Warning, /sdk/rust-qt-binding-generator/tests/rust_objects/src/interface.rs is written in an unsupported language. File is not indexed.

 /* generated by rust_qt_binding_generator */
 use libc::{c_char, c_ushort, c_int};
 use std::slice;
 use std::char::decode_utf16;
 
 use std::sync::Arc;
 use std::sync::atomic::{AtomicPtr, Ordering};
 use std::ptr::null;
 
 use implementation::*;
 
 
 pub enum QString {}
 
 fn set_string_from_utf16(s: &mut String, str: *const c_ushort, len: c_int) {
     let utf16 = unsafe { slice::from_raw_parts(str, to_usize(len)) };
     let characters = decode_utf16(utf16.iter().cloned())
         .map(|r| r.unwrap());
     s.clear();
     s.extend(characters);
 }
 
 
 
 fn to_usize(n: c_int) -> usize {
     if n < 0 {
         panic!("Cannot cast {} to usize", n);
     }
     n as usize
 }
 
 
 fn to_c_int(n: usize) -> c_int {
     if n > c_int::max_value() as usize {
         panic!("Cannot cast {} to c_int", n);
     }
     n as c_int
 }
 
 
 pub struct GroupQObject {}
 
 pub struct GroupEmitter {
     qobject: Arc<AtomicPtr<GroupQObject>>,
 }
 
 unsafe impl Send for GroupEmitter {}
 
 impl GroupEmitter {
     /// Clone the emitter
     ///
     /// The emitter can only be cloned when it is mutable. The emitter calls
     /// into C++ code which may call into Rust again. If emmitting is possible
     /// from immutable structures, that might lead to access to a mutable
     /// reference. That is undefined behaviour and forbidden.
     pub fn clone(&mut self) -> GroupEmitter {
         GroupEmitter {
             qobject: self.qobject.clone(),
         }
     }
     fn clear(&self) {
         let n: *const GroupQObject = null();
         self.qobject.store(n as *mut GroupQObject, Ordering::SeqCst);
     }
 }
 
 pub trait GroupTrait {
     fn new(emit: GroupEmitter,
         person: Person) -> Self;
     fn emit(&mut self) -> &mut GroupEmitter;
     fn person(&self) -> &Person;
     fn person_mut(&mut self) -> &mut Person;
 }
 
 #[no_mangle]
 pub extern "C" fn group_new(
     group: *mut GroupQObject,
     person: *mut PersonQObject,
     object: *mut InnerObjectQObject,
     object_description_changed: extern fn(*mut InnerObjectQObject),
 ) -> *mut Group {
     let object_emit = InnerObjectEmitter {
         qobject: Arc::new(AtomicPtr::new(object)),
         description_changed: object_description_changed,
     };
     let d_object = InnerObject::new(object_emit);
     let person_emit = PersonEmitter {
         qobject: Arc::new(AtomicPtr::new(person)),
     };
     let d_person = Person::new(person_emit,
         d_object);
     let group_emit = GroupEmitter {
         qobject: Arc::new(AtomicPtr::new(group)),
     };
     let d_group = Group::new(group_emit,
         d_person);
     Box::into_raw(Box::new(d_group))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn group_free(ptr: *mut Group) {
     Box::from_raw(ptr).emit().clear();
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn group_person_get(ptr: *mut Group) -> *mut Person {
     (&mut *ptr).person_mut()
 }
 
 pub struct InnerObjectQObject {}
 
 pub struct InnerObjectEmitter {
     qobject: Arc<AtomicPtr<InnerObjectQObject>>,
     description_changed: extern fn(*mut InnerObjectQObject),
 }
 
 unsafe impl Send for InnerObjectEmitter {}
 
 impl InnerObjectEmitter {
     /// Clone the emitter
     ///
     /// The emitter can only be cloned when it is mutable. The emitter calls
     /// into C++ code which may call into Rust again. If emmitting is possible
     /// from immutable structures, that might lead to access to a mutable
     /// reference. That is undefined behaviour and forbidden.
     pub fn clone(&mut self) -> InnerObjectEmitter {
         InnerObjectEmitter {
             qobject: self.qobject.clone(),
             description_changed: self.description_changed,
         }
     }
     fn clear(&self) {
         let n: *const InnerObjectQObject = null();
         self.qobject.store(n as *mut InnerObjectQObject, Ordering::SeqCst);
     }
     pub fn description_changed(&mut self) {
         let ptr = self.qobject.load(Ordering::SeqCst);
         if !ptr.is_null() {
             (self.description_changed)(ptr);
         }
     }
 }
 
 pub trait InnerObjectTrait {
     fn new(emit: InnerObjectEmitter) -> Self;
     fn emit(&mut self) -> &mut InnerObjectEmitter;
     fn description(&self) -> &str;
     fn set_description(&mut self, value: String);
 }
 
 #[no_mangle]
 pub extern "C" fn inner_object_new(
     inner_object: *mut InnerObjectQObject,
     inner_object_description_changed: extern fn(*mut InnerObjectQObject),
 ) -> *mut InnerObject {
     let inner_object_emit = InnerObjectEmitter {
         qobject: Arc::new(AtomicPtr::new(inner_object)),
         description_changed: inner_object_description_changed,
     };
     let d_inner_object = InnerObject::new(inner_object_emit);
     Box::into_raw(Box::new(d_inner_object))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn inner_object_free(ptr: *mut InnerObject) {
     Box::from_raw(ptr).emit().clear();
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn inner_object_description_get(
     ptr: *const InnerObject,
     p: *mut QString,
     set: extern fn(*mut QString, *const c_char, c_int),
 ) {
     let o = &*ptr;
     let v = o.description();
     let s: *const c_char = v.as_ptr() as *const c_char;
     set(p, s, to_c_int(v.len()));
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn inner_object_description_set(ptr: *mut InnerObject, v: *const c_ushort, len: c_int) {
     let o = &mut *ptr;
     let mut s = String::new();
     set_string_from_utf16(&mut s, v, len);
     o.set_description(s);
 }
 
 pub struct PersonQObject {}
 
 pub struct PersonEmitter {
     qobject: Arc<AtomicPtr<PersonQObject>>,
 }
 
 unsafe impl Send for PersonEmitter {}
 
 impl PersonEmitter {
     /// Clone the emitter
     ///
     /// The emitter can only be cloned when it is mutable. The emitter calls
     /// into C++ code which may call into Rust again. If emmitting is possible
     /// from immutable structures, that might lead to access to a mutable
     /// reference. That is undefined behaviour and forbidden.
     pub fn clone(&mut self) -> PersonEmitter {
         PersonEmitter {
             qobject: self.qobject.clone(),
         }
     }
     fn clear(&self) {
         let n: *const PersonQObject = null();
         self.qobject.store(n as *mut PersonQObject, Ordering::SeqCst);
     }
 }
 
 pub trait PersonTrait {
     fn new(emit: PersonEmitter,
         object: InnerObject) -> Self;
     fn emit(&mut self) -> &mut PersonEmitter;
     fn object(&self) -> &InnerObject;
     fn object_mut(&mut self) -> &mut InnerObject;
 }
 
 #[no_mangle]
 pub extern "C" fn person_new(
     person: *mut PersonQObject,
     object: *mut InnerObjectQObject,
     object_description_changed: extern fn(*mut InnerObjectQObject),
 ) -> *mut Person {
     let object_emit = InnerObjectEmitter {
         qobject: Arc::new(AtomicPtr::new(object)),
         description_changed: object_description_changed,
     };
     let d_object = InnerObject::new(object_emit);
     let person_emit = PersonEmitter {
         qobject: Arc::new(AtomicPtr::new(person)),
     };
     let d_person = Person::new(person_emit,
         d_object);
     Box::into_raw(Box::new(d_person))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn person_free(ptr: *mut Person) {
     Box::from_raw(ptr).emit().clear();
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn person_object_get(ptr: *mut Person) -> *mut InnerObject {
     (&mut *ptr).object_mut()
 }