diff --git a/demo/rust/src/interface.rs b/demo/rust/src/interface.rs index b8fdf89..ac0c9c2 100644 --- a/demo/rust/src/interface.rs +++ b/demo/rust/src/interface.rs @@ -1,1410 +1,1410 @@ /* 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::*; #[repr(C)] pub struct COption { data: T, some: bool, } impl COption { #![allow(dead_code)] fn into(self) -> Option { if self.some { Some(self.data) } else { None } } } impl From> for COption where T: Default, { fn from(t: Option) -> COption { if let Some(v) = t { COption { data: v, some: true, } } else { COption { data: T::default(), some: false, } } } } 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); } pub enum QByteArray {} #[repr(C)] #[derive(PartialEq, Eq, Debug)] pub enum SortOrder { Ascending = 0, Descending = 1, } #[repr(C)] pub struct QModelIndex { row: c_int, internal_id: usize, } 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 DemoQObject {} pub struct DemoEmitter { qobject: Arc>, } unsafe impl Send for DemoEmitter {} impl DemoEmitter { /// 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) -> DemoEmitter { DemoEmitter { qobject: self.qobject.clone(), } } fn clear(&self) { let n: *const DemoQObject = null(); self.qobject.store(n as *mut DemoQObject, Ordering::SeqCst); } } pub trait DemoTrait { fn new(emit: DemoEmitter, fibonacci: Fibonacci, fibonacci_list: FibonacciList, file_system_tree: FileSystemTree, processes: Processes, time_series: TimeSeries) -> Self; fn emit(&mut self) -> &mut DemoEmitter; fn fibonacci(&self) -> &Fibonacci; fn fibonacci_mut(&mut self) -> &mut Fibonacci; fn fibonacci_list(&self) -> &FibonacciList; fn fibonacci_list_mut(&mut self) -> &mut FibonacciList; fn file_system_tree(&self) -> &FileSystemTree; fn file_system_tree_mut(&mut self) -> &mut FileSystemTree; fn processes(&self) -> &Processes; fn processes_mut(&mut self) -> &mut Processes; fn time_series(&self) -> &TimeSeries; fn time_series_mut(&mut self) -> &mut TimeSeries; } #[no_mangle] pub extern "C" fn demo_new( demo: *mut DemoQObject, fibonacci: *mut FibonacciQObject, fibonacci_input_changed: fn(*mut FibonacciQObject), fibonacci_result_changed: fn(*mut FibonacciQObject), fibonacci_list: *mut FibonacciListQObject, fibonacci_list_new_data_ready: fn(*mut FibonacciListQObject), fibonacci_list_layout_about_to_be_changed: fn(*mut FibonacciListQObject), fibonacci_list_layout_changed: fn(*mut FibonacciListQObject), fibonacci_list_data_changed: fn(*mut FibonacciListQObject, usize, usize), fibonacci_list_begin_reset_model: fn(*mut FibonacciListQObject), fibonacci_list_end_reset_model: fn(*mut FibonacciListQObject), fibonacci_list_begin_insert_rows: fn(*mut FibonacciListQObject, usize, usize), fibonacci_list_end_insert_rows: fn(*mut FibonacciListQObject), fibonacci_list_begin_move_rows: fn(*mut FibonacciListQObject, usize, usize, usize), fibonacci_list_end_move_rows: fn(*mut FibonacciListQObject), fibonacci_list_begin_remove_rows: fn(*mut FibonacciListQObject, usize, usize), fibonacci_list_end_remove_rows: fn(*mut FibonacciListQObject), file_system_tree: *mut FileSystemTreeQObject, file_system_tree_path_changed: fn(*mut FileSystemTreeQObject), file_system_tree_new_data_ready: fn(*mut FileSystemTreeQObject, index: COption), file_system_tree_layout_about_to_be_changed: fn(*mut FileSystemTreeQObject), file_system_tree_layout_changed: fn(*mut FileSystemTreeQObject), file_system_tree_data_changed: fn(*mut FileSystemTreeQObject, usize, usize), file_system_tree_begin_reset_model: fn(*mut FileSystemTreeQObject), file_system_tree_end_reset_model: fn(*mut FileSystemTreeQObject), file_system_tree_begin_insert_rows: fn(*mut FileSystemTreeQObject, index: COption, usize, usize), file_system_tree_end_insert_rows: fn(*mut FileSystemTreeQObject), file_system_tree_begin_move_rows: fn(*mut FileSystemTreeQObject, index: COption, usize, usize, index: COption, usize), file_system_tree_end_move_rows: fn(*mut FileSystemTreeQObject), file_system_tree_begin_remove_rows: fn(*mut FileSystemTreeQObject, index: COption, usize, usize), file_system_tree_end_remove_rows: fn(*mut FileSystemTreeQObject), processes: *mut ProcessesQObject, processes_active_changed: fn(*mut ProcessesQObject), processes_new_data_ready: fn(*mut ProcessesQObject, index: COption), processes_layout_about_to_be_changed: fn(*mut ProcessesQObject), processes_layout_changed: fn(*mut ProcessesQObject), processes_data_changed: fn(*mut ProcessesQObject, usize, usize), processes_begin_reset_model: fn(*mut ProcessesQObject), processes_end_reset_model: fn(*mut ProcessesQObject), processes_begin_insert_rows: fn(*mut ProcessesQObject, index: COption, usize, usize), processes_end_insert_rows: fn(*mut ProcessesQObject), processes_begin_move_rows: fn(*mut ProcessesQObject, index: COption, usize, usize, index: COption, usize), processes_end_move_rows: fn(*mut ProcessesQObject), processes_begin_remove_rows: fn(*mut ProcessesQObject, index: COption, usize, usize), processes_end_remove_rows: fn(*mut ProcessesQObject), time_series: *mut TimeSeriesQObject, time_series_new_data_ready: fn(*mut TimeSeriesQObject), time_series_layout_about_to_be_changed: fn(*mut TimeSeriesQObject), time_series_layout_changed: fn(*mut TimeSeriesQObject), time_series_data_changed: fn(*mut TimeSeriesQObject, usize, usize), time_series_begin_reset_model: fn(*mut TimeSeriesQObject), time_series_end_reset_model: fn(*mut TimeSeriesQObject), time_series_begin_insert_rows: fn(*mut TimeSeriesQObject, usize, usize), time_series_end_insert_rows: fn(*mut TimeSeriesQObject), time_series_begin_move_rows: fn(*mut TimeSeriesQObject, usize, usize, usize), time_series_end_move_rows: fn(*mut TimeSeriesQObject), time_series_begin_remove_rows: fn(*mut TimeSeriesQObject, usize, usize), time_series_end_remove_rows: fn(*mut TimeSeriesQObject), ) -> *mut Demo { let fibonacci_emit = FibonacciEmitter { qobject: Arc::new(AtomicPtr::new(fibonacci)), input_changed: fibonacci_input_changed, result_changed: fibonacci_result_changed, }; let d_fibonacci = Fibonacci::new(fibonacci_emit); let fibonacci_list_emit = FibonacciListEmitter { qobject: Arc::new(AtomicPtr::new(fibonacci_list)), new_data_ready: fibonacci_list_new_data_ready, }; let model = FibonacciListList { qobject: fibonacci_list, layout_about_to_be_changed: fibonacci_list_layout_about_to_be_changed, layout_changed: fibonacci_list_layout_changed, data_changed: fibonacci_list_data_changed, begin_reset_model: fibonacci_list_begin_reset_model, end_reset_model: fibonacci_list_end_reset_model, begin_insert_rows: fibonacci_list_begin_insert_rows, end_insert_rows: fibonacci_list_end_insert_rows, begin_move_rows: fibonacci_list_begin_move_rows, end_move_rows: fibonacci_list_end_move_rows, begin_remove_rows: fibonacci_list_begin_remove_rows, end_remove_rows: fibonacci_list_end_remove_rows, }; let d_fibonacci_list = FibonacciList::new(fibonacci_list_emit, model); let file_system_tree_emit = FileSystemTreeEmitter { qobject: Arc::new(AtomicPtr::new(file_system_tree)), path_changed: file_system_tree_path_changed, new_data_ready: file_system_tree_new_data_ready, }; let model = FileSystemTreeTree { qobject: file_system_tree, layout_about_to_be_changed: file_system_tree_layout_about_to_be_changed, layout_changed: file_system_tree_layout_changed, data_changed: file_system_tree_data_changed, begin_reset_model: file_system_tree_begin_reset_model, end_reset_model: file_system_tree_end_reset_model, begin_insert_rows: file_system_tree_begin_insert_rows, end_insert_rows: file_system_tree_end_insert_rows, begin_move_rows: file_system_tree_begin_move_rows, end_move_rows: file_system_tree_end_move_rows, begin_remove_rows: file_system_tree_begin_remove_rows, end_remove_rows: file_system_tree_end_remove_rows, }; let d_file_system_tree = FileSystemTree::new(file_system_tree_emit, model); let processes_emit = ProcessesEmitter { qobject: Arc::new(AtomicPtr::new(processes)), active_changed: processes_active_changed, new_data_ready: processes_new_data_ready, }; let model = ProcessesTree { qobject: processes, layout_about_to_be_changed: processes_layout_about_to_be_changed, layout_changed: processes_layout_changed, data_changed: processes_data_changed, begin_reset_model: processes_begin_reset_model, end_reset_model: processes_end_reset_model, begin_insert_rows: processes_begin_insert_rows, end_insert_rows: processes_end_insert_rows, begin_move_rows: processes_begin_move_rows, end_move_rows: processes_end_move_rows, begin_remove_rows: processes_begin_remove_rows, end_remove_rows: processes_end_remove_rows, }; let d_processes = Processes::new(processes_emit, model); let time_series_emit = TimeSeriesEmitter { qobject: Arc::new(AtomicPtr::new(time_series)), new_data_ready: time_series_new_data_ready, }; let model = TimeSeriesList { qobject: time_series, layout_about_to_be_changed: time_series_layout_about_to_be_changed, layout_changed: time_series_layout_changed, data_changed: time_series_data_changed, begin_reset_model: time_series_begin_reset_model, end_reset_model: time_series_end_reset_model, begin_insert_rows: time_series_begin_insert_rows, end_insert_rows: time_series_end_insert_rows, begin_move_rows: time_series_begin_move_rows, end_move_rows: time_series_end_move_rows, begin_remove_rows: time_series_begin_remove_rows, end_remove_rows: time_series_end_remove_rows, }; let d_time_series = TimeSeries::new(time_series_emit, model); let demo_emit = DemoEmitter { qobject: Arc::new(AtomicPtr::new(demo)), }; let d_demo = Demo::new(demo_emit, d_fibonacci, d_fibonacci_list, d_file_system_tree, d_processes, d_time_series); Box::into_raw(Box::new(d_demo)) } #[no_mangle] pub unsafe extern "C" fn demo_free(ptr: *mut Demo) { Box::from_raw(ptr).emit().clear(); } #[no_mangle] pub unsafe extern "C" fn demo_fibonacci_get(ptr: *mut Demo) -> *mut Fibonacci { (&mut *ptr).fibonacci_mut() } #[no_mangle] pub unsafe extern "C" fn demo_fibonacci_list_get(ptr: *mut Demo) -> *mut FibonacciList { (&mut *ptr).fibonacci_list_mut() } #[no_mangle] pub unsafe extern "C" fn demo_file_system_tree_get(ptr: *mut Demo) -> *mut FileSystemTree { (&mut *ptr).file_system_tree_mut() } #[no_mangle] pub unsafe extern "C" fn demo_processes_get(ptr: *mut Demo) -> *mut Processes { (&mut *ptr).processes_mut() } #[no_mangle] pub unsafe extern "C" fn demo_time_series_get(ptr: *mut Demo) -> *mut TimeSeries { (&mut *ptr).time_series_mut() } pub struct FibonacciQObject {} pub struct FibonacciEmitter { qobject: Arc>, input_changed: fn(*mut FibonacciQObject), result_changed: fn(*mut FibonacciQObject), } unsafe impl Send for FibonacciEmitter {} impl FibonacciEmitter { /// 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) -> FibonacciEmitter { FibonacciEmitter { qobject: self.qobject.clone(), input_changed: self.input_changed, result_changed: self.result_changed, } } fn clear(&self) { let n: *const FibonacciQObject = null(); self.qobject.store(n as *mut FibonacciQObject, Ordering::SeqCst); } pub fn input_changed(&mut self) { let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() { (self.input_changed)(ptr); } } pub fn result_changed(&mut self) { let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() { (self.result_changed)(ptr); } } } pub trait FibonacciTrait { fn new(emit: FibonacciEmitter) -> Self; fn emit(&mut self) -> &mut FibonacciEmitter; fn input(&self) -> u32; fn set_input(&mut self, value: u32); fn result(&self) -> u64; } #[no_mangle] pub extern "C" fn fibonacci_new( fibonacci: *mut FibonacciQObject, fibonacci_input_changed: fn(*mut FibonacciQObject), fibonacci_result_changed: fn(*mut FibonacciQObject), ) -> *mut Fibonacci { let fibonacci_emit = FibonacciEmitter { qobject: Arc::new(AtomicPtr::new(fibonacci)), input_changed: fibonacci_input_changed, result_changed: fibonacci_result_changed, }; let d_fibonacci = Fibonacci::new(fibonacci_emit); Box::into_raw(Box::new(d_fibonacci)) } #[no_mangle] pub unsafe extern "C" fn fibonacci_free(ptr: *mut Fibonacci) { Box::from_raw(ptr).emit().clear(); } #[no_mangle] pub unsafe extern "C" fn fibonacci_input_get(ptr: *const Fibonacci) -> u32 { (&*ptr).input() } #[no_mangle] pub unsafe extern "C" fn fibonacci_input_set(ptr: *mut Fibonacci, v: u32) { (&mut *ptr).set_input(v); } #[no_mangle] pub unsafe extern "C" fn fibonacci_result_get(ptr: *const Fibonacci) -> u64 { (&*ptr).result() } pub struct FibonacciListQObject {} pub struct FibonacciListEmitter { qobject: Arc>, new_data_ready: fn(*mut FibonacciListQObject), } unsafe impl Send for FibonacciListEmitter {} impl FibonacciListEmitter { /// 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) -> FibonacciListEmitter { FibonacciListEmitter { qobject: self.qobject.clone(), new_data_ready: self.new_data_ready, } } fn clear(&self) { let n: *const FibonacciListQObject = null(); self.qobject.store(n as *mut FibonacciListQObject, Ordering::SeqCst); } pub fn new_data_ready(&mut self) { let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() { (self.new_data_ready)(ptr); } } } #[derive(Clone)] pub struct FibonacciListList { qobject: *mut FibonacciListQObject, layout_about_to_be_changed: fn(*mut FibonacciListQObject), layout_changed: fn(*mut FibonacciListQObject), data_changed: fn(*mut FibonacciListQObject, usize, usize), begin_reset_model: fn(*mut FibonacciListQObject), end_reset_model: fn(*mut FibonacciListQObject), begin_insert_rows: fn(*mut FibonacciListQObject, usize, usize), end_insert_rows: fn(*mut FibonacciListQObject), begin_move_rows: fn(*mut FibonacciListQObject, usize, usize, usize), end_move_rows: fn(*mut FibonacciListQObject), begin_remove_rows: fn(*mut FibonacciListQObject, usize, usize), end_remove_rows: fn(*mut FibonacciListQObject), } impl FibonacciListList { pub fn layout_about_to_be_changed(&mut self) { (self.layout_about_to_be_changed)(self.qobject); } pub fn layout_changed(&mut self) { (self.layout_changed)(self.qobject); } pub fn data_changed(&mut self, first: usize, last: usize) { (self.data_changed)(self.qobject, first, last); } pub fn begin_reset_model(&mut self) { (self.begin_reset_model)(self.qobject); } pub fn end_reset_model(&mut self) { (self.end_reset_model)(self.qobject); } pub fn begin_insert_rows(&mut self, first: usize, last: usize) { (self.begin_insert_rows)(self.qobject, first, last); } pub fn end_insert_rows(&mut self) { (self.end_insert_rows)(self.qobject); } pub fn begin_move_rows(&mut self, first: usize, last: usize, destination: usize) { (self.begin_move_rows)(self.qobject, first, last, destination); } pub fn end_move_rows(&mut self) { (self.end_move_rows)(self.qobject); } pub fn begin_remove_rows(&mut self, first: usize, last: usize) { (self.begin_remove_rows)(self.qobject, first, last); } pub fn end_remove_rows(&mut self) { (self.end_remove_rows)(self.qobject); } } pub trait FibonacciListTrait { fn new(emit: FibonacciListEmitter, model: FibonacciListList) -> Self; fn emit(&mut self) -> &mut FibonacciListEmitter; fn row_count(&self) -> usize; fn insert_rows(&mut self, _row: usize, _count: usize) -> bool { false } fn remove_rows(&mut self, _row: usize, _count: usize) -> bool { false } fn can_fetch_more(&self) -> bool { false } fn fetch_more(&mut self) {} - fn sort(&mut self, u8, SortOrder) {} + fn sort(&mut self, _: u8, _: SortOrder) {} fn fibonacci_number(&self, index: usize) -> u64; fn row(&self, index: usize) -> u64; } #[no_mangle] pub extern "C" fn fibonacci_list_new( fibonacci_list: *mut FibonacciListQObject, fibonacci_list_new_data_ready: fn(*mut FibonacciListQObject), fibonacci_list_layout_about_to_be_changed: fn(*mut FibonacciListQObject), fibonacci_list_layout_changed: fn(*mut FibonacciListQObject), fibonacci_list_data_changed: fn(*mut FibonacciListQObject, usize, usize), fibonacci_list_begin_reset_model: fn(*mut FibonacciListQObject), fibonacci_list_end_reset_model: fn(*mut FibonacciListQObject), fibonacci_list_begin_insert_rows: fn(*mut FibonacciListQObject, usize, usize), fibonacci_list_end_insert_rows: fn(*mut FibonacciListQObject), fibonacci_list_begin_move_rows: fn(*mut FibonacciListQObject, usize, usize, usize), fibonacci_list_end_move_rows: fn(*mut FibonacciListQObject), fibonacci_list_begin_remove_rows: fn(*mut FibonacciListQObject, usize, usize), fibonacci_list_end_remove_rows: fn(*mut FibonacciListQObject), ) -> *mut FibonacciList { let fibonacci_list_emit = FibonacciListEmitter { qobject: Arc::new(AtomicPtr::new(fibonacci_list)), new_data_ready: fibonacci_list_new_data_ready, }; let model = FibonacciListList { qobject: fibonacci_list, layout_about_to_be_changed: fibonacci_list_layout_about_to_be_changed, layout_changed: fibonacci_list_layout_changed, data_changed: fibonacci_list_data_changed, begin_reset_model: fibonacci_list_begin_reset_model, end_reset_model: fibonacci_list_end_reset_model, begin_insert_rows: fibonacci_list_begin_insert_rows, end_insert_rows: fibonacci_list_end_insert_rows, begin_move_rows: fibonacci_list_begin_move_rows, end_move_rows: fibonacci_list_end_move_rows, begin_remove_rows: fibonacci_list_begin_remove_rows, end_remove_rows: fibonacci_list_end_remove_rows, }; let d_fibonacci_list = FibonacciList::new(fibonacci_list_emit, model); Box::into_raw(Box::new(d_fibonacci_list)) } #[no_mangle] pub unsafe extern "C" fn fibonacci_list_free(ptr: *mut FibonacciList) { Box::from_raw(ptr).emit().clear(); } #[no_mangle] pub unsafe extern "C" fn fibonacci_list_row_count(ptr: *const FibonacciList) -> c_int { to_c_int((&*ptr).row_count()) } #[no_mangle] pub unsafe extern "C" fn fibonacci_list_insert_rows(ptr: *mut FibonacciList, row: c_int, count: c_int) -> bool { (&mut *ptr).insert_rows(to_usize(row), to_usize(count)) } #[no_mangle] pub unsafe extern "C" fn fibonacci_list_remove_rows(ptr: *mut FibonacciList, row: c_int, count: c_int) -> bool { (&mut *ptr).remove_rows(to_usize(row), to_usize(count)) } #[no_mangle] pub unsafe extern "C" fn fibonacci_list_can_fetch_more(ptr: *const FibonacciList) -> bool { (&*ptr).can_fetch_more() } #[no_mangle] pub unsafe extern "C" fn fibonacci_list_fetch_more(ptr: *mut FibonacciList) { (&mut *ptr).fetch_more() } #[no_mangle] pub unsafe extern "C" fn fibonacci_list_sort( ptr: *mut FibonacciList, column: u8, order: SortOrder, ) { (&mut *ptr).sort(column, order) } #[no_mangle] pub unsafe extern "C" fn fibonacci_list_data_fibonacci_number(ptr: *const FibonacciList, row: c_int) -> u64 { let o = &*ptr; o.fibonacci_number(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn fibonacci_list_data_row(ptr: *const FibonacciList, row: c_int) -> u64 { let o = &*ptr; o.row(to_usize(row)).into() } pub struct FileSystemTreeQObject {} pub struct FileSystemTreeEmitter { qobject: Arc>, path_changed: fn(*mut FileSystemTreeQObject), new_data_ready: fn(*mut FileSystemTreeQObject, index: COption), } unsafe impl Send for FileSystemTreeEmitter {} impl FileSystemTreeEmitter { /// 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) -> FileSystemTreeEmitter { FileSystemTreeEmitter { qobject: self.qobject.clone(), path_changed: self.path_changed, new_data_ready: self.new_data_ready, } } fn clear(&self) { let n: *const FileSystemTreeQObject = null(); self.qobject.store(n as *mut FileSystemTreeQObject, Ordering::SeqCst); } pub fn path_changed(&mut self) { let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() { (self.path_changed)(ptr); } } pub fn new_data_ready(&mut self, item: Option) { let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() { (self.new_data_ready)(ptr, item.into()); } } } #[derive(Clone)] pub struct FileSystemTreeTree { qobject: *mut FileSystemTreeQObject, layout_about_to_be_changed: fn(*mut FileSystemTreeQObject), layout_changed: fn(*mut FileSystemTreeQObject), data_changed: fn(*mut FileSystemTreeQObject, usize, usize), begin_reset_model: fn(*mut FileSystemTreeQObject), end_reset_model: fn(*mut FileSystemTreeQObject), begin_insert_rows: fn(*mut FileSystemTreeQObject, index: COption, usize, usize), end_insert_rows: fn(*mut FileSystemTreeQObject), begin_move_rows: fn(*mut FileSystemTreeQObject, index: COption, usize, usize, dest: COption, usize), end_move_rows: fn(*mut FileSystemTreeQObject), begin_remove_rows: fn(*mut FileSystemTreeQObject, index: COption, usize, usize), end_remove_rows: fn(*mut FileSystemTreeQObject), } impl FileSystemTreeTree { pub fn layout_about_to_be_changed(&mut self) { (self.layout_about_to_be_changed)(self.qobject); } pub fn layout_changed(&mut self) { (self.layout_changed)(self.qobject); } pub fn data_changed(&mut self, first: usize, last: usize) { (self.data_changed)(self.qobject, first, last); } pub fn begin_reset_model(&mut self) { (self.begin_reset_model)(self.qobject); } pub fn end_reset_model(&mut self) { (self.end_reset_model)(self.qobject); } pub fn begin_insert_rows(&mut self, index: Option, first: usize, last: usize) { (self.begin_insert_rows)(self.qobject, index.into(), first, last); } pub fn end_insert_rows(&mut self) { (self.end_insert_rows)(self.qobject); } pub fn begin_move_rows(&mut self, index: Option, first: usize, last: usize, dest: Option, destination: usize) { (self.begin_move_rows)(self.qobject, index.into(), first, last, dest.into(), destination); } pub fn end_move_rows(&mut self) { (self.end_move_rows)(self.qobject); } pub fn begin_remove_rows(&mut self, index: Option, first: usize, last: usize) { (self.begin_remove_rows)(self.qobject, index.into(), first, last); } pub fn end_remove_rows(&mut self) { (self.end_remove_rows)(self.qobject); } } pub trait FileSystemTreeTrait { fn new(emit: FileSystemTreeEmitter, model: FileSystemTreeTree) -> Self; fn emit(&mut self) -> &mut FileSystemTreeEmitter; fn path(&self) -> Option<&str>; fn set_path(&mut self, value: Option); - fn row_count(&self, Option) -> usize; - fn can_fetch_more(&self, Option) -> bool { + fn row_count(&self, _: Option) -> usize; + fn can_fetch_more(&self, _: Option) -> bool { false } - fn fetch_more(&mut self, Option) {} - fn sort(&mut self, u8, SortOrder) {} + fn fetch_more(&mut self, _: Option) {} + fn sort(&mut self, _: u8, _: SortOrder) {} fn check_row(&self, index: usize, row: usize) -> Option; fn index(&self, item: Option, row: usize) -> usize; fn parent(&self, index: usize) -> Option; fn row(&self, index: usize) -> usize; fn file_icon(&self, index: usize) -> &[u8]; fn file_name(&self, index: usize) -> String; fn file_path(&self, index: usize) -> Option; fn file_permissions(&self, index: usize) -> i32; fn file_size(&self, index: usize) -> Option; fn file_type(&self, index: usize) -> i32; } #[no_mangle] pub extern "C" fn file_system_tree_new( file_system_tree: *mut FileSystemTreeQObject, file_system_tree_path_changed: fn(*mut FileSystemTreeQObject), file_system_tree_new_data_ready: fn(*mut FileSystemTreeQObject, index: COption), file_system_tree_layout_about_to_be_changed: fn(*mut FileSystemTreeQObject), file_system_tree_layout_changed: fn(*mut FileSystemTreeQObject), file_system_tree_data_changed: fn(*mut FileSystemTreeQObject, usize, usize), file_system_tree_begin_reset_model: fn(*mut FileSystemTreeQObject), file_system_tree_end_reset_model: fn(*mut FileSystemTreeQObject), file_system_tree_begin_insert_rows: fn(*mut FileSystemTreeQObject, index: COption, usize, usize), file_system_tree_end_insert_rows: fn(*mut FileSystemTreeQObject), file_system_tree_begin_move_rows: fn(*mut FileSystemTreeQObject, index: COption, usize, usize, index: COption, usize), file_system_tree_end_move_rows: fn(*mut FileSystemTreeQObject), file_system_tree_begin_remove_rows: fn(*mut FileSystemTreeQObject, index: COption, usize, usize), file_system_tree_end_remove_rows: fn(*mut FileSystemTreeQObject), ) -> *mut FileSystemTree { let file_system_tree_emit = FileSystemTreeEmitter { qobject: Arc::new(AtomicPtr::new(file_system_tree)), path_changed: file_system_tree_path_changed, new_data_ready: file_system_tree_new_data_ready, }; let model = FileSystemTreeTree { qobject: file_system_tree, layout_about_to_be_changed: file_system_tree_layout_about_to_be_changed, layout_changed: file_system_tree_layout_changed, data_changed: file_system_tree_data_changed, begin_reset_model: file_system_tree_begin_reset_model, end_reset_model: file_system_tree_end_reset_model, begin_insert_rows: file_system_tree_begin_insert_rows, end_insert_rows: file_system_tree_end_insert_rows, begin_move_rows: file_system_tree_begin_move_rows, end_move_rows: file_system_tree_end_move_rows, begin_remove_rows: file_system_tree_begin_remove_rows, end_remove_rows: file_system_tree_end_remove_rows, }; let d_file_system_tree = FileSystemTree::new(file_system_tree_emit, model); Box::into_raw(Box::new(d_file_system_tree)) } #[no_mangle] pub unsafe extern "C" fn file_system_tree_free(ptr: *mut FileSystemTree) { Box::from_raw(ptr).emit().clear(); } #[no_mangle] pub unsafe extern "C" fn file_system_tree_path_get( ptr: *const FileSystemTree, p: *mut QString, set: fn(*mut QString, *const c_char, c_int), ) { let o = &*ptr; let v = o.path(); if let Some(v) = v { 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 file_system_tree_path_set(ptr: *mut FileSystemTree, 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_path(Some(s)); } #[no_mangle] pub unsafe extern "C" fn file_system_tree_path_set_none(ptr: *mut FileSystemTree) { let o = &mut *ptr; o.set_path(None); } #[no_mangle] pub unsafe extern "C" fn file_system_tree_row_count( ptr: *const FileSystemTree, index: COption, ) -> c_int { to_c_int((&*ptr).row_count(index.into())) } #[no_mangle] pub unsafe extern "C" fn file_system_tree_can_fetch_more( ptr: *const FileSystemTree, index: COption, ) -> bool { (&*ptr).can_fetch_more(index.into()) } #[no_mangle] pub unsafe extern "C" fn file_system_tree_fetch_more(ptr: *mut FileSystemTree, index: COption) { (&mut *ptr).fetch_more(index.into()) } #[no_mangle] pub unsafe extern "C" fn file_system_tree_sort( ptr: *mut FileSystemTree, column: u8, order: SortOrder ) { (&mut *ptr).sort(column, order) } #[no_mangle] pub unsafe extern "C" fn file_system_tree_check_row( ptr: *const FileSystemTree, index: usize, row: c_int, ) -> COption { (&*ptr).check_row(index.into(), to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn file_system_tree_index( ptr: *const FileSystemTree, index: COption, row: c_int, ) -> usize { (&*ptr).index(index.into(), to_usize(row)) } #[no_mangle] pub unsafe extern "C" fn file_system_tree_parent(ptr: *const FileSystemTree, index: usize) -> QModelIndex { if let Some(parent) = (&*ptr).parent(index) { QModelIndex { row: to_c_int((&*ptr).row(parent)), internal_id: parent, } } else { QModelIndex { row: -1, internal_id: 0, } } } #[no_mangle] pub unsafe extern "C" fn file_system_tree_row(ptr: *const FileSystemTree, index: usize) -> c_int { to_c_int((&*ptr).row(index)) } #[no_mangle] pub unsafe extern "C" fn file_system_tree_data_file_icon( ptr: *const FileSystemTree, index: usize, d: *mut QByteArray, set: fn(*mut QByteArray, *const c_char, len: c_int), ) { let o = &*ptr; let data = o.file_icon(index); let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); } #[no_mangle] pub unsafe extern "C" fn file_system_tree_data_file_name( ptr: *const FileSystemTree, index: usize, d: *mut QString, set: fn(*mut QString, *const c_char, len: c_int), ) { let o = &*ptr; let data = o.file_name(index); let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); } #[no_mangle] pub unsafe extern "C" fn file_system_tree_data_file_path( ptr: *const FileSystemTree, index: usize, d: *mut QString, set: fn(*mut QString, *const c_char, len: c_int), ) { let o = &*ptr; let data = o.file_path(index); if let Some(data) = data { let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); } } #[no_mangle] pub unsafe extern "C" fn file_system_tree_data_file_permissions(ptr: *const FileSystemTree, index: usize) -> i32 { let o = &*ptr; o.file_permissions(index).into() } #[no_mangle] pub unsafe extern "C" fn file_system_tree_data_file_size(ptr: *const FileSystemTree, index: usize) -> COption { let o = &*ptr; o.file_size(index).into() } #[no_mangle] pub unsafe extern "C" fn file_system_tree_data_file_type(ptr: *const FileSystemTree, index: usize) -> i32 { let o = &*ptr; o.file_type(index).into() } pub struct ProcessesQObject {} pub struct ProcessesEmitter { qobject: Arc>, active_changed: fn(*mut ProcessesQObject), new_data_ready: fn(*mut ProcessesQObject, index: COption), } unsafe impl Send for ProcessesEmitter {} impl ProcessesEmitter { /// 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) -> ProcessesEmitter { ProcessesEmitter { qobject: self.qobject.clone(), active_changed: self.active_changed, new_data_ready: self.new_data_ready, } } fn clear(&self) { let n: *const ProcessesQObject = null(); self.qobject.store(n as *mut ProcessesQObject, Ordering::SeqCst); } pub fn active_changed(&mut self) { let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() { (self.active_changed)(ptr); } } pub fn new_data_ready(&mut self, item: Option) { let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() { (self.new_data_ready)(ptr, item.into()); } } } #[derive(Clone)] pub struct ProcessesTree { qobject: *mut ProcessesQObject, layout_about_to_be_changed: fn(*mut ProcessesQObject), layout_changed: fn(*mut ProcessesQObject), data_changed: fn(*mut ProcessesQObject, usize, usize), begin_reset_model: fn(*mut ProcessesQObject), end_reset_model: fn(*mut ProcessesQObject), begin_insert_rows: fn(*mut ProcessesQObject, index: COption, usize, usize), end_insert_rows: fn(*mut ProcessesQObject), begin_move_rows: fn(*mut ProcessesQObject, index: COption, usize, usize, dest: COption, usize), end_move_rows: fn(*mut ProcessesQObject), begin_remove_rows: fn(*mut ProcessesQObject, index: COption, usize, usize), end_remove_rows: fn(*mut ProcessesQObject), } impl ProcessesTree { pub fn layout_about_to_be_changed(&mut self) { (self.layout_about_to_be_changed)(self.qobject); } pub fn layout_changed(&mut self) { (self.layout_changed)(self.qobject); } pub fn data_changed(&mut self, first: usize, last: usize) { (self.data_changed)(self.qobject, first, last); } pub fn begin_reset_model(&mut self) { (self.begin_reset_model)(self.qobject); } pub fn end_reset_model(&mut self) { (self.end_reset_model)(self.qobject); } pub fn begin_insert_rows(&mut self, index: Option, first: usize, last: usize) { (self.begin_insert_rows)(self.qobject, index.into(), first, last); } pub fn end_insert_rows(&mut self) { (self.end_insert_rows)(self.qobject); } pub fn begin_move_rows(&mut self, index: Option, first: usize, last: usize, dest: Option, destination: usize) { (self.begin_move_rows)(self.qobject, index.into(), first, last, dest.into(), destination); } pub fn end_move_rows(&mut self) { (self.end_move_rows)(self.qobject); } pub fn begin_remove_rows(&mut self, index: Option, first: usize, last: usize) { (self.begin_remove_rows)(self.qobject, index.into(), first, last); } pub fn end_remove_rows(&mut self) { (self.end_remove_rows)(self.qobject); } } pub trait ProcessesTrait { fn new(emit: ProcessesEmitter, model: ProcessesTree) -> Self; fn emit(&mut self) -> &mut ProcessesEmitter; fn active(&self) -> bool; fn set_active(&mut self, value: bool); - fn row_count(&self, Option) -> usize; - fn can_fetch_more(&self, Option) -> bool { + fn row_count(&self, _: Option) -> usize; + fn can_fetch_more(&self, _: Option) -> bool { false } - fn fetch_more(&mut self, Option) {} - fn sort(&mut self, u8, SortOrder) {} + fn fetch_more(&mut self, _: Option) {} + fn sort(&mut self, _: u8, _: SortOrder) {} fn check_row(&self, index: usize, row: usize) -> Option; fn index(&self, item: Option, row: usize) -> usize; fn parent(&self, index: usize) -> Option; fn row(&self, index: usize) -> usize; fn cmd(&self, index: usize) -> String; fn cpu_percentage(&self, index: usize) -> u8; fn cpu_usage(&self, index: usize) -> f32; fn memory(&self, index: usize) -> u64; fn name(&self, index: usize) -> &str; fn pid(&self, index: usize) -> u32; fn uid(&self, index: usize) -> u32; } #[no_mangle] pub extern "C" fn processes_new( processes: *mut ProcessesQObject, processes_active_changed: fn(*mut ProcessesQObject), processes_new_data_ready: fn(*mut ProcessesQObject, index: COption), processes_layout_about_to_be_changed: fn(*mut ProcessesQObject), processes_layout_changed: fn(*mut ProcessesQObject), processes_data_changed: fn(*mut ProcessesQObject, usize, usize), processes_begin_reset_model: fn(*mut ProcessesQObject), processes_end_reset_model: fn(*mut ProcessesQObject), processes_begin_insert_rows: fn(*mut ProcessesQObject, index: COption, usize, usize), processes_end_insert_rows: fn(*mut ProcessesQObject), processes_begin_move_rows: fn(*mut ProcessesQObject, index: COption, usize, usize, index: COption, usize), processes_end_move_rows: fn(*mut ProcessesQObject), processes_begin_remove_rows: fn(*mut ProcessesQObject, index: COption, usize, usize), processes_end_remove_rows: fn(*mut ProcessesQObject), ) -> *mut Processes { let processes_emit = ProcessesEmitter { qobject: Arc::new(AtomicPtr::new(processes)), active_changed: processes_active_changed, new_data_ready: processes_new_data_ready, }; let model = ProcessesTree { qobject: processes, layout_about_to_be_changed: processes_layout_about_to_be_changed, layout_changed: processes_layout_changed, data_changed: processes_data_changed, begin_reset_model: processes_begin_reset_model, end_reset_model: processes_end_reset_model, begin_insert_rows: processes_begin_insert_rows, end_insert_rows: processes_end_insert_rows, begin_move_rows: processes_begin_move_rows, end_move_rows: processes_end_move_rows, begin_remove_rows: processes_begin_remove_rows, end_remove_rows: processes_end_remove_rows, }; let d_processes = Processes::new(processes_emit, model); Box::into_raw(Box::new(d_processes)) } #[no_mangle] pub unsafe extern "C" fn processes_free(ptr: *mut Processes) { Box::from_raw(ptr).emit().clear(); } #[no_mangle] pub unsafe extern "C" fn processes_active_get(ptr: *const Processes) -> bool { (&*ptr).active() } #[no_mangle] pub unsafe extern "C" fn processes_active_set(ptr: *mut Processes, v: bool) { (&mut *ptr).set_active(v); } #[no_mangle] pub unsafe extern "C" fn processes_row_count( ptr: *const Processes, index: COption, ) -> c_int { to_c_int((&*ptr).row_count(index.into())) } #[no_mangle] pub unsafe extern "C" fn processes_can_fetch_more( ptr: *const Processes, index: COption, ) -> bool { (&*ptr).can_fetch_more(index.into()) } #[no_mangle] pub unsafe extern "C" fn processes_fetch_more(ptr: *mut Processes, index: COption) { (&mut *ptr).fetch_more(index.into()) } #[no_mangle] pub unsafe extern "C" fn processes_sort( ptr: *mut Processes, column: u8, order: SortOrder ) { (&mut *ptr).sort(column, order) } #[no_mangle] pub unsafe extern "C" fn processes_check_row( ptr: *const Processes, index: usize, row: c_int, ) -> COption { (&*ptr).check_row(index.into(), to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn processes_index( ptr: *const Processes, index: COption, row: c_int, ) -> usize { (&*ptr).index(index.into(), to_usize(row)) } #[no_mangle] pub unsafe extern "C" fn processes_parent(ptr: *const Processes, index: usize) -> QModelIndex { if let Some(parent) = (&*ptr).parent(index) { QModelIndex { row: to_c_int((&*ptr).row(parent)), internal_id: parent, } } else { QModelIndex { row: -1, internal_id: 0, } } } #[no_mangle] pub unsafe extern "C" fn processes_row(ptr: *const Processes, index: usize) -> c_int { to_c_int((&*ptr).row(index)) } #[no_mangle] pub unsafe extern "C" fn processes_data_cmd( ptr: *const Processes, index: usize, d: *mut QString, set: fn(*mut QString, *const c_char, len: c_int), ) { let o = &*ptr; let data = o.cmd(index); let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); } #[no_mangle] pub unsafe extern "C" fn processes_data_cpu_percentage(ptr: *const Processes, index: usize) -> u8 { let o = &*ptr; o.cpu_percentage(index).into() } #[no_mangle] pub unsafe extern "C" fn processes_data_cpu_usage(ptr: *const Processes, index: usize) -> f32 { let o = &*ptr; o.cpu_usage(index).into() } #[no_mangle] pub unsafe extern "C" fn processes_data_memory(ptr: *const Processes, index: usize) -> u64 { let o = &*ptr; o.memory(index).into() } #[no_mangle] pub unsafe extern "C" fn processes_data_name( ptr: *const Processes, index: usize, d: *mut QString, set: fn(*mut QString, *const c_char, len: c_int), ) { let o = &*ptr; let data = o.name(index); let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); } #[no_mangle] pub unsafe extern "C" fn processes_data_pid(ptr: *const Processes, index: usize) -> u32 { let o = &*ptr; o.pid(index).into() } #[no_mangle] pub unsafe extern "C" fn processes_data_uid(ptr: *const Processes, index: usize) -> u32 { let o = &*ptr; o.uid(index).into() } pub struct TimeSeriesQObject {} pub struct TimeSeriesEmitter { qobject: Arc>, new_data_ready: fn(*mut TimeSeriesQObject), } unsafe impl Send for TimeSeriesEmitter {} impl TimeSeriesEmitter { /// 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) -> TimeSeriesEmitter { TimeSeriesEmitter { qobject: self.qobject.clone(), new_data_ready: self.new_data_ready, } } fn clear(&self) { let n: *const TimeSeriesQObject = null(); self.qobject.store(n as *mut TimeSeriesQObject, Ordering::SeqCst); } pub fn new_data_ready(&mut self) { let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() { (self.new_data_ready)(ptr); } } } #[derive(Clone)] pub struct TimeSeriesList { qobject: *mut TimeSeriesQObject, layout_about_to_be_changed: fn(*mut TimeSeriesQObject), layout_changed: fn(*mut TimeSeriesQObject), data_changed: fn(*mut TimeSeriesQObject, usize, usize), begin_reset_model: fn(*mut TimeSeriesQObject), end_reset_model: fn(*mut TimeSeriesQObject), begin_insert_rows: fn(*mut TimeSeriesQObject, usize, usize), end_insert_rows: fn(*mut TimeSeriesQObject), begin_move_rows: fn(*mut TimeSeriesQObject, usize, usize, usize), end_move_rows: fn(*mut TimeSeriesQObject), begin_remove_rows: fn(*mut TimeSeriesQObject, usize, usize), end_remove_rows: fn(*mut TimeSeriesQObject), } impl TimeSeriesList { pub fn layout_about_to_be_changed(&mut self) { (self.layout_about_to_be_changed)(self.qobject); } pub fn layout_changed(&mut self) { (self.layout_changed)(self.qobject); } pub fn data_changed(&mut self, first: usize, last: usize) { (self.data_changed)(self.qobject, first, last); } pub fn begin_reset_model(&mut self) { (self.begin_reset_model)(self.qobject); } pub fn end_reset_model(&mut self) { (self.end_reset_model)(self.qobject); } pub fn begin_insert_rows(&mut self, first: usize, last: usize) { (self.begin_insert_rows)(self.qobject, first, last); } pub fn end_insert_rows(&mut self) { (self.end_insert_rows)(self.qobject); } pub fn begin_move_rows(&mut self, first: usize, last: usize, destination: usize) { (self.begin_move_rows)(self.qobject, first, last, destination); } pub fn end_move_rows(&mut self) { (self.end_move_rows)(self.qobject); } pub fn begin_remove_rows(&mut self, first: usize, last: usize) { (self.begin_remove_rows)(self.qobject, first, last); } pub fn end_remove_rows(&mut self) { (self.end_remove_rows)(self.qobject); } } pub trait TimeSeriesTrait { fn new(emit: TimeSeriesEmitter, model: TimeSeriesList) -> Self; fn emit(&mut self) -> &mut TimeSeriesEmitter; fn row_count(&self) -> usize; fn insert_rows(&mut self, _row: usize, _count: usize) -> bool { false } fn remove_rows(&mut self, _row: usize, _count: usize) -> bool { false } fn can_fetch_more(&self) -> bool { false } fn fetch_more(&mut self) {} - fn sort(&mut self, u8, SortOrder) {} + fn sort(&mut self, _: u8, _: SortOrder) {} fn cos(&self, index: usize) -> f32; fn set_cos(&mut self, index: usize, f32) -> bool; fn sin(&self, index: usize) -> f32; fn set_sin(&mut self, index: usize, f32) -> bool; fn time(&self, index: usize) -> f32; fn set_time(&mut self, index: usize, f32) -> bool; } #[no_mangle] pub extern "C" fn time_series_new( time_series: *mut TimeSeriesQObject, time_series_new_data_ready: fn(*mut TimeSeriesQObject), time_series_layout_about_to_be_changed: fn(*mut TimeSeriesQObject), time_series_layout_changed: fn(*mut TimeSeriesQObject), time_series_data_changed: fn(*mut TimeSeriesQObject, usize, usize), time_series_begin_reset_model: fn(*mut TimeSeriesQObject), time_series_end_reset_model: fn(*mut TimeSeriesQObject), time_series_begin_insert_rows: fn(*mut TimeSeriesQObject, usize, usize), time_series_end_insert_rows: fn(*mut TimeSeriesQObject), time_series_begin_move_rows: fn(*mut TimeSeriesQObject, usize, usize, usize), time_series_end_move_rows: fn(*mut TimeSeriesQObject), time_series_begin_remove_rows: fn(*mut TimeSeriesQObject, usize, usize), time_series_end_remove_rows: fn(*mut TimeSeriesQObject), ) -> *mut TimeSeries { let time_series_emit = TimeSeriesEmitter { qobject: Arc::new(AtomicPtr::new(time_series)), new_data_ready: time_series_new_data_ready, }; let model = TimeSeriesList { qobject: time_series, layout_about_to_be_changed: time_series_layout_about_to_be_changed, layout_changed: time_series_layout_changed, data_changed: time_series_data_changed, begin_reset_model: time_series_begin_reset_model, end_reset_model: time_series_end_reset_model, begin_insert_rows: time_series_begin_insert_rows, end_insert_rows: time_series_end_insert_rows, begin_move_rows: time_series_begin_move_rows, end_move_rows: time_series_end_move_rows, begin_remove_rows: time_series_begin_remove_rows, end_remove_rows: time_series_end_remove_rows, }; let d_time_series = TimeSeries::new(time_series_emit, model); Box::into_raw(Box::new(d_time_series)) } #[no_mangle] pub unsafe extern "C" fn time_series_free(ptr: *mut TimeSeries) { Box::from_raw(ptr).emit().clear(); } #[no_mangle] pub unsafe extern "C" fn time_series_row_count(ptr: *const TimeSeries) -> c_int { to_c_int((&*ptr).row_count()) } #[no_mangle] pub unsafe extern "C" fn time_series_insert_rows(ptr: *mut TimeSeries, row: c_int, count: c_int) -> bool { (&mut *ptr).insert_rows(to_usize(row), to_usize(count)) } #[no_mangle] pub unsafe extern "C" fn time_series_remove_rows(ptr: *mut TimeSeries, row: c_int, count: c_int) -> bool { (&mut *ptr).remove_rows(to_usize(row), to_usize(count)) } #[no_mangle] pub unsafe extern "C" fn time_series_can_fetch_more(ptr: *const TimeSeries) -> bool { (&*ptr).can_fetch_more() } #[no_mangle] pub unsafe extern "C" fn time_series_fetch_more(ptr: *mut TimeSeries) { (&mut *ptr).fetch_more() } #[no_mangle] pub unsafe extern "C" fn time_series_sort( ptr: *mut TimeSeries, column: u8, order: SortOrder, ) { (&mut *ptr).sort(column, order) } #[no_mangle] pub unsafe extern "C" fn time_series_data_cos(ptr: *const TimeSeries, row: c_int) -> f32 { let o = &*ptr; o.cos(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn time_series_set_data_cos( ptr: *mut TimeSeries, row: c_int, v: f32, ) -> bool { (&mut *ptr).set_cos(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn time_series_data_sin(ptr: *const TimeSeries, row: c_int) -> f32 { let o = &*ptr; o.sin(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn time_series_set_data_sin( ptr: *mut TimeSeries, row: c_int, v: f32, ) -> bool { (&mut *ptr).set_sin(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn time_series_data_time(ptr: *const TimeSeries, row: c_int) -> f32 { let o = &*ptr; o.time(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn time_series_set_data_time( ptr: *mut TimeSeries, row: c_int, v: f32, ) -> bool { (&mut *ptr).set_time(to_usize(row), v) } diff --git a/src/rust.rs b/src/rust.rs index a56378f..e752540 100644 --- a/src/rust.rs +++ b/src/rust.rs @@ -1,1547 +1,1547 @@ //! `rust` is the module that generates the rust code for the binding use configuration::*; use configuration_private::*; use std::io::{Result, Write}; use util::{snake_case, write_if_different}; fn rust_type(p: &Property) -> String { if p.optional { return format!("Option<{}>", p.property_type.rust_type()); } p.property_type.rust_type().to_string() } fn rust_type_(p: &ItemProperty) -> String { if p.optional { return format!("Option<{}>", p.item_property_type.rust_type()); } p.item_property_type.rust_type().to_string() } fn rust_return_type(p: &Property) -> String { let mut type_: String = p.property_type.rust_type().to_string(); if type_ == "String" { type_ = "str".to_string(); } if type_ == "Vec" { type_ = "[u8]".to_string(); } if p.property_type.is_complex() { type_ = "&".to_string() + &type_; } if p.optional { return "Option<".to_string() + &type_ + ">"; } type_ } fn rust_return_type_(p: &ItemProperty) -> String { let mut type_: String = p.item_property_type.rust_type().to_string(); if type_ == "String" && !p.rust_by_value { type_ = "str".to_string(); } if type_ == "Vec" && !p.rust_by_value { type_ = "[u8]".to_string(); } if p.item_property_type.is_complex() && !p.rust_by_value { type_ = "&".to_string() + &type_; } if p.optional { return "Option<".to_string() + &type_ + ">"; } type_ } fn rust_c_type(p: &ItemProperty) -> String { if p.optional { return format!("COption<{}>", p.item_property_type.rust_type()); } p.item_property_type.rust_type().to_string() } fn rust_type_init(p: &Property) -> &str { if p.optional { return "None"; } p.property_type.rust_type_init() } fn r_constructor_args_decl(r: &mut Vec, name: &str, o: &Object, conf: &Config) -> Result<()> { write!(r, " {}: *mut {}QObject", snake_case(name), o.name)?; for (p_name, p) in &o.properties { if let Type::Object(object) = &p.property_type { writeln!(r, ",")?; r_constructor_args_decl(r, p_name, object, conf)?; } else { write!( r, ",\n {}_{}_changed: fn(*mut {}QObject)", snake_case(name), snake_case(p_name), o.name )?; } } if o.object_type == ObjectType::List { write!( r, ",\n {}_new_data_ready: fn(*mut {}QObject)", snake_case(name), o.name )?; } else if o.object_type == ObjectType::Tree { write!( r, ",\n {}_new_data_ready: fn(*mut {}QObject, index: COption)", snake_case(name), o.name )?; } if o.object_type != ObjectType::Object { let index_decl = if o.object_type == ObjectType::Tree { " index: COption," } else { "" }; let dest_decl = if o.object_type == ObjectType::Tree { " index: COption," } else { "" }; write!( r, ", {2}_layout_about_to_be_changed: fn(*mut {0}QObject), {2}_layout_changed: fn(*mut {0}QObject), {2}_data_changed: fn(*mut {0}QObject, usize, usize), {2}_begin_reset_model: fn(*mut {0}QObject), {2}_end_reset_model: fn(*mut {0}QObject), {2}_begin_insert_rows: fn(*mut {0}QObject,{1} usize, usize), {2}_end_insert_rows: fn(*mut {0}QObject), {2}_begin_move_rows: fn(*mut {0}QObject,{1} usize, usize,{3} usize), {2}_end_move_rows: fn(*mut {0}QObject), {2}_begin_remove_rows: fn(*mut {0}QObject,{1} usize, usize), {2}_end_remove_rows: fn(*mut {0}QObject)", o.name, index_decl, snake_case(name), dest_decl )?; } Ok(()) } fn r_constructor_args(r: &mut Vec, name: &str, o: &Object, conf: &Config) -> Result<()> { for (name, p) in &o.properties { if let Type::Object(object) = &p.property_type { r_constructor_args(r, name, object, conf)?; } } writeln!( r, " let {}_emit = {}Emitter {{ qobject: Arc::new(AtomicPtr::new({0})),", snake_case(name), o.name )?; for (p_name, p) in &o.properties { if p.is_object() { continue; } writeln!( r, " {}_changed: {}_{0}_changed,", snake_case(p_name), snake_case(name) )?; } if o.object_type != ObjectType::Object { writeln!( r, " new_data_ready: {}_new_data_ready,", snake_case(name) )?; } let mut model = String::new(); if o.object_type != ObjectType::Object { let type_ = if o.object_type == ObjectType::List { "List" } else { "Tree" }; model.push_str(", model"); writeln!( r, " }}; let model = {}{} {{ qobject: {}, layout_about_to_be_changed: {2}_layout_about_to_be_changed, layout_changed: {2}_layout_changed, data_changed: {2}_data_changed, begin_reset_model: {2}_begin_reset_model, end_reset_model: {2}_end_reset_model, begin_insert_rows: {2}_begin_insert_rows, end_insert_rows: {2}_end_insert_rows, begin_move_rows: {2}_begin_move_rows, end_move_rows: {2}_end_move_rows, begin_remove_rows: {2}_begin_remove_rows, end_remove_rows: {2}_end_remove_rows,", o.name, type_, snake_case(name) )?; } write!( r, " }};\n let d_{} = {}::new({0}_emit{}", snake_case(name), o.name, model )?; for (name, p) in &o.properties { if p.is_object() { write!(r, ",\n d_{}", snake_case(name))?; } } writeln!(r, ");") } fn write_function( r: &mut Vec, (name, f): (&String, &Function), lcname: &str, o: &Object, ) -> Result<()> { let lc = snake_case(name); write!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_{}(ptr: *{} {}", lcname, lc, if f.mutable { "mut" } else { "const" }, o.name )?; // write all the input arguments, for QString and QByteArray, write // pointers to their content and the length which is int in Qt for a in &f.arguments { write!(r, ", ")?; if a.argument_type.name() == "QString" { write!(r, "{}_str: *const c_ushort, {0}_len: c_int", a.name)?; } else if a.argument_type.name() == "QByteArray" { write!(r, "{}_str: *const c_char, {0}_len: c_int", a.name)?; } else { write!(r, "{}: {}", a.name, a.argument_type.rust_type())?; } } // If the return type is QString or QByteArray, append a pointer to the // variable that will be set to the argument list. Also add a setter // function. if f.return_type.is_complex() { writeln!( r, ", d: *mut {}, set: fn(*mut {0}, str: *const c_char, len: c_int)) {{", f.return_type.name() )?; } else { writeln!(r, ") -> {} {{", f.return_type.rust_type())?; } for a in &f.arguments { if a.argument_type.name() == "QString" { writeln!( r, " let mut {} = String::new(); set_string_from_utf16(&mut {0}, {0}_str, {0}_len);", a.name )?; } else if a.argument_type.name() == "QByteArray" { writeln!( r, " let {} = {{ slice::from_raw_parts({0}_str as *const u8, to_usize({0}_len)) }};", a.name )?; } } if f.mutable { writeln!(r, " let o = &mut *ptr;")?; } else { writeln!(r, " let o = &*ptr;")?; } write!(r, " let r = o.{}(", lc)?; for (i, a) in f.arguments.iter().enumerate() { if i > 0 { write!(r, ", ")?; } write!(r, "{}", a.name)?; } writeln!(r, ");")?; if f.return_type.is_complex() { writeln!( r, " let s: *const c_char = r.as_ptr() as (*const c_char); set(d, s, r.len() as i32);" )?; } else { writeln!(r, " r")?; } writeln!(r, "}}") } fn write_rust_interface_object(r: &mut Vec, o: &Object, conf: &Config) -> Result<()> { let lcname = snake_case(&o.name); writeln!( r, " pub struct {}QObject {{}} pub struct {0}Emitter {{ qobject: Arc>,", o.name )?; for (name, p) in &o.properties { if p.is_object() { continue; } writeln!( r, " {}_changed: fn(*mut {}QObject),", snake_case(name), o.name )?; } if o.object_type == ObjectType::List { writeln!(r, " new_data_ready: fn(*mut {}QObject),", o.name)?; } else if o.object_type == ObjectType::Tree { writeln!( r, " new_data_ready: fn(*mut {}QObject, index: COption),", o.name )?; } writeln!( r, "}} unsafe impl Send for {}Emitter {{}} impl {0}Emitter {{ /// 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) -> {0}Emitter {{ {0}Emitter {{ qobject: self.qobject.clone(),", o.name )?; for (name, p) in &o.properties { if p.is_object() { continue; } writeln!( r, " {}_changed: self.{0}_changed,", snake_case(name), )?; } if o.object_type != ObjectType::Object { writeln!(r, " new_data_ready: self.new_data_ready,")?; } writeln!( r, " }} }} fn clear(&self) {{ let n: *const {0}QObject = null(); self.qobject.store(n as *mut {0}QObject, Ordering::SeqCst); }}", o.name )?; for (name, p) in &o.properties { if p.is_object() { continue; } writeln!( r, " pub fn {}_changed(&mut self) {{ let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() {{ (self.{0}_changed)(ptr); }} }}", snake_case(name) )?; } if o.object_type == ObjectType::List { writeln!( r, " pub fn new_data_ready(&mut self) {{ let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() {{ (self.new_data_ready)(ptr); }} }}" )?; } else if o.object_type == ObjectType::Tree { writeln!( r, " pub fn new_data_ready(&mut self, item: Option) {{ let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() {{ (self.new_data_ready)(ptr, item.into()); }} }}" )?; } let mut model_struct = String::new(); if o.object_type != ObjectType::Object { let type_ = if o.object_type == ObjectType::List { "List" } else { "Tree" }; model_struct = format!(", model: {}{}", o.name, type_); let mut index = ""; let mut index_decl = ""; let mut index_c_decl = ""; let mut dest = ""; let mut dest_decl = ""; let mut dest_c_decl = ""; if o.object_type == ObjectType::Tree { index_decl = " index: Option,"; index_c_decl = " index: COption,"; index = " index.into(),"; dest_decl = " dest: Option,"; dest_c_decl = " dest: COption,"; dest = " dest.into(),"; } writeln!( r, "}} #[derive(Clone)] pub struct {0}{1} {{ qobject: *mut {0}QObject, layout_about_to_be_changed: fn(*mut {0}QObject), layout_changed: fn(*mut {0}QObject), data_changed: fn(*mut {0}QObject, usize, usize), begin_reset_model: fn(*mut {0}QObject), end_reset_model: fn(*mut {0}QObject), begin_insert_rows: fn(*mut {0}QObject,{4} usize, usize), end_insert_rows: fn(*mut {0}QObject), begin_move_rows: fn(*mut {0}QObject,{4} usize, usize,{7} usize), end_move_rows: fn(*mut {0}QObject), begin_remove_rows: fn(*mut {0}QObject,{4} usize, usize), end_remove_rows: fn(*mut {0}QObject), }} impl {0}{1} {{ pub fn layout_about_to_be_changed(&mut self) {{ (self.layout_about_to_be_changed)(self.qobject); }} pub fn layout_changed(&mut self) {{ (self.layout_changed)(self.qobject); }} pub fn data_changed(&mut self, first: usize, last: usize) {{ (self.data_changed)(self.qobject, first, last); }} pub fn begin_reset_model(&mut self) {{ (self.begin_reset_model)(self.qobject); }} pub fn end_reset_model(&mut self) {{ (self.end_reset_model)(self.qobject); }} pub fn begin_insert_rows(&mut self,{2} first: usize, last: usize) {{ (self.begin_insert_rows)(self.qobject,{3} first, last); }} pub fn end_insert_rows(&mut self) {{ (self.end_insert_rows)(self.qobject); }} pub fn begin_move_rows(&mut self,{2} first: usize, last: usize,{5} destination: usize) {{ (self.begin_move_rows)(self.qobject,{3} first, last,{6} destination); }} pub fn end_move_rows(&mut self) {{ (self.end_move_rows)(self.qobject); }} pub fn begin_remove_rows(&mut self,{2} first: usize, last: usize) {{ (self.begin_remove_rows)(self.qobject,{3} first, last); }} pub fn end_remove_rows(&mut self) {{ (self.end_remove_rows)(self.qobject); }}", o.name, type_, index_decl, index, index_c_decl, dest_decl, dest, dest_c_decl )?; } write!( r, "}} pub trait {}Trait {{ fn new(emit: {0}Emitter{}", o.name, model_struct )?; for (name, p) in &o.properties { if p.is_object() { write!(r, ",\n {}: {}", snake_case(name), p.type_name())?; } } writeln!( r, ") -> Self; fn emit(&mut self) -> &mut {}Emitter;", o.name )?; for (name, p) in &o.properties { let lc = snake_case(name).to_lowercase(); if p.is_object() { writeln!(r, " fn {}(&self) -> &{};", lc, rust_type(p))?; writeln!(r, " fn {}_mut(&mut self) -> &mut {};", lc, rust_type(p))?; } else { if p.rust_by_function { write!( r, " fn {}(&self, getter: F) where F: FnOnce({});", lc, rust_return_type(p) )?; } else { writeln!(r, " fn {}(&self) -> {};", lc, rust_return_type(p))?; } if p.write { if p.type_name() == "QByteArray" { if p.optional { writeln!(r, " fn set_{}(&mut self, value: Option<&[u8]>);", lc)?; } else { writeln!(r, " fn set_{}(&mut self, value: &[u8]);", lc)?; } } else { writeln!(r, " fn set_{}(&mut self, value: {});", lc, rust_type(p))?; } } } } for (name, f) in &o.functions { let lc = snake_case(name); let mut arg_list = String::new(); if !f.arguments.is_empty() { for a in &f.arguments { let t = if a.argument_type.name() == "QByteArray" { "&[u8]" } else { a.argument_type.rust_type() }; arg_list.push_str(&format!(", {}: {}", a.name, t)); } } writeln!( r, " fn {}(&{}self{}) -> {};", lc, if f.mutable { "mut " } else { "" }, arg_list, f.return_type.rust_type() )?; } if o.object_type == ObjectType::List { writeln!( r, " fn row_count(&self) -> usize; fn insert_rows(&mut self, _row: usize, _count: usize) -> bool {{ false }} fn remove_rows(&mut self, _row: usize, _count: usize) -> bool {{ false }} fn can_fetch_more(&self) -> bool {{ false }} fn fetch_more(&mut self) {{}} fn sort(&mut self, _: u8, _: SortOrder) {{}}" )?; } else if o.object_type == ObjectType::Tree { writeln!( r, " fn row_count(&self, _: Option) -> usize; fn can_fetch_more(&self, _: Option) -> bool {{ false }} fn fetch_more(&mut self, _: Option) {{}} fn sort(&mut self, _: u8, _: SortOrder) {{}} fn check_row(&self, index: usize, row: usize) -> Option; fn index(&self, item: Option, row: usize) -> usize; fn parent(&self, index: usize) -> Option; fn row(&self, index: usize) -> usize;" )?; } if o.object_type != ObjectType::Object { for (name, ip) in &o.item_properties { let name = snake_case(name); writeln!( r, " fn {}(&self, index: usize) -> {};", name, rust_return_type_(ip) )?; if ip.write { if ip.item_property_type.name() == "QByteArray" { if ip.optional { writeln!( r, " fn set_{}(&mut self, index: usize, _: Option<&[u8]>) -> bool;", name )?; } else { writeln!( r, - " fn set_{}(&mut self, index: usize, &[u8]) -> bool;", + " fn set_{}(&mut self, index: usize, _: &[u8]) -> bool;", name )?; } } else { writeln!( r, - " fn set_{}(&mut self, index: usize, {}) -> bool;", + " fn set_{}(&mut self, index: usize, _: {}) -> bool;", name, rust_type_(ip) )?; } } } } writeln!( r, "}} #[no_mangle] pub extern \"C\" fn {}_new(", lcname )?; r_constructor_args_decl(r, &lcname, o, conf)?; writeln!(r, ",\n) -> *mut {} {{", o.name)?; r_constructor_args(r, &lcname, o, conf)?; writeln!( r, " Box::into_raw(Box::new(d_{})) }} #[no_mangle] pub unsafe extern \"C\" fn {0}_free(ptr: *mut {}) {{ Box::from_raw(ptr).emit().clear(); }}", lcname, o.name )?; for (name, p) in &o.properties { let base = format!("{}_{}", lcname, snake_case(name)); if p.is_object() { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_get(ptr: *mut {}) -> *mut {} {{ (&mut *ptr).{}_mut() }}", base, o.name, rust_type(p), snake_case(name) )?; } else if p.is_complex() && !p.optional { if p.rust_by_function { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_get( ptr: *const {}, p: *mut {}, set: fn(*mut {2}, *const c_char, c_int), ) {{ let o = &*ptr; o.{}(|v| {{ let s: *const c_char = v.as_ptr() as (*const c_char); set(p, s, to_c_int(v.len())); }}); }}", base, o.name, p.type_name(), snake_case(name) )?; } else { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_get( ptr: *const {}, p: *mut {}, set: fn(*mut {2}, *const c_char, c_int), ) {{ let o = &*ptr; let v = o.{}(); let s: *const c_char = v.as_ptr() as (*const c_char); set(p, s, to_c_int(v.len())); }}", base, o.name, p.type_name(), snake_case(name) )?; } if p.write && p.type_name() == "QString" { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_set(ptr: *mut {}, 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_{}(s); }}", base, o.name, snake_case(name) )?; } else if p.write { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_set(ptr: *mut {}, v: *const c_char, len: c_int) {{ let o = &mut *ptr; let v = slice::from_raw_parts(v as *const u8, to_usize(len)); o.set_{}(v); }}", base, o.name, snake_case(name) )?; } } else if p.is_complex() { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_get( ptr: *const {}, p: *mut {}, set: fn(*mut {2}, *const c_char, c_int), ) {{ let o = &*ptr; let v = o.{}(); if let Some(v) = v {{ let s: *const c_char = v.as_ptr() as (*const c_char); set(p, s, to_c_int(v.len())); }} }}", base, o.name, p.type_name(), snake_case(name) )?; if p.write && p.type_name() == "QString" { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_set(ptr: *mut {}, 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_{}(Some(s)); }}", base, o.name, snake_case(name) )?; } else if p.write { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_set(ptr: *mut {}, v: *const c_char, len: c_int) {{ let o = &mut *ptr; let v = slice::from_raw_parts(v as *const u8, to_usize(len)); o.set_{}(Some(v.into())); }}", base, o.name, snake_case(name) )?; } } else if p.optional { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_get(ptr: *const {}) -> COption<{}> {{ match (&*ptr).{}() {{ Some(value) => COption {{ data: value, some: true }}, None => COption {{ data: {2}::default(), some: false}} }} }}", base, o.name, p.property_type.rust_type(), snake_case(name) )?; if p.write { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_set(ptr: *mut {}, v: {}) {{ (&mut *ptr).set_{}(Some(v)); }}", base, o.name, p.property_type.rust_type(), snake_case(name) )?; } } else { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_get(ptr: *const {}) -> {} {{ (&*ptr).{}() }}", base, o.name, rust_type(p), snake_case(name) )?; if p.write { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_set(ptr: *mut {}, v: {}) {{ (&mut *ptr).set_{}(v); }}", base, o.name, rust_type(p), snake_case(name) )?; } } if p.write && p.optional { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_set_none(ptr: *mut {}) {{ let o = &mut *ptr; o.set_{}(None); }}", base, o.name, snake_case(name) )?; } } for f in &o.functions { write_function(r, f, &lcname, o)?; } if o.object_type == ObjectType::List { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {1}_row_count(ptr: *const {0}) -> c_int {{ to_c_int((&*ptr).row_count()) }} #[no_mangle] pub unsafe extern \"C\" fn {1}_insert_rows(ptr: *mut {0}, row: c_int, count: c_int) -> bool {{ (&mut *ptr).insert_rows(to_usize(row), to_usize(count)) }} #[no_mangle] pub unsafe extern \"C\" fn {1}_remove_rows(ptr: *mut {0}, row: c_int, count: c_int) -> bool {{ (&mut *ptr).remove_rows(to_usize(row), to_usize(count)) }} #[no_mangle] pub unsafe extern \"C\" fn {1}_can_fetch_more(ptr: *const {0}) -> bool {{ (&*ptr).can_fetch_more() }} #[no_mangle] pub unsafe extern \"C\" fn {1}_fetch_more(ptr: *mut {0}) {{ (&mut *ptr).fetch_more() }} #[no_mangle] pub unsafe extern \"C\" fn {1}_sort( ptr: *mut {0}, column: u8, order: SortOrder, ) {{ (&mut *ptr).sort(column, order) }}", o.name, lcname )?; } else if o.object_type == ObjectType::Tree { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {1}_row_count( ptr: *const {0}, index: COption, ) -> c_int {{ to_c_int((&*ptr).row_count(index.into())) }} #[no_mangle] pub unsafe extern \"C\" fn {1}_can_fetch_more( ptr: *const {0}, index: COption, ) -> bool {{ (&*ptr).can_fetch_more(index.into()) }} #[no_mangle] pub unsafe extern \"C\" fn {1}_fetch_more(ptr: *mut {0}, index: COption) {{ (&mut *ptr).fetch_more(index.into()) }} #[no_mangle] pub unsafe extern \"C\" fn {1}_sort( ptr: *mut {0}, column: u8, order: SortOrder ) {{ (&mut *ptr).sort(column, order) }} #[no_mangle] pub unsafe extern \"C\" fn {1}_check_row( ptr: *const {0}, index: usize, row: c_int, ) -> COption {{ (&*ptr).check_row(index.into(), to_usize(row)).into() }} #[no_mangle] pub unsafe extern \"C\" fn {1}_index( ptr: *const {0}, index: COption, row: c_int, ) -> usize {{ (&*ptr).index(index.into(), to_usize(row)) }} #[no_mangle] pub unsafe extern \"C\" fn {1}_parent(ptr: *const {0}, index: usize) -> QModelIndex {{ if let Some(parent) = (&*ptr).parent(index) {{ QModelIndex {{ row: to_c_int((&*ptr).row(parent)), internal_id: parent, }} }} else {{ QModelIndex {{ row: -1, internal_id: 0, }} }} }} #[no_mangle] pub unsafe extern \"C\" fn {1}_row(ptr: *const {0}, index: usize) -> c_int {{ to_c_int((&*ptr).row(index)) }}", o.name, lcname )?; } if o.object_type != ObjectType::Object { let (index_decl, index) = if o.object_type == ObjectType::Tree { (", index: usize", "index") } else { (", row: c_int", "to_usize(row)") }; for (name, ip) in &o.item_properties { if ip.is_complex() && !ip.optional { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_data_{}( ptr: *const {}{}, d: *mut {}, set: fn(*mut {4}, *const c_char, len: c_int), ) {{ let o = &*ptr; let data = o.{1}({}); let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); }}", lcname, snake_case(name), o.name, index_decl, ip.type_name(), index )?; } else if ip.is_complex() { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_data_{}( ptr: *const {}{}, d: *mut {}, set: fn(*mut {4}, *const c_char, len: c_int), ) {{ let o = &*ptr; let data = o.{1}({}); if let Some(data) = data {{ let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); }} }}", lcname, snake_case(name), o.name, index_decl, ip.type_name(), index )?; } else { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_data_{}(ptr: *const {}{}) -> {} {{ let o = &*ptr; o.{1}({}).into() }}", lcname, snake_case(name), o.name, index_decl, rust_c_type(ip), index )?; } if ip.write { let val = if ip.optional { "Some(v)" } else { "v" }; if ip.type_name() == "QString" { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_set_data_{}( ptr: *mut {}{}, s: *const c_ushort, len: c_int, ) -> bool {{ let o = &mut *ptr; let mut v = String::new(); set_string_from_utf16(&mut v, s, len); o.set_{1}({}, {}) }}", lcname, snake_case(name), o.name, index_decl, index, val )?; } else if ip.type_name() == "QByteArray" { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_set_data_{}( ptr: *mut {}{}, s: *const c_char, len: c_int, ) -> bool {{ let o = &mut *ptr; let slice = ::std::slice::from_raw_parts(s as *const u8, to_usize(len)); o.set_{1}({}, {}) }}", lcname, snake_case(name), o.name, index_decl, index, if ip.optional { "Some(slice)" } else { "slice" } )?; } else { let type_ = ip.item_property_type.rust_type(); writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_set_data_{}( ptr: *mut {}{}, v: {}, ) -> bool {{ (&mut *ptr).set_{1}({}, {}) }}", lcname, snake_case(name), o.name, index_decl, type_, index, val )?; } } if ip.write && ip.optional { writeln!( r, " #[no_mangle] pub unsafe extern \"C\" fn {}_set_data_{}_none(ptr: *mut {}{}) -> bool {{ (&mut *ptr).set_{1}({}, None) }}", lcname, snake_case(name), o.name, index_decl, index )?; } } } Ok(()) } fn write_rust_types(conf: &Config, r: &mut Vec) -> Result<()> { let mut has_option = false; let mut has_string = false; let mut has_byte_array = false; let mut has_list_or_tree = false; for o in conf.objects.values() { has_list_or_tree |= o.object_type != ObjectType::Object; for p in o.properties.values() { has_option |= p.optional; has_string |= p.property_type == Type::Simple(SimpleType::QString); has_byte_array |= p.property_type == Type::Simple(SimpleType::QByteArray); } for p in o.item_properties.values() { has_option |= p.optional; has_string |= p.item_property_type == SimpleType::QString; has_byte_array |= p.item_property_type == SimpleType::QByteArray; } for f in o.functions.values() { has_string |= f.return_type == SimpleType::QString; has_byte_array |= f.return_type == SimpleType::QByteArray; for a in &f.arguments { has_string |= a.argument_type == SimpleType::QString; has_byte_array |= a.argument_type == SimpleType::QByteArray; } } } if has_option || has_list_or_tree { writeln!( r, " #[repr(C)] pub struct COption {{ data: T, some: bool, }} impl COption {{ #![allow(dead_code)] fn into(self) -> Option {{ if self.some {{ Some(self.data) }} else {{ None }} }} }} impl From> for COption where T: Default, {{ fn from(t: Option) -> COption {{ if let Some(v) = t {{ COption {{ data: v, some: true, }} }} else {{ COption {{ data: T::default(), some: false, }} }} }} }}" )?; } if has_string { writeln!( r, " 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); }} " )?; } if has_byte_array { writeln!( r, " pub enum QByteArray {{}}" )?; } if has_list_or_tree { writeln!( r, " #[repr(C)] #[derive(PartialEq, Eq, Debug)] pub enum SortOrder {{ Ascending = 0, Descending = 1, }} #[repr(C)] pub struct QModelIndex {{ row: c_int, internal_id: usize, }}" )?; } if has_string || has_byte_array || has_list_or_tree { writeln!( r, " fn to_usize(n: c_int) -> usize {{ if n < 0 {{ panic!(\"Cannot cast {{}} to usize\", n); }} n as usize }} " )?; } if has_string || has_byte_array || has_list_or_tree { writeln!( r, " 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 }} " )?; } Ok(()) } pub fn write_interface(conf: &Config) -> Result<()> { let mut r = Vec::new(); writeln!( r, "/* 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 {}{}::*;", get_module_prefix(conf), conf.rust.implementation_module )?; write_rust_types(conf, &mut r)?; for object in conf.objects.values() { write_rust_interface_object(&mut r, object, conf)?; } let mut file = conf .config_file .parent() .unwrap() .join(&conf.rust.dir) .join("src") .join(&conf.rust.interface_module); file.set_extension("rs"); write_if_different(file, &r) } fn write_rust_implementation_object(r: &mut Vec, o: &Object) -> Result<()> { if o.object_type != ObjectType::Object { writeln!(r, "#[derive(Default, Clone)]")?; writeln!(r, "struct {}Item {{", o.name)?; for (name, ip) in &o.item_properties { let lc = snake_case(name); if ip.optional { writeln!( r, " {}: Option<{}>,", lc, ip.item_property_type.rust_type() )?; } else { writeln!(r, " {}: {},", lc, ip.item_property_type.rust_type())?; } } writeln!(r, "}}\n")?; } let mut model_struct = String::new(); writeln!(r, "pub struct {} {{\n emit: {0}Emitter,", o.name)?; if o.object_type == ObjectType::List { model_struct = format!(", model: {}List", o.name); writeln!(r, " model: {}List,", o.name)?; } else if o.object_type == ObjectType::Tree { model_struct = format!(", model: {}Tree", o.name); writeln!(r, " model: {}Tree,", o.name)?; } for (name, p) in &o.properties { let lc = snake_case(name); writeln!(r, " {}: {},", lc, rust_type(p))?; } if o.object_type != ObjectType::Object { writeln!(r, " list: Vec<{}Item>,", o.name)?; } writeln!(r, "}}\n")?; for (name, p) in &o.properties { if p.is_object() { model_struct += &format!(", {}: {}", name, p.type_name()); } } writeln!( r, "impl {}Trait for {0} {{ fn new(emit: {0}Emitter{}) -> {0} {{ {0} {{ emit,", o.name, model_struct )?; if o.object_type != ObjectType::Object { writeln!(r, " model,")?; writeln!(r, " list: Vec::new(),")?; } for (name, p) in &o.properties { let lc = snake_case(name); if p.is_object() { writeln!(r, " {},", lc)?; } else { writeln!(r, " {}: {},", lc, rust_type_init(p))?; } } writeln!( r, " }} }} fn emit(&mut self) -> &mut {}Emitter {{ &self.emit }}", o.name )?; for (name, p) in &o.properties { let lc = snake_case(name); if p.is_object() { writeln!( r, " fn {}(&self) -> &{} {{ &self.{0} }} fn {0}_mut(&mut self) -> &mut {1} {{ &mut self.{0} }}", lc, rust_return_type(p) )?; } else if p.rust_by_function { writeln!( r, " fn {}(&self, getter: F) where F: FnOnce({}), {{ getter(&self.{0}) }}", lc, rust_return_type(p) )?; } else { writeln!(r, " fn {}(&self) -> {} {{", lc, rust_return_type(p))?; if p.is_complex() { if p.optional { writeln!(r, " self.{}.as_ref().map(|p| &p[..])", lc)?; } else { writeln!(r, " &self.{}", lc)?; } } else { writeln!(r, " self.{}", lc)?; } writeln!(r, " }}")?; } if !p.is_object() && p.write { let bytearray = p.property_type == Type::Simple(SimpleType::QByteArray); let (t, v) = if bytearray && p.optional { ("Option<&[u8]>".to_string(), ".map(|v| v.to_vec())") } else if bytearray { ("&[u8]".to_string(), ".to_vec()") } else { (rust_type(p), "") }; writeln!( r, " fn set_{}(&mut self, value: {}) {{ self.{0} = value{}; self.emit.{0}_changed(); }}", lc, t, v )?; } } if o.object_type == ObjectType::List { writeln!( r, " fn row_count(&self) -> usize {{\n self.list.len()\n }}" )?; } else if o.object_type == ObjectType::Tree { writeln!( r, " fn row_count(&self, item: Option) -> usize {{ self.list.len() }} fn index(&self, item: Option, row: usize) -> usize {{ 0 }} fn parent(&self, index: usize) -> Option {{ None }} fn row(&self, index: usize) -> usize {{ index }} fn check_row(&self, index: usize, _row: usize) -> Option {{ if index < self.list.len() {{ Some(index) }} else {{ None }} }}" )?; } if o.object_type != ObjectType::Object { for (name, ip) in &o.item_properties { let lc = snake_case(name); writeln!( r, " fn {}(&self, index: usize) -> {} {{", lc, rust_return_type_(ip) )?; if ip.is_complex() && ip.optional { writeln!( r, " self.list[index].{}.as_ref().map(|v| &v[..])", lc )?; } else if ip.is_complex() { writeln!(r, " &self.list[index].{}", lc)?; } else { writeln!(r, " self.list[index].{}", lc)?; } writeln!(r, " }}")?; let bytearray = ip.item_property_type == SimpleType::QByteArray; if ip.write && bytearray && ip.optional { writeln!( r, " fn set_{}(&mut self, index: usize, v: Option<&[u8]>) -> bool {{ self.list[index].{0} = v.map(|v| v.to_vec()); true }}", lc )?; } else if ip.write && bytearray { writeln!( r, " fn set_{}(&mut self, index: usize, v: &[u8]) -> bool {{ self.list[index].{0} = v.to_vec(); true }}", lc )?; } else if ip.write { writeln!( r, " fn set_{}(&mut self, index: usize, v: {}) -> bool {{ self.list[index].{0} = v; true }}", lc, rust_type_(ip) )?; } } } writeln!(r, "}}") } pub fn write_implementation(conf: &Config) -> Result<()> { let mut file = conf .config_file .parent() .unwrap() .join(&conf.rust.dir) .join("src") .join(&conf.rust.implementation_module); if !conf.overwrite_implementation && file.exists() { return Ok(()); } file.set_extension("rs"); if !conf.overwrite_implementation && file.exists() { return Ok(()); } let mut r = Vec::new(); writeln!( r, "#![allow(unused_imports)] #![allow(unused_variables)] #![allow(dead_code)] use {}{}::*; ", get_module_prefix(conf), conf.rust.interface_module )?; for object in conf.objects.values() { write_rust_implementation_object(&mut r, object)?; } write_if_different(file, &r) } /// Inspects the rust edition of the target crate to decide how the module /// imports should be written. /// /// As of Rust 2018, modules inside the crate should be prefixed with `crate::`. /// Prior to the 2018 edition, crate-local modules could be imported without /// this prefix. fn get_module_prefix(conf: &Config) -> &'static str { match conf.rust_edition { RustEdition::Rust2018 => "crate::", _ => "", } } diff --git a/tests/rust_list/src/interface.rs b/tests/rust_list/src/interface.rs index 0428169..3fd4978 100644 --- a/tests/rust_list/src/interface.rs +++ b/tests/rust_list/src/interface.rs @@ -1,498 +1,498 @@ /* 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::*; #[repr(C)] pub struct COption { data: T, some: bool, } impl COption { #![allow(dead_code)] fn into(self) -> Option { if self.some { Some(self.data) } else { None } } } impl From> for COption where T: Default, { fn from(t: Option) -> COption { if let Some(v) = t { COption { data: v, some: true, } } else { COption { data: T::default(), some: false, } } } } 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); } #[repr(C)] #[derive(PartialEq, Eq, Debug)] pub enum SortOrder { Ascending = 0, Descending = 1, } #[repr(C)] pub struct QModelIndex { row: c_int, internal_id: usize, } 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 NoRoleQObject {} pub struct NoRoleEmitter { qobject: Arc>, new_data_ready: fn(*mut NoRoleQObject), } unsafe impl Send for NoRoleEmitter {} impl NoRoleEmitter { /// 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) -> NoRoleEmitter { NoRoleEmitter { qobject: self.qobject.clone(), new_data_ready: self.new_data_ready, } } fn clear(&self) { let n: *const NoRoleQObject = null(); self.qobject.store(n as *mut NoRoleQObject, Ordering::SeqCst); } pub fn new_data_ready(&mut self) { let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() { (self.new_data_ready)(ptr); } } } #[derive(Clone)] pub struct NoRoleList { qobject: *mut NoRoleQObject, layout_about_to_be_changed: fn(*mut NoRoleQObject), layout_changed: fn(*mut NoRoleQObject), data_changed: fn(*mut NoRoleQObject, usize, usize), begin_reset_model: fn(*mut NoRoleQObject), end_reset_model: fn(*mut NoRoleQObject), begin_insert_rows: fn(*mut NoRoleQObject, usize, usize), end_insert_rows: fn(*mut NoRoleQObject), begin_move_rows: fn(*mut NoRoleQObject, usize, usize, usize), end_move_rows: fn(*mut NoRoleQObject), begin_remove_rows: fn(*mut NoRoleQObject, usize, usize), end_remove_rows: fn(*mut NoRoleQObject), } impl NoRoleList { pub fn layout_about_to_be_changed(&mut self) { (self.layout_about_to_be_changed)(self.qobject); } pub fn layout_changed(&mut self) { (self.layout_changed)(self.qobject); } pub fn data_changed(&mut self, first: usize, last: usize) { (self.data_changed)(self.qobject, first, last); } pub fn begin_reset_model(&mut self) { (self.begin_reset_model)(self.qobject); } pub fn end_reset_model(&mut self) { (self.end_reset_model)(self.qobject); } pub fn begin_insert_rows(&mut self, first: usize, last: usize) { (self.begin_insert_rows)(self.qobject, first, last); } pub fn end_insert_rows(&mut self) { (self.end_insert_rows)(self.qobject); } pub fn begin_move_rows(&mut self, first: usize, last: usize, destination: usize) { (self.begin_move_rows)(self.qobject, first, last, destination); } pub fn end_move_rows(&mut self) { (self.end_move_rows)(self.qobject); } pub fn begin_remove_rows(&mut self, first: usize, last: usize) { (self.begin_remove_rows)(self.qobject, first, last); } pub fn end_remove_rows(&mut self) { (self.end_remove_rows)(self.qobject); } } pub trait NoRoleTrait { fn new(emit: NoRoleEmitter, model: NoRoleList) -> Self; fn emit(&mut self) -> &mut NoRoleEmitter; fn row_count(&self) -> usize; fn insert_rows(&mut self, _row: usize, _count: usize) -> bool { false } fn remove_rows(&mut self, _row: usize, _count: usize) -> bool { false } fn can_fetch_more(&self) -> bool { false } fn fetch_more(&mut self) {} - fn sort(&mut self, u8, SortOrder) {} + fn sort(&mut self, _: u8, _: SortOrder) {} fn user_age(&self, index: usize) -> u8; - fn set_user_age(&mut self, index: usize, u8) -> bool; + fn set_user_age(&mut self, index: usize, _: u8) -> bool; fn user_name(&self, index: usize) -> &str; - fn set_user_name(&mut self, index: usize, String) -> bool; + fn set_user_name(&mut self, index: usize, _: String) -> bool; } #[no_mangle] pub extern "C" fn no_role_new( no_role: *mut NoRoleQObject, no_role_new_data_ready: fn(*mut NoRoleQObject), no_role_layout_about_to_be_changed: fn(*mut NoRoleQObject), no_role_layout_changed: fn(*mut NoRoleQObject), no_role_data_changed: fn(*mut NoRoleQObject, usize, usize), no_role_begin_reset_model: fn(*mut NoRoleQObject), no_role_end_reset_model: fn(*mut NoRoleQObject), no_role_begin_insert_rows: fn(*mut NoRoleQObject, usize, usize), no_role_end_insert_rows: fn(*mut NoRoleQObject), no_role_begin_move_rows: fn(*mut NoRoleQObject, usize, usize, usize), no_role_end_move_rows: fn(*mut NoRoleQObject), no_role_begin_remove_rows: fn(*mut NoRoleQObject, usize, usize), no_role_end_remove_rows: fn(*mut NoRoleQObject), ) -> *mut NoRole { let no_role_emit = NoRoleEmitter { qobject: Arc::new(AtomicPtr::new(no_role)), new_data_ready: no_role_new_data_ready, }; let model = NoRoleList { qobject: no_role, layout_about_to_be_changed: no_role_layout_about_to_be_changed, layout_changed: no_role_layout_changed, data_changed: no_role_data_changed, begin_reset_model: no_role_begin_reset_model, end_reset_model: no_role_end_reset_model, begin_insert_rows: no_role_begin_insert_rows, end_insert_rows: no_role_end_insert_rows, begin_move_rows: no_role_begin_move_rows, end_move_rows: no_role_end_move_rows, begin_remove_rows: no_role_begin_remove_rows, end_remove_rows: no_role_end_remove_rows, }; let d_no_role = NoRole::new(no_role_emit, model); Box::into_raw(Box::new(d_no_role)) } #[no_mangle] pub unsafe extern "C" fn no_role_free(ptr: *mut NoRole) { Box::from_raw(ptr).emit().clear(); } #[no_mangle] pub unsafe extern "C" fn no_role_row_count(ptr: *const NoRole) -> c_int { to_c_int((&*ptr).row_count()) } #[no_mangle] pub unsafe extern "C" fn no_role_insert_rows(ptr: *mut NoRole, row: c_int, count: c_int) -> bool { (&mut *ptr).insert_rows(to_usize(row), to_usize(count)) } #[no_mangle] pub unsafe extern "C" fn no_role_remove_rows(ptr: *mut NoRole, row: c_int, count: c_int) -> bool { (&mut *ptr).remove_rows(to_usize(row), to_usize(count)) } #[no_mangle] pub unsafe extern "C" fn no_role_can_fetch_more(ptr: *const NoRole) -> bool { (&*ptr).can_fetch_more() } #[no_mangle] pub unsafe extern "C" fn no_role_fetch_more(ptr: *mut NoRole) { (&mut *ptr).fetch_more() } #[no_mangle] pub unsafe extern "C" fn no_role_sort( ptr: *mut NoRole, column: u8, order: SortOrder, ) { (&mut *ptr).sort(column, order) } #[no_mangle] pub unsafe extern "C" fn no_role_data_user_age(ptr: *const NoRole, row: c_int) -> u8 { let o = &*ptr; o.user_age(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn no_role_set_data_user_age( ptr: *mut NoRole, row: c_int, v: u8, ) -> bool { (&mut *ptr).set_user_age(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn no_role_data_user_name( ptr: *const NoRole, row: c_int, d: *mut QString, set: fn(*mut QString, *const c_char, len: c_int), ) { let o = &*ptr; let data = o.user_name(to_usize(row)); let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); } #[no_mangle] pub unsafe extern "C" fn no_role_set_data_user_name( ptr: *mut NoRole, row: c_int, s: *const c_ushort, len: c_int, ) -> bool { let o = &mut *ptr; let mut v = String::new(); set_string_from_utf16(&mut v, s, len); o.set_user_name(to_usize(row), v) } pub struct PersonsQObject {} pub struct PersonsEmitter { qobject: Arc>, new_data_ready: fn(*mut PersonsQObject), } unsafe impl Send for PersonsEmitter {} impl PersonsEmitter { /// 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) -> PersonsEmitter { PersonsEmitter { qobject: self.qobject.clone(), new_data_ready: self.new_data_ready, } } fn clear(&self) { let n: *const PersonsQObject = null(); self.qobject.store(n as *mut PersonsQObject, Ordering::SeqCst); } pub fn new_data_ready(&mut self) { let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() { (self.new_data_ready)(ptr); } } } #[derive(Clone)] pub struct PersonsList { qobject: *mut PersonsQObject, layout_about_to_be_changed: fn(*mut PersonsQObject), layout_changed: fn(*mut PersonsQObject), data_changed: fn(*mut PersonsQObject, usize, usize), begin_reset_model: fn(*mut PersonsQObject), end_reset_model: fn(*mut PersonsQObject), begin_insert_rows: fn(*mut PersonsQObject, usize, usize), end_insert_rows: fn(*mut PersonsQObject), begin_move_rows: fn(*mut PersonsQObject, usize, usize, usize), end_move_rows: fn(*mut PersonsQObject), begin_remove_rows: fn(*mut PersonsQObject, usize, usize), end_remove_rows: fn(*mut PersonsQObject), } impl PersonsList { pub fn layout_about_to_be_changed(&mut self) { (self.layout_about_to_be_changed)(self.qobject); } pub fn layout_changed(&mut self) { (self.layout_changed)(self.qobject); } pub fn data_changed(&mut self, first: usize, last: usize) { (self.data_changed)(self.qobject, first, last); } pub fn begin_reset_model(&mut self) { (self.begin_reset_model)(self.qobject); } pub fn end_reset_model(&mut self) { (self.end_reset_model)(self.qobject); } pub fn begin_insert_rows(&mut self, first: usize, last: usize) { (self.begin_insert_rows)(self.qobject, first, last); } pub fn end_insert_rows(&mut self) { (self.end_insert_rows)(self.qobject); } pub fn begin_move_rows(&mut self, first: usize, last: usize, destination: usize) { (self.begin_move_rows)(self.qobject, first, last, destination); } pub fn end_move_rows(&mut self) { (self.end_move_rows)(self.qobject); } pub fn begin_remove_rows(&mut self, first: usize, last: usize) { (self.begin_remove_rows)(self.qobject, first, last); } pub fn end_remove_rows(&mut self) { (self.end_remove_rows)(self.qobject); } } pub trait PersonsTrait { fn new(emit: PersonsEmitter, model: PersonsList) -> Self; fn emit(&mut self) -> &mut PersonsEmitter; fn row_count(&self) -> usize; fn insert_rows(&mut self, _row: usize, _count: usize) -> bool { false } fn remove_rows(&mut self, _row: usize, _count: usize) -> bool { false } fn can_fetch_more(&self) -> bool { false } fn fetch_more(&mut self) {} - fn sort(&mut self, u8, SortOrder) {} + fn sort(&mut self, _: u8, _: SortOrder) {} fn user_name(&self, index: usize) -> &str; - fn set_user_name(&mut self, index: usize, String) -> bool; + fn set_user_name(&mut self, index: usize, _: String) -> bool; } #[no_mangle] pub extern "C" fn persons_new( persons: *mut PersonsQObject, persons_new_data_ready: fn(*mut PersonsQObject), persons_layout_about_to_be_changed: fn(*mut PersonsQObject), persons_layout_changed: fn(*mut PersonsQObject), persons_data_changed: fn(*mut PersonsQObject, usize, usize), persons_begin_reset_model: fn(*mut PersonsQObject), persons_end_reset_model: fn(*mut PersonsQObject), persons_begin_insert_rows: fn(*mut PersonsQObject, usize, usize), persons_end_insert_rows: fn(*mut PersonsQObject), persons_begin_move_rows: fn(*mut PersonsQObject, usize, usize, usize), persons_end_move_rows: fn(*mut PersonsQObject), persons_begin_remove_rows: fn(*mut PersonsQObject, usize, usize), persons_end_remove_rows: fn(*mut PersonsQObject), ) -> *mut Persons { let persons_emit = PersonsEmitter { qobject: Arc::new(AtomicPtr::new(persons)), new_data_ready: persons_new_data_ready, }; let model = PersonsList { qobject: persons, layout_about_to_be_changed: persons_layout_about_to_be_changed, layout_changed: persons_layout_changed, data_changed: persons_data_changed, begin_reset_model: persons_begin_reset_model, end_reset_model: persons_end_reset_model, begin_insert_rows: persons_begin_insert_rows, end_insert_rows: persons_end_insert_rows, begin_move_rows: persons_begin_move_rows, end_move_rows: persons_end_move_rows, begin_remove_rows: persons_begin_remove_rows, end_remove_rows: persons_end_remove_rows, }; let d_persons = Persons::new(persons_emit, model); Box::into_raw(Box::new(d_persons)) } #[no_mangle] pub unsafe extern "C" fn persons_free(ptr: *mut Persons) { Box::from_raw(ptr).emit().clear(); } #[no_mangle] pub unsafe extern "C" fn persons_row_count(ptr: *const Persons) -> c_int { to_c_int((&*ptr).row_count()) } #[no_mangle] pub unsafe extern "C" fn persons_insert_rows(ptr: *mut Persons, row: c_int, count: c_int) -> bool { (&mut *ptr).insert_rows(to_usize(row), to_usize(count)) } #[no_mangle] pub unsafe extern "C" fn persons_remove_rows(ptr: *mut Persons, row: c_int, count: c_int) -> bool { (&mut *ptr).remove_rows(to_usize(row), to_usize(count)) } #[no_mangle] pub unsafe extern "C" fn persons_can_fetch_more(ptr: *const Persons) -> bool { (&*ptr).can_fetch_more() } #[no_mangle] pub unsafe extern "C" fn persons_fetch_more(ptr: *mut Persons) { (&mut *ptr).fetch_more() } #[no_mangle] pub unsafe extern "C" fn persons_sort( ptr: *mut Persons, column: u8, order: SortOrder, ) { (&mut *ptr).sort(column, order) } #[no_mangle] pub unsafe extern "C" fn persons_data_user_name( ptr: *const Persons, row: c_int, d: *mut QString, set: fn(*mut QString, *const c_char, len: c_int), ) { let o = &*ptr; let data = o.user_name(to_usize(row)); let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); } #[no_mangle] pub unsafe extern "C" fn persons_set_data_user_name( ptr: *mut Persons, row: c_int, s: *const c_ushort, len: c_int, ) -> bool { let o = &mut *ptr; let mut v = String::new(); set_string_from_utf16(&mut v, s, len); o.set_user_name(to_usize(row), v) } diff --git a/tests/rust_list_types/src/interface.rs b/tests/rust_list_types/src/interface.rs index 2fabcd4..ad73b74 100644 --- a/tests/rust_list_types/src/interface.rs +++ b/tests/rust_list_types/src/interface.rs @@ -1,573 +1,573 @@ /* 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::*; #[repr(C)] pub struct COption { data: T, some: bool, } impl COption { #![allow(dead_code)] fn into(self) -> Option { if self.some { Some(self.data) } else { None } } } impl From> for COption where T: Default, { fn from(t: Option) -> COption { if let Some(v) = t { COption { data: v, some: true, } } else { COption { data: T::default(), some: false, } } } } 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); } pub enum QByteArray {} #[repr(C)] #[derive(PartialEq, Eq, Debug)] pub enum SortOrder { Ascending = 0, Descending = 1, } #[repr(C)] pub struct QModelIndex { row: c_int, internal_id: usize, } 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 ListQObject {} pub struct ListEmitter { qobject: Arc>, new_data_ready: fn(*mut ListQObject), } unsafe impl Send for ListEmitter {} impl ListEmitter { /// 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) -> ListEmitter { ListEmitter { qobject: self.qobject.clone(), new_data_ready: self.new_data_ready, } } fn clear(&self) { let n: *const ListQObject = null(); self.qobject.store(n as *mut ListQObject, Ordering::SeqCst); } pub fn new_data_ready(&mut self) { let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() { (self.new_data_ready)(ptr); } } } #[derive(Clone)] pub struct ListList { qobject: *mut ListQObject, layout_about_to_be_changed: fn(*mut ListQObject), layout_changed: fn(*mut ListQObject), data_changed: fn(*mut ListQObject, usize, usize), begin_reset_model: fn(*mut ListQObject), end_reset_model: fn(*mut ListQObject), begin_insert_rows: fn(*mut ListQObject, usize, usize), end_insert_rows: fn(*mut ListQObject), begin_move_rows: fn(*mut ListQObject, usize, usize, usize), end_move_rows: fn(*mut ListQObject), begin_remove_rows: fn(*mut ListQObject, usize, usize), end_remove_rows: fn(*mut ListQObject), } impl ListList { pub fn layout_about_to_be_changed(&mut self) { (self.layout_about_to_be_changed)(self.qobject); } pub fn layout_changed(&mut self) { (self.layout_changed)(self.qobject); } pub fn data_changed(&mut self, first: usize, last: usize) { (self.data_changed)(self.qobject, first, last); } pub fn begin_reset_model(&mut self) { (self.begin_reset_model)(self.qobject); } pub fn end_reset_model(&mut self) { (self.end_reset_model)(self.qobject); } pub fn begin_insert_rows(&mut self, first: usize, last: usize) { (self.begin_insert_rows)(self.qobject, first, last); } pub fn end_insert_rows(&mut self) { (self.end_insert_rows)(self.qobject); } pub fn begin_move_rows(&mut self, first: usize, last: usize, destination: usize) { (self.begin_move_rows)(self.qobject, first, last, destination); } pub fn end_move_rows(&mut self) { (self.end_move_rows)(self.qobject); } pub fn begin_remove_rows(&mut self, first: usize, last: usize) { (self.begin_remove_rows)(self.qobject, first, last); } pub fn end_remove_rows(&mut self) { (self.end_remove_rows)(self.qobject); } } pub trait ListTrait { fn new(emit: ListEmitter, model: ListList) -> Self; fn emit(&mut self) -> &mut ListEmitter; fn row_count(&self) -> usize; fn insert_rows(&mut self, _row: usize, _count: usize) -> bool { false } fn remove_rows(&mut self, _row: usize, _count: usize) -> bool { false } fn can_fetch_more(&self) -> bool { false } fn fetch_more(&mut self) {} - fn sort(&mut self, u8, SortOrder) {} + fn sort(&mut self, _: u8, _: SortOrder) {} fn boolean(&self, index: usize) -> bool; - fn set_boolean(&mut self, index: usize, bool) -> bool; + fn set_boolean(&mut self, index: usize, _: bool) -> bool; fn bytearray(&self, index: usize) -> &[u8]; - fn set_bytearray(&mut self, index: usize, &[u8]) -> bool; + fn set_bytearray(&mut self, index: usize, _: &[u8]) -> bool; fn f32(&self, index: usize) -> f32; - fn set_f32(&mut self, index: usize, f32) -> bool; + fn set_f32(&mut self, index: usize, _: f32) -> bool; fn f64(&self, index: usize) -> f64; - fn set_f64(&mut self, index: usize, f64) -> bool; + fn set_f64(&mut self, index: usize, _: f64) -> bool; fn i16(&self, index: usize) -> i16; - fn set_i16(&mut self, index: usize, i16) -> bool; + fn set_i16(&mut self, index: usize, _: i16) -> bool; fn i32(&self, index: usize) -> i32; - fn set_i32(&mut self, index: usize, i32) -> bool; + fn set_i32(&mut self, index: usize, _: i32) -> bool; fn i64(&self, index: usize) -> i64; - fn set_i64(&mut self, index: usize, i64) -> bool; + fn set_i64(&mut self, index: usize, _: i64) -> bool; fn i8(&self, index: usize) -> i8; - fn set_i8(&mut self, index: usize, i8) -> bool; + fn set_i8(&mut self, index: usize, _: i8) -> bool; fn optional_boolean(&self, index: usize) -> Option; - fn set_optional_boolean(&mut self, index: usize, Option) -> bool; + fn set_optional_boolean(&mut self, index: usize, _: Option) -> bool; fn optional_bytearray(&self, index: usize) -> Option<&[u8]>; - fn set_optional_bytearray(&mut self, index: usize, Option<&[u8]>) -> bool; + fn set_optional_bytearray(&mut self, index: usize, _: Option<&[u8]>) -> bool; fn optional_string(&self, index: usize) -> Option<&str>; - fn set_optional_string(&mut self, index: usize, Option) -> bool; + fn set_optional_string(&mut self, index: usize, _: Option) -> bool; fn string(&self, index: usize) -> &str; - fn set_string(&mut self, index: usize, String) -> bool; + fn set_string(&mut self, index: usize, _: String) -> bool; fn u16(&self, index: usize) -> u16; - fn set_u16(&mut self, index: usize, u16) -> bool; + fn set_u16(&mut self, index: usize, _: u16) -> bool; fn u32(&self, index: usize) -> u32; - fn set_u32(&mut self, index: usize, u32) -> bool; + fn set_u32(&mut self, index: usize, _: u32) -> bool; fn u64(&self, index: usize) -> u64; - fn set_u64(&mut self, index: usize, u64) -> bool; + fn set_u64(&mut self, index: usize, _: u64) -> bool; fn u8(&self, index: usize) -> u8; - fn set_u8(&mut self, index: usize, u8) -> bool; + fn set_u8(&mut self, index: usize, _: u8) -> bool; } #[no_mangle] pub extern "C" fn list_new( list: *mut ListQObject, list_new_data_ready: fn(*mut ListQObject), list_layout_about_to_be_changed: fn(*mut ListQObject), list_layout_changed: fn(*mut ListQObject), list_data_changed: fn(*mut ListQObject, usize, usize), list_begin_reset_model: fn(*mut ListQObject), list_end_reset_model: fn(*mut ListQObject), list_begin_insert_rows: fn(*mut ListQObject, usize, usize), list_end_insert_rows: fn(*mut ListQObject), list_begin_move_rows: fn(*mut ListQObject, usize, usize, usize), list_end_move_rows: fn(*mut ListQObject), list_begin_remove_rows: fn(*mut ListQObject, usize, usize), list_end_remove_rows: fn(*mut ListQObject), ) -> *mut List { let list_emit = ListEmitter { qobject: Arc::new(AtomicPtr::new(list)), new_data_ready: list_new_data_ready, }; let model = ListList { qobject: list, layout_about_to_be_changed: list_layout_about_to_be_changed, layout_changed: list_layout_changed, data_changed: list_data_changed, begin_reset_model: list_begin_reset_model, end_reset_model: list_end_reset_model, begin_insert_rows: list_begin_insert_rows, end_insert_rows: list_end_insert_rows, begin_move_rows: list_begin_move_rows, end_move_rows: list_end_move_rows, begin_remove_rows: list_begin_remove_rows, end_remove_rows: list_end_remove_rows, }; let d_list = List::new(list_emit, model); Box::into_raw(Box::new(d_list)) } #[no_mangle] pub unsafe extern "C" fn list_free(ptr: *mut List) { Box::from_raw(ptr).emit().clear(); } #[no_mangle] pub unsafe extern "C" fn list_row_count(ptr: *const List) -> c_int { to_c_int((&*ptr).row_count()) } #[no_mangle] pub unsafe extern "C" fn list_insert_rows(ptr: *mut List, row: c_int, count: c_int) -> bool { (&mut *ptr).insert_rows(to_usize(row), to_usize(count)) } #[no_mangle] pub unsafe extern "C" fn list_remove_rows(ptr: *mut List, row: c_int, count: c_int) -> bool { (&mut *ptr).remove_rows(to_usize(row), to_usize(count)) } #[no_mangle] pub unsafe extern "C" fn list_can_fetch_more(ptr: *const List) -> bool { (&*ptr).can_fetch_more() } #[no_mangle] pub unsafe extern "C" fn list_fetch_more(ptr: *mut List) { (&mut *ptr).fetch_more() } #[no_mangle] pub unsafe extern "C" fn list_sort( ptr: *mut List, column: u8, order: SortOrder, ) { (&mut *ptr).sort(column, order) } #[no_mangle] pub unsafe extern "C" fn list_data_boolean(ptr: *const List, row: c_int) -> bool { let o = &*ptr; o.boolean(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn list_set_data_boolean( ptr: *mut List, row: c_int, v: bool, ) -> bool { (&mut *ptr).set_boolean(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn list_data_bytearray( ptr: *const List, row: c_int, d: *mut QByteArray, set: fn(*mut QByteArray, *const c_char, len: c_int), ) { let o = &*ptr; let data = o.bytearray(to_usize(row)); let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); } #[no_mangle] pub unsafe extern "C" fn list_set_data_bytearray( ptr: *mut List, row: c_int, s: *const c_char, len: c_int, ) -> bool { let o = &mut *ptr; let slice = ::std::slice::from_raw_parts(s as *const u8, to_usize(len)); o.set_bytearray(to_usize(row), slice) } #[no_mangle] pub unsafe extern "C" fn list_data_f32(ptr: *const List, row: c_int) -> f32 { let o = &*ptr; o.f32(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn list_set_data_f32( ptr: *mut List, row: c_int, v: f32, ) -> bool { (&mut *ptr).set_f32(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn list_data_f64(ptr: *const List, row: c_int) -> f64 { let o = &*ptr; o.f64(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn list_set_data_f64( ptr: *mut List, row: c_int, v: f64, ) -> bool { (&mut *ptr).set_f64(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn list_data_i16(ptr: *const List, row: c_int) -> i16 { let o = &*ptr; o.i16(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn list_set_data_i16( ptr: *mut List, row: c_int, v: i16, ) -> bool { (&mut *ptr).set_i16(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn list_data_i32(ptr: *const List, row: c_int) -> i32 { let o = &*ptr; o.i32(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn list_set_data_i32( ptr: *mut List, row: c_int, v: i32, ) -> bool { (&mut *ptr).set_i32(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn list_data_i64(ptr: *const List, row: c_int) -> i64 { let o = &*ptr; o.i64(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn list_set_data_i64( ptr: *mut List, row: c_int, v: i64, ) -> bool { (&mut *ptr).set_i64(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn list_data_i8(ptr: *const List, row: c_int) -> i8 { let o = &*ptr; o.i8(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn list_set_data_i8( ptr: *mut List, row: c_int, v: i8, ) -> bool { (&mut *ptr).set_i8(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn list_data_optional_boolean(ptr: *const List, row: c_int) -> COption { let o = &*ptr; o.optional_boolean(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn list_set_data_optional_boolean( ptr: *mut List, row: c_int, v: bool, ) -> bool { (&mut *ptr).set_optional_boolean(to_usize(row), Some(v)) } #[no_mangle] pub unsafe extern "C" fn list_set_data_optional_boolean_none(ptr: *mut List, row: c_int) -> bool { (&mut *ptr).set_optional_boolean(to_usize(row), None) } #[no_mangle] pub unsafe extern "C" fn list_data_optional_bytearray( ptr: *const List, row: c_int, d: *mut QByteArray, set: fn(*mut QByteArray, *const c_char, len: c_int), ) { let o = &*ptr; let data = o.optional_bytearray(to_usize(row)); if let Some(data) = data { let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); } } #[no_mangle] pub unsafe extern "C" fn list_set_data_optional_bytearray( ptr: *mut List, row: c_int, s: *const c_char, len: c_int, ) -> bool { let o = &mut *ptr; let slice = ::std::slice::from_raw_parts(s as *const u8, to_usize(len)); o.set_optional_bytearray(to_usize(row), Some(slice)) } #[no_mangle] pub unsafe extern "C" fn list_set_data_optional_bytearray_none(ptr: *mut List, row: c_int) -> bool { (&mut *ptr).set_optional_bytearray(to_usize(row), None) } #[no_mangle] pub unsafe extern "C" fn list_data_optional_string( ptr: *const List, row: c_int, d: *mut QString, set: fn(*mut QString, *const c_char, len: c_int), ) { let o = &*ptr; let data = o.optional_string(to_usize(row)); if let Some(data) = data { let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); } } #[no_mangle] pub unsafe extern "C" fn list_set_data_optional_string( ptr: *mut List, row: c_int, s: *const c_ushort, len: c_int, ) -> bool { let o = &mut *ptr; let mut v = String::new(); set_string_from_utf16(&mut v, s, len); o.set_optional_string(to_usize(row), Some(v)) } #[no_mangle] pub unsafe extern "C" fn list_set_data_optional_string_none(ptr: *mut List, row: c_int) -> bool { (&mut *ptr).set_optional_string(to_usize(row), None) } #[no_mangle] pub unsafe extern "C" fn list_data_string( ptr: *const List, row: c_int, d: *mut QString, set: fn(*mut QString, *const c_char, len: c_int), ) { let o = &*ptr; let data = o.string(to_usize(row)); let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); } #[no_mangle] pub unsafe extern "C" fn list_set_data_string( ptr: *mut List, row: c_int, s: *const c_ushort, len: c_int, ) -> bool { let o = &mut *ptr; let mut v = String::new(); set_string_from_utf16(&mut v, s, len); o.set_string(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn list_data_u16(ptr: *const List, row: c_int) -> u16 { let o = &*ptr; o.u16(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn list_set_data_u16( ptr: *mut List, row: c_int, v: u16, ) -> bool { (&mut *ptr).set_u16(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn list_data_u32(ptr: *const List, row: c_int) -> u32 { let o = &*ptr; o.u32(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn list_set_data_u32( ptr: *mut List, row: c_int, v: u32, ) -> bool { (&mut *ptr).set_u32(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn list_data_u64(ptr: *const List, row: c_int) -> u64 { let o = &*ptr; o.u64(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn list_set_data_u64( ptr: *mut List, row: c_int, v: u64, ) -> bool { (&mut *ptr).set_u64(to_usize(row), v) } #[no_mangle] pub unsafe extern "C" fn list_data_u8(ptr: *const List, row: c_int) -> u8 { let o = &*ptr; o.u8(to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn list_set_data_u8( ptr: *mut List, row: c_int, v: u8, ) -> bool { (&mut *ptr).set_u8(to_usize(row), v) } diff --git a/tests/rust_tree/src/interface.rs b/tests/rust_tree/src/interface.rs index 618120b..f7a8f7c 100644 --- a/tests/rust_tree/src/interface.rs +++ b/tests/rust_tree/src/interface.rs @@ -1,320 +1,320 @@ /* 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::*; #[repr(C)] pub struct COption { data: T, some: bool, } impl COption { #![allow(dead_code)] fn into(self) -> Option { if self.some { Some(self.data) } else { None } } } impl From> for COption where T: Default, { fn from(t: Option) -> COption { if let Some(v) = t { COption { data: v, some: true, } } else { COption { data: T::default(), some: false, } } } } 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); } #[repr(C)] #[derive(PartialEq, Eq, Debug)] pub enum SortOrder { Ascending = 0, Descending = 1, } #[repr(C)] pub struct QModelIndex { row: c_int, internal_id: usize, } 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 PersonsQObject {} pub struct PersonsEmitter { qobject: Arc>, new_data_ready: fn(*mut PersonsQObject, index: COption), } unsafe impl Send for PersonsEmitter {} impl PersonsEmitter { /// 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) -> PersonsEmitter { PersonsEmitter { qobject: self.qobject.clone(), new_data_ready: self.new_data_ready, } } fn clear(&self) { let n: *const PersonsQObject = null(); self.qobject.store(n as *mut PersonsQObject, Ordering::SeqCst); } pub fn new_data_ready(&mut self, item: Option) { let ptr = self.qobject.load(Ordering::SeqCst); if !ptr.is_null() { (self.new_data_ready)(ptr, item.into()); } } } #[derive(Clone)] pub struct PersonsTree { qobject: *mut PersonsQObject, layout_about_to_be_changed: fn(*mut PersonsQObject), layout_changed: fn(*mut PersonsQObject), data_changed: fn(*mut PersonsQObject, usize, usize), begin_reset_model: fn(*mut PersonsQObject), end_reset_model: fn(*mut PersonsQObject), begin_insert_rows: fn(*mut PersonsQObject, index: COption, usize, usize), end_insert_rows: fn(*mut PersonsQObject), begin_move_rows: fn(*mut PersonsQObject, index: COption, usize, usize, dest: COption, usize), end_move_rows: fn(*mut PersonsQObject), begin_remove_rows: fn(*mut PersonsQObject, index: COption, usize, usize), end_remove_rows: fn(*mut PersonsQObject), } impl PersonsTree { pub fn layout_about_to_be_changed(&mut self) { (self.layout_about_to_be_changed)(self.qobject); } pub fn layout_changed(&mut self) { (self.layout_changed)(self.qobject); } pub fn data_changed(&mut self, first: usize, last: usize) { (self.data_changed)(self.qobject, first, last); } pub fn begin_reset_model(&mut self) { (self.begin_reset_model)(self.qobject); } pub fn end_reset_model(&mut self) { (self.end_reset_model)(self.qobject); } pub fn begin_insert_rows(&mut self, index: Option, first: usize, last: usize) { (self.begin_insert_rows)(self.qobject, index.into(), first, last); } pub fn end_insert_rows(&mut self) { (self.end_insert_rows)(self.qobject); } pub fn begin_move_rows(&mut self, index: Option, first: usize, last: usize, dest: Option, destination: usize) { (self.begin_move_rows)(self.qobject, index.into(), first, last, dest.into(), destination); } pub fn end_move_rows(&mut self) { (self.end_move_rows)(self.qobject); } pub fn begin_remove_rows(&mut self, index: Option, first: usize, last: usize) { (self.begin_remove_rows)(self.qobject, index.into(), first, last); } pub fn end_remove_rows(&mut self) { (self.end_remove_rows)(self.qobject); } } pub trait PersonsTrait { fn new(emit: PersonsEmitter, model: PersonsTree) -> Self; fn emit(&mut self) -> &mut PersonsEmitter; - fn row_count(&self, Option) -> usize; - fn can_fetch_more(&self, Option) -> bool { + fn row_count(&self, _: Option) -> usize; + fn can_fetch_more(&self, _: Option) -> bool { false } - fn fetch_more(&mut self, Option) {} - fn sort(&mut self, u8, SortOrder) {} + fn fetch_more(&mut self, _: Option) {} + fn sort(&mut self, _: u8, _: SortOrder) {} fn check_row(&self, index: usize, row: usize) -> Option; fn index(&self, item: Option, row: usize) -> usize; fn parent(&self, index: usize) -> Option; fn row(&self, index: usize) -> usize; fn user_name(&self, index: usize) -> &str; - fn set_user_name(&mut self, index: usize, String) -> bool; + fn set_user_name(&mut self, index: usize, _: String) -> bool; } #[no_mangle] pub extern "C" fn persons_new( persons: *mut PersonsQObject, persons_new_data_ready: fn(*mut PersonsQObject, index: COption), persons_layout_about_to_be_changed: fn(*mut PersonsQObject), persons_layout_changed: fn(*mut PersonsQObject), persons_data_changed: fn(*mut PersonsQObject, usize, usize), persons_begin_reset_model: fn(*mut PersonsQObject), persons_end_reset_model: fn(*mut PersonsQObject), persons_begin_insert_rows: fn(*mut PersonsQObject, index: COption, usize, usize), persons_end_insert_rows: fn(*mut PersonsQObject), persons_begin_move_rows: fn(*mut PersonsQObject, index: COption, usize, usize, index: COption, usize), persons_end_move_rows: fn(*mut PersonsQObject), persons_begin_remove_rows: fn(*mut PersonsQObject, index: COption, usize, usize), persons_end_remove_rows: fn(*mut PersonsQObject), ) -> *mut Persons { let persons_emit = PersonsEmitter { qobject: Arc::new(AtomicPtr::new(persons)), new_data_ready: persons_new_data_ready, }; let model = PersonsTree { qobject: persons, layout_about_to_be_changed: persons_layout_about_to_be_changed, layout_changed: persons_layout_changed, data_changed: persons_data_changed, begin_reset_model: persons_begin_reset_model, end_reset_model: persons_end_reset_model, begin_insert_rows: persons_begin_insert_rows, end_insert_rows: persons_end_insert_rows, begin_move_rows: persons_begin_move_rows, end_move_rows: persons_end_move_rows, begin_remove_rows: persons_begin_remove_rows, end_remove_rows: persons_end_remove_rows, }; let d_persons = Persons::new(persons_emit, model); Box::into_raw(Box::new(d_persons)) } #[no_mangle] pub unsafe extern "C" fn persons_free(ptr: *mut Persons) { Box::from_raw(ptr).emit().clear(); } #[no_mangle] pub unsafe extern "C" fn persons_row_count( ptr: *const Persons, index: COption, ) -> c_int { to_c_int((&*ptr).row_count(index.into())) } #[no_mangle] pub unsafe extern "C" fn persons_can_fetch_more( ptr: *const Persons, index: COption, ) -> bool { (&*ptr).can_fetch_more(index.into()) } #[no_mangle] pub unsafe extern "C" fn persons_fetch_more(ptr: *mut Persons, index: COption) { (&mut *ptr).fetch_more(index.into()) } #[no_mangle] pub unsafe extern "C" fn persons_sort( ptr: *mut Persons, column: u8, order: SortOrder ) { (&mut *ptr).sort(column, order) } #[no_mangle] pub unsafe extern "C" fn persons_check_row( ptr: *const Persons, index: usize, row: c_int, ) -> COption { (&*ptr).check_row(index.into(), to_usize(row)).into() } #[no_mangle] pub unsafe extern "C" fn persons_index( ptr: *const Persons, index: COption, row: c_int, ) -> usize { (&*ptr).index(index.into(), to_usize(row)) } #[no_mangle] pub unsafe extern "C" fn persons_parent(ptr: *const Persons, index: usize) -> QModelIndex { if let Some(parent) = (&*ptr).parent(index) { QModelIndex { row: to_c_int((&*ptr).row(parent)), internal_id: parent, } } else { QModelIndex { row: -1, internal_id: 0, } } } #[no_mangle] pub unsafe extern "C" fn persons_row(ptr: *const Persons, index: usize) -> c_int { to_c_int((&*ptr).row(index)) } #[no_mangle] pub unsafe extern "C" fn persons_data_user_name( ptr: *const Persons, index: usize, d: *mut QString, set: fn(*mut QString, *const c_char, len: c_int), ) { let o = &*ptr; let data = o.user_name(index); let s: *const c_char = data.as_ptr() as (*const c_char); set(d, s, to_c_int(data.len())); } #[no_mangle] pub unsafe extern "C" fn persons_set_data_user_name( ptr: *mut Persons, index: usize, s: *const c_ushort, len: c_int, ) -> bool { let o = &mut *ptr; let mut v = String::new(); set_string_from_utf16(&mut v, s, len); o.set_user_name(index, v) }