marrub
/
rust-qt-binding-generator
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Rust code formatting improvements

master
Jos van den Oever 2017-08-29 20:37:51 +02:00
parent 3e9e4208ce
commit bd908181ec
19 changed files with 575 additions and 350 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
demo/rust/src/fibonacci_implementation.rs
View File

@ -6,7 +6,7 @@ use std::sync::Arc;
fn fibonacci(input: u32) -> usize { fn fibonacci(input: u32) -> usize {
if input <= 1 { if input <= 1 {
return input as usize return input as usize;
} }
let mut i = 0; let mut i = 0;
let mut sum = 0; let mut sum = 0;

61
demo/rust/src/fibonacci_interface.rs
View File

@ -16,17 +16,20 @@ pub struct COption<T> {
some: bool, some: bool,
} }
impl<T> From<Option<T>> for COption<T> where T: Default { impl<T> From<Option<T>> for COption<T>
fn from(t: Option<T>) -> COption <T> { where
T: Default,
{
fn from(t: Option<T>) -> COption<T> {
if let Some(v) = t { if let Some(v) = t {
COption { COption {
data: v, data: v,
some: true some: true,
} }
} else { } else {
COption { COption {
data: T::default(), data: T::default(),
some: false some: false,
} }
} }
} }
@ -36,7 +39,7 @@ impl<T> From<Option<T>> for COption<T> where T: Default {
#[repr(C)] #[repr(C)]
pub enum SortOrder { pub enum SortOrder {
Ascending = 0, Ascending = 0,
Descending = 1 Descending = 1,
} }
#[repr(C)] #[repr(C)]
@ -47,7 +50,7 @@ pub struct QModelIndex {
pub struct FibonacciQObject {} pub struct FibonacciQObject {}
#[derive (Clone)] #[derive(Clone)]
pub struct FibonacciEmitter { pub struct FibonacciEmitter {
qobject: Arc<Mutex<*const FibonacciQObject>>, qobject: Arc<Mutex<*const FibonacciQObject>>,
input_changed: fn(*const FibonacciQObject), input_changed: fn(*const FibonacciQObject),
@ -83,10 +86,11 @@ pub trait FibonacciTrait {
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn fibonacci_new(fibonacci: *mut FibonacciQObject, pub extern "C" fn fibonacci_new(
input_changed: fn(*const FibonacciQObject), fibonacci: *mut FibonacciQObject,
result_changed: fn(*const FibonacciQObject)) input_changed: fn(*const FibonacciQObject),
-> *mut Fibonacci { result_changed: fn(*const FibonacciQObject),
) -> *mut Fibonacci {
let fibonacci_emit = FibonacciEmitter { let fibonacci_emit = FibonacciEmitter {
qobject: Arc::new(Mutex::new(fibonacci)), qobject: Arc::new(Mutex::new(fibonacci)),
input_changed: input_changed, input_changed: input_changed,
@ -118,7 +122,7 @@ pub unsafe extern "C" fn fibonacci_result_get(ptr: *const Fibonacci) -> u64 {
pub struct FibonacciListQObject {} pub struct FibonacciListQObject {}
#[derive (Clone)] #[derive(Clone)]
pub struct FibonacciListEmitter { pub struct FibonacciListEmitter {
qobject: Arc<Mutex<*const FibonacciListQObject>>, qobject: Arc<Mutex<*const FibonacciListQObject>>,
new_data_ready: fn(*const FibonacciListQObject), new_data_ready: fn(*const FibonacciListQObject),
@ -177,27 +181,26 @@ pub trait FibonacciListTrait {
fn create(emit: FibonacciListEmitter, model: FibonacciListList) -> Self; fn create(emit: FibonacciListEmitter, model: FibonacciListList) -> Self;
fn emit(&self) -> &FibonacciListEmitter; fn emit(&self) -> &FibonacciListEmitter;
fn row_count(&self) -> usize; fn row_count(&self) -> usize;
fn can_fetch_more(&self) -> bool { false } fn can_fetch_more(&self) -> bool {
false
}
fn fetch_more(&mut self) {} fn fetch_more(&mut self) {}
fn sort(&mut self, u8, SortOrder) {} fn sort(&mut self, u8, SortOrder) {}
fn result(&self, item: usize) -> u64; fn result(&self, item: usize) -> u64;
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn fibonacci_list_new(fibonacci_list: *mut FibonacciListQObject, pub extern "C" fn fibonacci_list_new(
new_data_ready: fn(*const FibonacciListQObject), fibonacci_list: *mut FibonacciListQObject,
data_changed: fn(*const FibonacciListQObject, usize, usize), new_data_ready: fn(*const FibonacciListQObject),
begin_reset_model: fn(*const FibonacciListQObject), data_changed: fn(*const FibonacciListQObject, usize, usize),
end_reset_model: fn(*const FibonacciListQObject), begin_reset_model: fn(*const FibonacciListQObject),
begin_insert_rows: fn(*const FibonacciListQObject, end_reset_model: fn(*const FibonacciListQObject),
usize, begin_insert_rows: fn(*const FibonacciListQObject, usize, usize),
usize), end_insert_rows: fn(*const FibonacciListQObject),
end_insert_rows: fn(*const FibonacciListQObject), begin_remove_rows: fn(*const FibonacciListQObject, usize, usize),
begin_remove_rows: fn(*const FibonacciListQObject, end_remove_rows: fn(*const FibonacciListQObject),
usize, ) -> *mut FibonacciList {
usize),
end_remove_rows: fn(*const FibonacciListQObject))
-> *mut FibonacciList {
let fibonacci_list_emit = FibonacciListEmitter { let fibonacci_list_emit = FibonacciListEmitter {
qobject: Arc::new(Mutex::new(fibonacci_list)), qobject: Arc::new(Mutex::new(fibonacci_list)),
new_data_ready: new_data_ready, new_data_ready: new_data_ready,
@ -234,7 +237,11 @@ pub unsafe extern "C" fn fibonacci_list_fetch_more(ptr: *mut FibonacciList) {
(&mut *ptr).fetch_more() (&mut *ptr).fetch_more()
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn fibonacci_list_sort(ptr: *mut FibonacciList, column: u8, order: SortOrder) { pub unsafe extern "C" fn fibonacci_list_sort(
ptr: *mut FibonacciList,
column: u8,
order: SortOrder,
) {
(&mut *ptr).sort(column, order) (&mut *ptr).sort(column, order)
} }

35
demo/rust/src/implementation.rs
View File

@ -12,7 +12,7 @@ use std::collections::HashMap;
pub struct DirEntry { pub struct DirEntry {
name: OsString, name: OsString,
metadata: Option<Metadata>, metadata: Option<Metadata>,
path: Option<PathBuf> path: Option<PathBuf>,
} }
type Incoming<T> = Arc<Mutex<HashMap<usize, Vec<T>>>>; type Incoming<T> = Arc<Mutex<HashMap<usize, Vec<T>>>>;
@ -22,11 +22,11 @@ impl Item for DirEntry {
DirEntry { DirEntry {
name: OsString::from(name), name: OsString::from(name),
metadata: metadata(name).ok(), metadata: metadata(name).ok(),
path: None path: None,
} }
} }
fn can_fetch_more(&self) -> bool { fn can_fetch_more(&self) -> bool {
self.metadata.as_ref().map_or(false, |m|m.is_dir()) self.metadata.as_ref().map_or(false, |m| m.is_dir())
} }
fn file_name(&self) -> String { fn file_name(&self) -> String {
self.name.to_string_lossy().to_string() self.name.to_string_lossy().to_string()
@ -41,11 +41,9 @@ impl Item for DirEntry {
0 0
} }
fn file_size(&self) -> Option<u64> { fn file_size(&self) -> Option<u64> {
self.metadata.as_ref().map(|m|m.len()) self.metadata.as_ref().map(|m| m.len())
} }
fn retrieve(id: usize, parents: Vec<&DirEntry>, fn retrieve(id: usize, parents: Vec<&DirEntry>, q: Incoming<Self>, emit: TreeEmitter) {
q: Incoming<Self>,
emit: TreeEmitter) {
let mut v = Vec::new(); let mut v = Vec::new();
let path: PathBuf = parents.into_iter().map(|e| &e.name).collect(); let path: PathBuf = parents.into_iter().map(|e| &e.name).collect();
thread::spawn(move || { thread::spawn(move || {
@ -54,7 +52,7 @@ impl Item for DirEntry {
let de = DirEntry { let de = DirEntry {
name: i.file_name(), name: i.file_name(),
metadata: i.metadata().ok(), metadata: i.metadata().ok(),
path: Some(i.path()) path: Some(i.path()),
}; };
v.push(de); v.push(de);
} }
@ -74,7 +72,7 @@ impl Default for DirEntry {
DirEntry { DirEntry {
name: OsString::new(), name: OsString::new(),
metadata: None, metadata: None,
path: None path: None,
} }
} }
} }
@ -107,7 +105,10 @@ pub struct RGeneralItemModel<T: Item> {
incoming: Incoming<T>, incoming: Incoming<T>,
} }
impl<T: Item> RGeneralItemModel<T> where T: Sync + Send { impl<T: Item> RGeneralItemModel<T>
where
T: Sync + Send,
{
fn reset(&mut self) { fn reset(&mut self) {
self.model.begin_reset_model(); self.model.begin_reset_model();
self.entries.clear(); self.entries.clear();
@ -150,8 +151,11 @@ impl<T: Item> RGeneralItemModel<T> where T: Sync + Send {
new_entries.push(e); new_entries.push(e);
} }
if new_entries.len() > 0 { if new_entries.len() > 0 {
self.model.begin_insert_rows(Some(id), 0, self.model.begin_insert_rows(
(new_entries.len() - 1)); Some(id),
0,
(new_entries.len() - 1),
);
} }
} }
self.entries[id].children = Some(children); self.entries[id].children = Some(children);
@ -173,14 +177,17 @@ impl<T: Item> RGeneralItemModel<T> where T: Sync + Send {
} }
} }
impl<T: Item> TreeTrait for RGeneralItemModel<T> where T: Sync + Send { impl<T: Item> TreeTrait for RGeneralItemModel<T>
where
T: Sync + Send,
{
fn create(emit: TreeEmitter, model: TreeUniformTree) -> Self { fn create(emit: TreeEmitter, model: TreeUniformTree) -> Self {
let mut tree = RGeneralItemModel { let mut tree = RGeneralItemModel {
emit: emit, emit: emit,
model: model, model: model,
entries: Vec::new(), entries: Vec::new(),
path: None, path: None,
incoming: Arc::new(Mutex::new(HashMap::new())) incoming: Arc::new(Mutex::new(HashMap::new())),
}; };
tree.reset(); tree.reset();
tree tree

115
demo/rust/src/interface.rs
View File

@ -16,17 +16,20 @@ pub struct COption<T> {
some: bool, some: bool,
} }
impl<T> From<Option<T>> for COption<T> where T: Default { impl<T> From<Option<T>> for COption<T>
fn from(t: Option<T>) -> COption <T> { where
T: Default,
{
fn from(t: Option<T>) -> COption<T> {
if let Some(v) = t { if let Some(v) = t {
COption { COption {
data: v, data: v,
some: true some: true,
} }
} else { } else {
COption { COption {
data: T::default(), data: T::default(),
some: false some: false,
} }
} }
} }
@ -88,7 +91,7 @@ impl<'a> From<&'a Vec<u8>> for QByteArray {
#[repr(C)] #[repr(C)]
pub enum SortOrder { pub enum SortOrder {
Ascending = 0, Ascending = 0,
Descending = 1 Descending = 1,
} }
#[repr(C)] #[repr(C)]
@ -99,7 +102,7 @@ pub struct QModelIndex {
pub struct TreeQObject {} pub struct TreeQObject {}
#[derive (Clone)] #[derive(Clone)]
pub struct TreeEmitter { pub struct TreeEmitter {
qobject: Arc<Mutex<*const TreeQObject>>, qobject: Arc<Mutex<*const TreeQObject>>,
path_changed: fn(*const TreeQObject), path_changed: fn(*const TreeQObject),
@ -121,7 +124,7 @@ impl TreeEmitter {
pub fn new_data_ready(&self, item: Option<usize>) { pub fn new_data_ready(&self, item: Option<usize>) {
let ptr = *self.qobject.lock().unwrap(); let ptr = *self.qobject.lock().unwrap();
if !ptr.is_null() { if !ptr.is_null() {
(self.new_data_ready)(ptr, item.unwrap_or(13), item.is_some()); (self.new_data_ready)(ptr, item.unwrap_or(13), item.is_some());
} }
} }
} }
@ -167,7 +170,9 @@ pub trait TreeTrait {
fn get_path(&self) -> Option<String>; fn get_path(&self) -> Option<String>;
fn set_path(&mut self, value: Option<String>); fn set_path(&mut self, value: Option<String>);
fn row_count(&self, Option<usize>) -> usize; fn row_count(&self, Option<usize>) -> usize;
fn can_fetch_more(&self, Option<usize>) -> bool { false } fn can_fetch_more(&self, Option<usize>) -> bool {
false
}
fn fetch_more(&mut self, Option<usize>) {} fn fetch_more(&mut self, Option<usize>) {}
fn sort(&mut self, u8, SortOrder) {} fn sort(&mut self, u8, SortOrder) {}
fn index(&self, item: Option<usize>, row: usize) -> usize; fn index(&self, item: Option<usize>, row: usize) -> usize;
@ -182,21 +187,18 @@ pub trait TreeTrait {
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn tree_new(tree: *mut TreeQObject, pub extern "C" fn tree_new(
path_changed: fn(*const TreeQObject), tree: *mut TreeQObject,
new_data_ready: fn(*const TreeQObject, item: usize, valid: bool), path_changed: fn(*const TreeQObject),
data_changed: fn(*const TreeQObject, usize, usize), new_data_ready: fn(*const TreeQObject, item: usize, valid: bool),
begin_reset_model: fn(*const TreeQObject), data_changed: fn(*const TreeQObject, usize, usize),
end_reset_model: fn(*const TreeQObject), begin_reset_model: fn(*const TreeQObject),
begin_insert_rows: fn(*const TreeQObject, item: usize, valid: bool, end_reset_model: fn(*const TreeQObject),
usize, begin_insert_rows: fn(*const TreeQObject, item: usize, valid: bool, usize, usize),
usize), end_insert_rows: fn(*const TreeQObject),
end_insert_rows: fn(*const TreeQObject), begin_remove_rows: fn(*const TreeQObject, item: usize, valid: bool, usize, usize),
begin_remove_rows: fn(*const TreeQObject, item: usize, valid: bool, end_remove_rows: fn(*const TreeQObject),
usize, ) -> *mut Tree {
usize),
end_remove_rows: fn(*const TreeQObject))
-> *mut Tree {
let tree_emit = TreeEmitter { let tree_emit = TreeEmitter {
qobject: Arc::new(Mutex::new(tree)), qobject: Arc::new(Mutex::new(tree)),
path_changed: path_changed, path_changed: path_changed,
@ -222,9 +224,11 @@ pub unsafe extern "C" fn tree_free(ptr: *mut Tree) {
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn tree_path_get(ptr: *const Tree, pub unsafe extern "C" fn tree_path_get(
p: *mut c_void, ptr: *const Tree,
set: fn(*mut c_void, QString)) { p: *mut c_void,
set: fn(*mut c_void, QString),
) {
let data = (&*ptr).get_path(); let data = (&*ptr).get_path();
if let Some(data) = data { if let Some(data) = data {
set(p, QString::from(&data)); set(p, QString::from(&data));
@ -241,7 +245,11 @@ pub unsafe extern "C" fn tree_path_set_none(ptr: *mut Tree) {
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn tree_row_count(ptr: *const Tree, item: usize, valid: bool) -> c_int { pub unsafe extern "C" fn tree_row_count(
ptr: *const Tree,
item: usize,
valid: bool,
) -> c_int {
if valid { if valid {
(&*ptr).row_count(Some(item)) as c_int (&*ptr).row_count(Some(item)) as c_int
} else { } else {
@ -249,7 +257,11 @@ pub unsafe extern "C" fn tree_row_count(ptr: *const Tree, item: usize, valid: bo
} }
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn tree_can_fetch_more(ptr: *const Tree, item: usize, valid: bool) -> bool { pub unsafe extern "C" fn tree_can_fetch_more(
ptr: *const Tree,
item: usize,
valid: bool,
) -> bool {
if valid { if valid {
(&*ptr).can_fetch_more(Some(item)) (&*ptr).can_fetch_more(Some(item))
} else { } else {
@ -265,11 +277,20 @@ pub unsafe extern "C" fn tree_fetch_more(ptr: *mut Tree, item: usize, valid: boo
} }
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn tree_sort(ptr: *mut Tree, column: u8, order: SortOrder) { pub unsafe extern "C" fn tree_sort(
ptr: *mut Tree,
column: u8,
order: SortOrder
) {
(&mut *ptr).sort(column, order) (&mut *ptr).sort(column, order)
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn tree_index(ptr: *const Tree, item: usize, valid: bool, row: c_int) -> usize { pub unsafe extern "C" fn tree_index(
ptr: *const Tree,
item: usize,
valid: bool,
row: c_int,
) -> usize {
if !valid { if !valid {
(&*ptr).index(None, row as usize) (&*ptr).index(None, row as usize)
} else { } else {
@ -279,9 +300,15 @@ pub unsafe extern "C" fn tree_index(ptr: *const Tree, item: usize, valid: bool,
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn tree_parent(ptr: *const Tree, index: usize) -> QModelIndex { pub unsafe extern "C" fn tree_parent(ptr: *const Tree, index: usize) -> QModelIndex {
if let Some(parent) = (&*ptr).parent(index) { if let Some(parent) = (&*ptr).parent(index) {
QModelIndex{row: (&*ptr).row(parent) as c_int, internal_id: parent} QModelIndex {
row: (&*ptr).row(parent) as c_int,
internal_id: parent,
}
} else { } else {
QModelIndex{row: -1, internal_id: 0} QModelIndex {
row: -1,
internal_id: 0,
}
} }
} }
#[no_mangle] #[no_mangle]
@ -290,25 +317,31 @@ pub unsafe extern "C" fn tree_row(ptr: *const Tree, item: usize) -> c_int {
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn tree_data_file_icon(ptr: *const Tree, item: usize, pub unsafe extern "C" fn tree_data_file_icon(
d: *mut c_void, ptr: *const Tree, item: usize,
set: fn(*mut c_void, QByteArray)) { d: *mut c_void,
set: fn(*mut c_void, QByteArray),
) {
let data = (&*ptr).file_icon(item); let data = (&*ptr).file_icon(item);
set(d, QByteArray::from(&data)); set(d, QByteArray::from(&data));
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn tree_data_file_name(ptr: *const Tree, item: usize, pub unsafe extern "C" fn tree_data_file_name(
d: *mut c_void, ptr: *const Tree, item: usize,
set: fn(*mut c_void, QString)) { d: *mut c_void,
set: fn(*mut c_void, QString),
) {
let data = (&*ptr).file_name(item); let data = (&*ptr).file_name(item);
set(d, QString::from(&data)); set(d, QString::from(&data));
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn tree_data_file_path(ptr: *const Tree, item: usize, pub unsafe extern "C" fn tree_data_file_path(
d: *mut c_void, ptr: *const Tree, item: usize,
set: fn(*mut c_void, QString)) { d: *mut c_void,
set: fn(*mut c_void, QString),
) {
let data = (&*ptr).file_path(item); let data = (&*ptr).file_path(item);
if let Some(data) = data { if let Some(data) = data {
set(d, QString::from(&data)); set(d, QString::from(&data));

105
demo/rust/src/processes_implementation.rs
View File

@ -8,14 +8,14 @@ use std::{thread, time};
struct ProcessItem { struct ProcessItem {
row: usize, row: usize,
tasks: Vec<pid_t>, tasks: Vec<pid_t>,
process: Process process: Process,
} }
#[derive (Default)] #[derive(Default)]
struct ProcessTree { struct ProcessTree {
top: Vec<pid_t>, top: Vec<pid_t>,
processes: HashMap<pid_t, ProcessItem>, processes: HashMap<pid_t, ProcessItem>,
cpusum: f32 cpusum: f32,
} }
pub struct Processes { pub struct Processes {
@ -23,10 +23,10 @@ pub struct Processes {
model: ProcessesUniformTree, model: ProcessesUniformTree,
p: ProcessTree, p: ProcessTree,
incoming: Arc<Mutex<Option<ProcessTree>>>, incoming: Arc<Mutex<Option<ProcessTree>>>,
active: bool active: bool,
} }
fn check_process_hierarchy(parent: Option<pid_t>, processes: &HashMap<pid_t,Process>) { fn check_process_hierarchy(parent: Option<pid_t>, processes: &HashMap<pid_t, Process>) {
for (pid, process) in processes { for (pid, process) in processes {
assert_eq!(process.pid, *pid); assert_eq!(process.pid, *pid);
if !parent.is_none() { if !parent.is_none() {
@ -36,15 +36,20 @@ fn check_process_hierarchy(parent: Option<pid_t>, processes: &HashMap<pid_t,Proc
} }
} }
fn collect_processes(tasks: &HashMap<pid_t,Process>, fn collect_processes(
mut processes: &mut HashMap<pid_t, ProcessItem>) -> f32 { tasks: &HashMap<pid_t, Process>,
mut processes: &mut HashMap<pid_t, ProcessItem>,
) -> f32 {
let mut cpusum = 0.0; let mut cpusum = 0.0;
for process in tasks.values() { for process in tasks.values() {
processes.insert(process.pid, ProcessItem { processes.insert(
row: 0, process.pid,
tasks: Vec::new(), ProcessItem {
process: process.clone() row: 0,
}); tasks: Vec::new(),
process: process.clone(),
},
);
let s = collect_processes(&process.tasks, &mut processes); let s = collect_processes(&process.tasks, &mut processes);
cpusum += process.cpu_usage + s; cpusum += process.cpu_usage + s;
} }
@ -118,8 +123,11 @@ impl Processes {
} }
} }
fn move_process(pid: pid_t, amap: &mut HashMap<pid_t, ProcessItem>, fn move_process(
bmap: &mut HashMap<pid_t, ProcessItem>) { pid: pid_t,
amap: &mut HashMap<pid_t, ProcessItem>,
bmap: &mut HashMap<pid_t, ProcessItem>,
) {
if let Some(e) = bmap.remove(&pid) { if let Some(e) = bmap.remove(&pid) {
amap.insert(pid, e); amap.insert(pid, e);
let ts = amap[&pid].tasks.clone(); let ts = amap[&pid].tasks.clone();
@ -129,11 +137,19 @@ fn move_process(pid: pid_t, amap: &mut HashMap<pid_t, ProcessItem>,
} }
} }
fn remove_row(model: &ProcessesUniformTree, parent: pid_t, row: usize, fn remove_row(
map: &mut HashMap<pid_t, ProcessItem>) { model: &ProcessesUniformTree,
parent: pid_t,
row: usize,
map: &mut HashMap<pid_t, ProcessItem>,
) {
let pid = map[&parent].tasks[row]; let pid = map[&parent].tasks[row];
println!("removing {} '{}' {}", pid, map[&pid].process.exe, println!(
map[&pid].process.cmd.join(" ")); "removing {} '{}' {}",
pid,
map[&pid].process.exe,
map[&pid].process.cmd.join(" ")
);
model.begin_remove_rows(Some(parent as usize), row, row); model.begin_remove_rows(Some(parent as usize), row, row);
map.remove(&pid); map.remove(&pid);
let len = { let len = {
@ -148,11 +164,20 @@ fn remove_row(model: &ProcessesUniformTree, parent: pid_t, row: usize,
model.end_remove_rows(); model.end_remove_rows();
} }
fn insert_row(model: &ProcessesUniformTree, parent: pid_t, row: usize, fn insert_row(
map: &mut HashMap<pid_t, ProcessItem>, pid: pid_t, model: &ProcessesUniformTree,
source: &mut HashMap<pid_t, ProcessItem>) { parent: pid_t,
println!("adding {} '{}' {}", pid, source[&pid].process.exe, row: usize,
source[&pid].process.cmd.join(" ")); map: &mut HashMap<pid_t, ProcessItem>,
pid: pid_t,
source: &mut HashMap<pid_t, ProcessItem>,
) {
println!(
"adding {} '{}' {}",
pid,
source[&pid].process.exe,
source[&pid].process.cmd.join(" ")
);
model.begin_insert_rows(Some(parent as usize), row, row); model.begin_insert_rows(Some(parent as usize), row, row);
move_process(pid, map, source); move_process(pid, map, source);
let len = { let len = {
@ -167,8 +192,7 @@ fn insert_row(model: &ProcessesUniformTree, parent: pid_t, row: usize,
model.end_insert_rows(); model.end_insert_rows();
} }
fn sync_row(model: &ProcessesUniformTree, pid: pid_t, fn sync_row(model: &ProcessesUniformTree, pid: pid_t, a: &mut Process, b: &Process) -> f32 {
a: &mut Process, b: &Process) -> f32 {
let mut changed = false; let mut changed = false;
if a.name != b.name { if a.name != b.name {
a.name.clone_from(&b.name); a.name.clone_from(&b.name);
@ -196,9 +220,12 @@ fn sync_row(model: &ProcessesUniformTree, pid: pid_t,
b.cpu_usage b.cpu_usage
} }
fn sync_tree(model: &ProcessesUniformTree, parent: pid_t, fn sync_tree(
amap: &mut HashMap<pid_t, ProcessItem>, model: &ProcessesUniformTree,
bmap: &mut HashMap<pid_t, ProcessItem>) -> f32 { parent: pid_t,
amap: &mut HashMap<pid_t, ProcessItem>,
bmap: &mut HashMap<pid_t, ProcessItem>,
) -> f32 {
let mut a = 0; let mut a = 0;
let mut b = 0; let mut b = 0;
let mut alen = amap[&parent].tasks.len(); let mut alen = amap[&parent].tasks.len();
@ -208,19 +235,24 @@ fn sync_tree(model: &ProcessesUniformTree, parent: pid_t,
while a < alen && b < blen { while a < alen && b < blen {
let apid = amap[&parent].tasks[a]; let apid = amap[&parent].tasks[a];
let bpid = bmap[&parent].tasks[b]; let bpid = bmap[&parent].tasks[b];
if apid < bpid { // a process has disappeared if apid < bpid {
// a process has disappeared
remove_row(model, parent, a, amap); remove_row(model, parent, a, amap);
alen -= 1; alen -= 1;
} else if apid > bpid { // a process has appeared } else if apid > bpid {
// a process has appeared
insert_row(model, parent, a, amap, bpid, bmap); insert_row(model, parent, a, amap, bpid, bmap);
cpu_total += amap[&bpid].process.cpu_usage; cpu_total += amap[&bpid].process.cpu_usage;
a += 1; a += 1;
alen += 1; alen += 1;
b += 1; b += 1;
} else { } else {
cpu_total += sync_row(model, apid, cpu_total += sync_row(
&mut amap.get_mut(&apid).unwrap().process, model,
&bmap[&apid].process); apid,
&mut amap.get_mut(&apid).unwrap().process,
&bmap[&apid].process,
);
cpu_total += sync_tree(model, apid, amap, bmap); cpu_total += sync_tree(model, apid, amap, bmap);
a += 1; a += 1;
b += 1; b += 1;
@ -237,7 +269,7 @@ fn sync_tree(model: &ProcessesUniformTree, parent: pid_t,
remove_row(model, parent, a, amap); remove_row(model, parent, a, amap);
alen -= 1; alen -= 1;
} }
if cpu_total != bmap[&parent].process.cpu_usage { if cpu_total != bmap[&parent].process.cpu_usage {
amap.get_mut(&parent).unwrap().process.cpu_usage = cpu_total; amap.get_mut(&parent).unwrap().process.cpu_usage = cpu_total;
model.data_changed(parent as usize, parent as usize); model.data_changed(parent as usize, parent as usize);
} }
@ -252,7 +284,7 @@ impl ProcessesTrait for Processes {
model: model, model: model,
p: ProcessTree::default(), p: ProcessTree::default(),
incoming: Arc::new(Mutex::new(None)), incoming: Arc::new(Mutex::new(None)),
active: true active: true,
}; };
update_thread(emit, p.incoming.clone()); update_thread(emit, p.incoming.clone());
p p
@ -305,8 +337,7 @@ impl ProcessesTrait for Processes {
} else { } else {
let top = self.p.top.clone(); let top = self.p.top.clone();
for pid in top { for pid in top {
sync_tree(&self.model, pid, &mut self.p.processes, sync_tree(&self.model, pid, &mut self.p.processes, &mut new.processes);
&mut new.processes);
} }
} }
} }

99
demo/rust/src/processes_interface.rs
View File

@ -16,17 +16,20 @@ pub struct COption<T> {
some: bool, some: bool,
} }
impl<T> From<Option<T>> for COption<T> where T: Default { impl<T> From<Option<T>> for COption<T>
fn from(t: Option<T>) -> COption <T> { where
T: Default,
{
fn from(t: Option<T>) -> COption<T> {
if let Some(v) = t { if let Some(v) = t {
COption { COption {
data: v, data: v,
some: true some: true,
} }
} else { } else {
COption { COption {
data: T::default(), data: T::default(),
some: false some: false,
} }
} }
} }
@ -65,7 +68,7 @@ impl<'a> From<&'a String> for QString {
#[repr(C)] #[repr(C)]
pub enum SortOrder { pub enum SortOrder {
Ascending = 0, Ascending = 0,
Descending = 1 Descending = 1,
} }
#[repr(C)] #[repr(C)]
@ -76,7 +79,7 @@ pub struct QModelIndex {
pub struct ProcessesQObject {} pub struct ProcessesQObject {}
#[derive (Clone)] #[derive(Clone)]
pub struct ProcessesEmitter { pub struct ProcessesEmitter {
qobject: Arc<Mutex<*const ProcessesQObject>>, qobject: Arc<Mutex<*const ProcessesQObject>>,
active_changed: fn(*const ProcessesQObject), active_changed: fn(*const ProcessesQObject),
@ -98,7 +101,7 @@ impl ProcessesEmitter {
pub fn new_data_ready(&self, item: Option<usize>) { pub fn new_data_ready(&self, item: Option<usize>) {
let ptr = *self.qobject.lock().unwrap(); let ptr = *self.qobject.lock().unwrap();
if !ptr.is_null() { if !ptr.is_null() {
(self.new_data_ready)(ptr, item.unwrap_or(13), item.is_some()); (self.new_data_ready)(ptr, item.unwrap_or(13), item.is_some());
} }
} }
} }
@ -144,7 +147,9 @@ pub trait ProcessesTrait {
fn get_active(&self) -> bool; fn get_active(&self) -> bool;
fn set_active(&mut self, value: bool); fn set_active(&mut self, value: bool);
fn row_count(&self, Option<usize>) -> usize; fn row_count(&self, Option<usize>) -> usize;
fn can_fetch_more(&self, Option<usize>) -> bool { false } fn can_fetch_more(&self, Option<usize>) -> bool {
false
}
fn fetch_more(&mut self, Option<usize>) {} fn fetch_more(&mut self, Option<usize>) {}
fn sort(&mut self, u8, SortOrder) {} fn sort(&mut self, u8, SortOrder) {}
fn index(&self, item: Option<usize>, row: usize) -> usize; fn index(&self, item: Option<usize>, row: usize) -> usize;
@ -160,21 +165,18 @@ pub trait ProcessesTrait {
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn processes_new(processes: *mut ProcessesQObject, pub extern "C" fn processes_new(
active_changed: fn(*const ProcessesQObject), processes: *mut ProcessesQObject,
new_data_ready: fn(*const ProcessesQObject, item: usize, valid: bool), active_changed: fn(*const ProcessesQObject),
data_changed: fn(*const ProcessesQObject, usize, usize), new_data_ready: fn(*const ProcessesQObject, item: usize, valid: bool),
begin_reset_model: fn(*const ProcessesQObject), data_changed: fn(*const ProcessesQObject, usize, usize),
end_reset_model: fn(*const ProcessesQObject), begin_reset_model: fn(*const ProcessesQObject),
begin_insert_rows: fn(*const ProcessesQObject, item: usize, valid: bool, end_reset_model: fn(*const ProcessesQObject),
usize, begin_insert_rows: fn(*const ProcessesQObject, item: usize, valid: bool, usize, usize),
usize), end_insert_rows: fn(*const ProcessesQObject),
end_insert_rows: fn(*const ProcessesQObject), begin_remove_rows: fn(*const ProcessesQObject, item: usize, valid: bool, usize, usize),
begin_remove_rows: fn(*const ProcessesQObject, item: usize, valid: bool, end_remove_rows: fn(*const ProcessesQObject),
usize, ) -> *mut Processes {
usize),
end_remove_rows: fn(*const ProcessesQObject))
-> *mut Processes {
let processes_emit = ProcessesEmitter { let processes_emit = ProcessesEmitter {
qobject: Arc::new(Mutex::new(processes)), qobject: Arc::new(Mutex::new(processes)),
active_changed: active_changed, active_changed: active_changed,
@ -210,7 +212,11 @@ pub unsafe extern "C" fn processes_active_set(ptr: *mut Processes, v: bool) {
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn processes_row_count(ptr: *const Processes, item: usize, valid: bool) -> c_int { pub unsafe extern "C" fn processes_row_count(
ptr: *const Processes,
item: usize,
valid: bool,
) -> c_int {
if valid { if valid {
(&*ptr).row_count(Some(item)) as c_int (&*ptr).row_count(Some(item)) as c_int
} else { } else {
@ -218,7 +224,11 @@ pub unsafe extern "C" fn processes_row_count(ptr: *const Processes, item: usize,
} }
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn processes_can_fetch_more(ptr: *const Processes, item: usize, valid: bool) -> bool { pub unsafe extern "C" fn processes_can_fetch_more(
ptr: *const Processes,
item: usize,
valid: bool,
) -> bool {
if valid { if valid {
(&*ptr).can_fetch_more(Some(item)) (&*ptr).can_fetch_more(Some(item))
} else { } else {
@ -234,11 +244,20 @@ pub unsafe extern "C" fn processes_fetch_more(ptr: *mut Processes, item: usize,
} }
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn processes_sort(ptr: *mut Processes, column: u8, order: SortOrder) { pub unsafe extern "C" fn processes_sort(
ptr: *mut Processes,
column: u8,
order: SortOrder
) {
(&mut *ptr).sort(column, order) (&mut *ptr).sort(column, order)
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn processes_index(ptr: *const Processes, item: usize, valid: bool, row: c_int) -> usize { pub unsafe extern "C" fn processes_index(
ptr: *const Processes,
item: usize,
valid: bool,
row: c_int,
) -> usize {
if !valid { if !valid {
(&*ptr).index(None, row as usize) (&*ptr).index(None, row as usize)
} else { } else {
@ -248,9 +267,15 @@ pub unsafe extern "C" fn processes_index(ptr: *const Processes, item: usize, val
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn processes_parent(ptr: *const Processes, index: usize) -> QModelIndex { pub unsafe extern "C" fn processes_parent(ptr: *const Processes, index: usize) -> QModelIndex {
if let Some(parent) = (&*ptr).parent(index) { if let Some(parent) = (&*ptr).parent(index) {
QModelIndex{row: (&*ptr).row(parent) as c_int, internal_id: parent} QModelIndex {
row: (&*ptr).row(parent) as c_int,
internal_id: parent,
}
} else { } else {
QModelIndex{row: -1, internal_id: 0} QModelIndex {
row: -1,
internal_id: 0,
}
} }
} }
#[no_mangle] #[no_mangle]
@ -259,9 +284,11 @@ pub unsafe extern "C" fn processes_row(ptr: *const Processes, item: usize) -> c_
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn processes_data_cmd(ptr: *const Processes, item: usize, pub unsafe extern "C" fn processes_data_cmd(
d: *mut c_void, ptr: *const Processes, item: usize,
set: fn(*mut c_void, QString)) { d: *mut c_void,
set: fn(*mut c_void, QString),
) {
let data = (&*ptr).cmd(item); let data = (&*ptr).cmd(item);
set(d, QString::from(&data)); set(d, QString::from(&data));
} }
@ -282,9 +309,11 @@ pub unsafe extern "C" fn processes_data_memory(ptr: *const Processes, item: usiz
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn processes_data_name(ptr: *const Processes, item: usize, pub unsafe extern "C" fn processes_data_name(
d: *mut c_void, ptr: *const Processes, item: usize,
set: fn(*mut c_void, QString)) { d: *mut c_void,
set: fn(*mut c_void, QString),
) {
let data = (&*ptr).name(item); let data = (&*ptr).name(item);
set(d, QString::from(&data)); set(d, QString::from(&data));
} }

6
demo/rust/src/time_series_implementation.rs
View File

@ -1,6 +1,6 @@
use time_series_interface::*; use time_series_interface::*;
#[derive (Default, Clone)] #[derive(Default, Clone)]
struct TimeSeriesItem { struct TimeSeriesItem {
input: u32, input: u32,
result: u32, result: u32,
@ -17,12 +17,12 @@ impl TimeSeriesTrait for TimeSeries {
let mut series = TimeSeries { let mut series = TimeSeries {
emit: emit, emit: emit,
model: model, model: model,
list: Vec::new() list: Vec::new(),
}; };
for i in 0..100 { for i in 0..100 {
series.list.push(TimeSeriesItem { series.list.push(TimeSeriesItem {
input: i, input: i,
result: 2 * i result: 2 * i,
}); });
} }
series series

60
demo/rust/src/time_series_interface.rs
View File

@ -16,17 +16,20 @@ pub struct COption<T> {
some: bool, some: bool,
} }
impl<T> From<Option<T>> for COption<T> where T: Default { impl<T> From<Option<T>> for COption<T>
fn from(t: Option<T>) -> COption <T> { where
T: Default,
{
fn from(t: Option<T>) -> COption<T> {
if let Some(v) = t { if let Some(v) = t {
COption { COption {
data: v, data: v,
some: true some: true,
} }
} else { } else {
COption { COption {
data: T::default(), data: T::default(),
some: false some: false,
} }
} }
} }
@ -36,7 +39,7 @@ impl<T> From<Option<T>> for COption<T> where T: Default {
#[repr(C)] #[repr(C)]
pub enum SortOrder { pub enum SortOrder {
Ascending = 0, Ascending = 0,
Descending = 1 Descending = 1,
} }
#[repr(C)] #[repr(C)]
@ -47,7 +50,7 @@ pub struct QModelIndex {
pub struct TimeSeriesQObject {} pub struct TimeSeriesQObject {}
#[derive (Clone)] #[derive(Clone)]
pub struct TimeSeriesEmitter { pub struct TimeSeriesEmitter {
qobject: Arc<Mutex<*const TimeSeriesQObject>>, qobject: Arc<Mutex<*const TimeSeriesQObject>>,
new_data_ready: fn(*const TimeSeriesQObject), new_data_ready: fn(*const TimeSeriesQObject),
@ -106,7 +109,9 @@ pub trait TimeSeriesTrait {
fn create(emit: TimeSeriesEmitter, model: TimeSeriesList) -> Self; fn create(emit: TimeSeriesEmitter, model: TimeSeriesList) -> Self;
fn emit(&self) -> &TimeSeriesEmitter; fn emit(&self) -> &TimeSeriesEmitter;
fn row_count(&self) -> usize; fn row_count(&self) -> usize;
fn can_fetch_more(&self) -> bool { false } fn can_fetch_more(&self) -> bool {
false
}
fn fetch_more(&mut self) {} fn fetch_more(&mut self) {}
fn sort(&mut self, u8, SortOrder) {} fn sort(&mut self, u8, SortOrder) {}
fn input(&self, item: usize) -> u32; fn input(&self, item: usize) -> u32;
@ -116,20 +121,17 @@ pub trait TimeSeriesTrait {
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn time_series_new(time_series: *mut TimeSeriesQObject, pub extern "C" fn time_series_new(
new_data_ready: fn(*const TimeSeriesQObject), time_series: *mut TimeSeriesQObject,
data_changed: fn(*const TimeSeriesQObject, usize, usize), new_data_ready: fn(*const TimeSeriesQObject),
begin_reset_model: fn(*const TimeSeriesQObject), data_changed: fn(*const TimeSeriesQObject, usize, usize),
end_reset_model: fn(*const TimeSeriesQObject), begin_reset_model: fn(*const TimeSeriesQObject),
begin_insert_rows: fn(*const TimeSeriesQObject, end_reset_model: fn(*const TimeSeriesQObject),
usize, begin_insert_rows: fn(*const TimeSeriesQObject, usize, usize),
usize), end_insert_rows: fn(*const TimeSeriesQObject),
end_insert_rows: fn(*const TimeSeriesQObject), begin_remove_rows: fn(*const TimeSeriesQObject, usize, usize),
begin_remove_rows: fn(*const TimeSeriesQObject, end_remove_rows: fn(*const TimeSeriesQObject),
usize, ) -> *mut TimeSeries {
usize),
end_remove_rows: fn(*const TimeSeriesQObject))
-> *mut TimeSeries {
let time_series_emit = TimeSeriesEmitter { let time_series_emit = TimeSeriesEmitter {
qobject: Arc::new(Mutex::new(time_series)), qobject: Arc::new(Mutex::new(time_series)),
new_data_ready: new_data_ready, new_data_ready: new_data_ready,
@ -166,7 +168,11 @@ pub unsafe extern "C" fn time_series_fetch_more(ptr: *mut TimeSeries) {
(&mut *ptr).fetch_more() (&mut *ptr).fetch_more()
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn time_series_sort(ptr: *mut TimeSeries, column: u8, order: SortOrder) { pub unsafe extern "C" fn time_series_sort(
ptr: *mut TimeSeries,
column: u8,
order: SortOrder,
) {
(&mut *ptr).sort(column, order) (&mut *ptr).sort(column, order)
} }
@ -176,7 +182,10 @@ pub unsafe extern "C" fn time_series_data_input(ptr: *const TimeSeries, row: c_i
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn time_series_set_data_input(ptr: *mut TimeSeries, row: c_int, v: u32) -> bool { pub unsafe extern "C" fn time_series_set_data_input(
ptr: *mut TimeSeries, row: c_int,
v: u32,
) -> bool {
(&mut *ptr).set_input(row as usize, v) (&mut *ptr).set_input(row as usize, v)
} }
@ -186,6 +195,9 @@ pub unsafe extern "C" fn time_series_data_result(ptr: *const TimeSeries, row: c_
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn time_series_set_data_result(ptr: *mut TimeSeries, row: c_int, v: u32) -> bool { pub unsafe extern "C" fn time_series_set_data_result(
ptr: *mut TimeSeries, row: c_int,
v: u32,
) -> bool {
(&mut *ptr).set_result(row as usize, v) (&mut *ptr).set_result(row as usize, v)
} }

140
src/rust.cpp
View File

@ -29,21 +29,21 @@ QString rustTypeInit(const T& p)
} }
void rConstructorArgsDecl(QTextStream& r, const QString& name, const Object& o, const Configuration& conf) { void rConstructorArgsDecl(QTextStream& r, const QString& name, const Object& o, const Configuration& conf) {
r << QString("%2: *mut %1QObject").arg(o.name, name); r << QString(" %2: *mut %1QObject").arg(o.name, name);
for (const Property& p: o.properties) { for (const Property& p: o.properties) {
if (p.type.type == BindingType::Object) { if (p.type.type == BindingType::Object) {
r << QString(", "); r << QString(",\n");
rConstructorArgsDecl(r, p.name, conf.findObject(p.type.name), conf); rConstructorArgsDecl(r, p.name, conf.findObject(p.type.name), conf);
} else { } else {
r << QString(",\n %2_changed: fn(*const %1QObject)") r << QString(",\n %2_changed: fn(*const %1QObject)")
.arg(o.name, snakeCase(p.name)); .arg(o.name, snakeCase(p.name));
} }
} }
if (o.type == ObjectType::List) { if (o.type == ObjectType::List) {
r << QString(",\n new_data_ready: fn(*const %1QObject)") r << QString(",\n new_data_ready: fn(*const %1QObject)")
.arg(o.name); .arg(o.name);
} else if (o.type == ObjectType::UniformTree) { } else if (o.type == ObjectType::UniformTree) {
r << QString(",\n new_data_ready: fn(*const %1QObject, item: usize, valid: bool)") r << QString(",\n new_data_ready: fn(*const %1QObject, item: usize, valid: bool)")
.arg(o.name); .arg(o.name);
} }
if (o.type != ObjectType::Object) { if (o.type != ObjectType::Object) {
@ -52,17 +52,13 @@ void rConstructorArgsDecl(QTextStream& r, const QString& name, const Object& o,
indexDecl = " item: usize, valid: bool,"; indexDecl = " item: usize, valid: bool,";
} }
r << QString(R"(, r << QString(R"(,
data_changed: fn(*const %1QObject, usize, usize), data_changed: fn(*const %1QObject, usize, usize),
begin_reset_model: fn(*const %1QObject), begin_reset_model: fn(*const %1QObject),
end_reset_model: fn(*const %1QObject), end_reset_model: fn(*const %1QObject),
begin_insert_rows: fn(*const %1QObject,%2 begin_insert_rows: fn(*const %1QObject,%2 usize, usize),
usize, end_insert_rows: fn(*const %1QObject),
usize), begin_remove_rows: fn(*const %1QObject,%2 usize, usize),
end_insert_rows: fn(*const %1QObject), end_remove_rows: fn(*const %1QObject))").arg(o.name, indexDecl);
begin_remove_rows: fn(*const %1QObject,%2
usize,
usize),
end_remove_rows: fn(*const %1QObject))").arg(o.name, indexDecl);
} }
} }
@ -114,7 +110,7 @@ void writeRustInterfaceObject(QTextStream& r, const Object& o, const Configurati
r << QString(R"( r << QString(R"(
pub struct %1QObject {} pub struct %1QObject {}
#[derive (Clone)] #[derive(Clone)]
pub struct %1Emitter { pub struct %1Emitter {
qobject: Arc<Mutex<*const %1QObject>>, qobject: Arc<Mutex<*const %1QObject>>,
)").arg(o.name); )").arg(o.name);
@ -165,7 +161,7 @@ impl %1Emitter {
r << R"( pub fn new_data_ready(&self, item: Option<usize>) { r << R"( pub fn new_data_ready(&self, item: Option<usize>) {
let ptr = *self.qobject.lock().unwrap(); let ptr = *self.qobject.lock().unwrap();
if !ptr.is_null() { if !ptr.is_null() {
(self.new_data_ready)(ptr, item.unwrap_or(13), item.is_some()); (self.new_data_ready)(ptr, item.unwrap_or(13), item.is_some());
} }
} }
)"; )";
@ -247,13 +243,17 @@ pub trait %1Trait {
} }
if (o.type == ObjectType::List) { if (o.type == ObjectType::List) {
r << R"( fn row_count(&self) -> usize; r << R"( fn row_count(&self) -> usize;
fn can_fetch_more(&self) -> bool { false } fn can_fetch_more(&self) -> bool {
false
}
fn fetch_more(&mut self) {} fn fetch_more(&mut self) {}
fn sort(&mut self, u8, SortOrder) {} fn sort(&mut self, u8, SortOrder) {}
)"; )";
} else if (o.type == ObjectType::UniformTree) { } else if (o.type == ObjectType::UniformTree) {
r << R"( fn row_count(&self, Option<usize>) -> usize; r << R"( fn row_count(&self, Option<usize>) -> usize;
fn can_fetch_more(&self, Option<usize>) -> bool { false } fn can_fetch_more(&self, Option<usize>) -> bool {
false
}
fn fetch_more(&mut self, Option<usize>) {} fn fetch_more(&mut self, Option<usize>) {}
fn sort(&mut self, u8, SortOrder) {} fn sort(&mut self, u8, SortOrder) {}
fn index(&self, item: Option<usize>, row: usize) -> usize; fn index(&self, item: Option<usize>, row: usize) -> usize;
@ -275,9 +275,10 @@ pub trait %1Trait {
r << QString(R"(} r << QString(R"(}
#[no_mangle] #[no_mangle]
pub extern "C" fn %1_new()").arg(lcname); pub extern "C" fn %1_new(
)").arg(lcname);
rConstructorArgsDecl(r, lcname, o, conf); rConstructorArgsDecl(r, lcname, o, conf);
r << QString(")\n -> *mut %1 {\n").arg(o.name); r << QString(",\n) -> *mut %1 {\n").arg(o.name);
rConstructorArgs(r, lcname, o, conf); rConstructorArgs(r, lcname, o, conf);
r << QString(R"( Box::into_raw(Box::new(d_%2)) r << QString(R"( Box::into_raw(Box::new(d_%2))
} }
@ -301,9 +302,11 @@ pub unsafe extern "C" fn %2_get(ptr: *mut %1) -> *mut %4 {
} else if (p.type.isComplex() && !p.optional) { } else if (p.type.isComplex() && !p.optional) {
r << QString(R"( r << QString(R"(
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn %2_get(ptr: *const %1, pub unsafe extern "C" fn %2_get(
p: *mut c_void, ptr: *const %1,
set: fn(*mut c_void, %4)) { p: *mut c_void,
set: fn(*mut c_void, %4),
) {
let data = (&*ptr).get_%3(); let data = (&*ptr).get_%3();
set(p, %4::from(&data)); set(p, %4::from(&data));
} }
@ -320,9 +323,11 @@ pub unsafe extern "C" fn %2_set(ptr: *mut %1, v: %4) {
} else if (p.type.isComplex()) { } else if (p.type.isComplex()) {
r << QString(R"( r << QString(R"(
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn %2_get(ptr: *const %1, pub unsafe extern "C" fn %2_get(
p: *mut c_void, ptr: *const %1,
set: fn(*mut c_void, %4)) { p: *mut c_void,
set: fn(*mut c_void, %4),
) {
let data = (&*ptr).get_%3(); let data = (&*ptr).get_%3();
if let Some(data) = data { if let Some(data) = data {
set(p, %4::from(&data)); set(p, %4::from(&data));
@ -374,14 +379,22 @@ pub unsafe extern "C" fn %2_fetch_more(ptr: *mut %1) {
(&mut *ptr).fetch_more() (&mut *ptr).fetch_more()
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn %2_sort(ptr: *mut %1, column: u8, order: SortOrder) { pub unsafe extern "C" fn %2_sort(
ptr: *mut %1,
column: u8,
order: SortOrder,
) {
(&mut *ptr).sort(column, order) (&mut *ptr).sort(column, order)
} }
)").arg(o.name, lcname); )").arg(o.name, lcname);
} else if (o.type == ObjectType::UniformTree) { } else if (o.type == ObjectType::UniformTree) {
r << QString(R"( r << QString(R"(
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn %2_row_count(ptr: *const %1, item: usize, valid: bool) -> c_int { pub unsafe extern "C" fn %2_row_count(
ptr: *const %1,
item: usize,
valid: bool,
) -> c_int {
if valid { if valid {
(&*ptr).row_count(Some(item)) as c_int (&*ptr).row_count(Some(item)) as c_int
} else { } else {
@ -389,7 +402,11 @@ pub unsafe extern "C" fn %2_row_count(ptr: *const %1, item: usize, valid: bool)
} }
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn %2_can_fetch_more(ptr: *const %1, item: usize, valid: bool) -> bool { pub unsafe extern "C" fn %2_can_fetch_more(
ptr: *const %1,
item: usize,
valid: bool,
) -> bool {
if valid { if valid {
(&*ptr).can_fetch_more(Some(item)) (&*ptr).can_fetch_more(Some(item))
} else { } else {
@ -405,11 +422,20 @@ pub unsafe extern "C" fn %2_fetch_more(ptr: *mut %1, item: usize, valid: bool) {
} }
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn %2_sort(ptr: *mut %1, column: u8, order: SortOrder) { pub unsafe extern "C" fn %2_sort(
ptr: *mut %1,
column: u8,
order: SortOrder
) {
(&mut *ptr).sort(column, order) (&mut *ptr).sort(column, order)
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn %2_index(ptr: *const %1, item: usize, valid: bool, row: c_int) -> usize { pub unsafe extern "C" fn %2_index(
ptr: *const %1,
item: usize,
valid: bool,
row: c_int,
) -> usize {
if !valid { if !valid {
(&*ptr).index(None, row as usize) (&*ptr).index(None, row as usize)
} else { } else {
@ -419,9 +445,15 @@ pub unsafe extern "C" fn %2_index(ptr: *const %1, item: usize, valid: bool, row:
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn %2_parent(ptr: *const %1, index: usize) -> QModelIndex { pub unsafe extern "C" fn %2_parent(ptr: *const %1, index: usize) -> QModelIndex {
if let Some(parent) = (&*ptr).parent(index) { if let Some(parent) = (&*ptr).parent(index) {
QModelIndex{row: (&*ptr).row(parent) as c_int, internal_id: parent} QModelIndex {
row: (&*ptr).row(parent) as c_int,
internal_id: parent,
}
} else { } else {
QModelIndex{row: -1, internal_id: 0} QModelIndex {
row: -1,
internal_id: 0,
}
} }
} }
#[no_mangle] #[no_mangle]
@ -441,9 +473,11 @@ pub unsafe extern "C" fn %2_row(ptr: *const %1, item: usize) -> c_int {
if (ip.type.isComplex() && !ip.optional) { if (ip.type.isComplex() && !ip.optional) {
r << QString(R"( r << QString(R"(
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn %2_data_%3(ptr: *const %1%5, pub unsafe extern "C" fn %2_data_%3(
d: *mut c_void, ptr: *const %1%5,
set: fn(*mut c_void, %4)) { d: *mut c_void,
set: fn(*mut c_void, %4),
) {
let data = (&*ptr).%3(%6); let data = (&*ptr).%3(%6);
set(d, %4::from(&data)); set(d, %4::from(&data));
} }
@ -451,9 +485,11 @@ pub unsafe extern "C" fn %2_data_%3(ptr: *const %1%5,
} else if (ip.type.isComplex()) { } else if (ip.type.isComplex()) {
r << QString(R"( r << QString(R"(
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn %2_data_%3(ptr: *const %1%5, pub unsafe extern "C" fn %2_data_%3(
d: *mut c_void, ptr: *const %1%5,
set: fn(*mut c_void, %4)) { d: *mut c_void,
set: fn(*mut c_void, %4),
) {
let data = (&*ptr).%3(%6); let data = (&*ptr).%3(%6);
if let Some(data) = data { if let Some(data) = data {
set(d, %4::from(&data)); set(d, %4::from(&data));
@ -480,7 +516,10 @@ pub unsafe extern "C" fn %2_data_%3(ptr: *const %1%5) -> %4 {
} }
r << QString(R"( r << QString(R"(
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn %2_set_data_%3(ptr: *mut %1%4, v: %6) -> bool { pub unsafe extern "C" fn %2_set_data_%3(
ptr: *mut %1%4,
v: %6,
) -> bool {
(&mut *ptr).set_%3(%5, %7) (&mut *ptr).set_%3(%5, %7)
} }
)").arg(o.name, lcname, snakeCase(ip.name), indexDecl, index, type, val); )").arg(o.name, lcname, snakeCase(ip.name), indexDecl, index, type, val);
@ -535,17 +574,20 @@ pub struct COption<T> {
some: bool, some: bool,
} }
impl<T> From<Option<T>> for COption<T> where T: Default { impl<T> From<Option<T>> for COption<T>
fn from(t: Option<T>) -> COption <T> { where
T: Default,
{
fn from(t: Option<T>) -> COption<T> {
if let Some(v) = t { if let Some(v) = t {
COption { COption {
data: v, data: v,
some: true some: true,
} }
} else { } else {
COption { COption {
data: T::default(), data: T::default(),
some: false some: false,
} }
} }
} }
@ -616,7 +658,7 @@ impl<'a> From<&'a Vec<u8>> for QByteArray {
#[repr(C)] #[repr(C)]
pub enum SortOrder { pub enum SortOrder {
Ascending = 0, Ascending = 0,
Descending = 1 Descending = 1,
} }
#[repr(C)] #[repr(C)]
@ -653,7 +695,7 @@ use %1::*;
void writeRustImplementationObject(QTextStream& r, const Object& o) { void writeRustImplementationObject(QTextStream& r, const Object& o) {
const QString lcname(snakeCase(o.name)); const QString lcname(snakeCase(o.name));
if (o.type != ObjectType::Object) { if (o.type != ObjectType::Object) {
r << "#[derive (Default, Clone)]\n"; r << "#[derive(Default, Clone)]\n";
r << QString("struct %1Item {\n").arg(o.name); r << QString("struct %1Item {\n").arg(o.name);
for (auto ip: o.itemProperties) { for (auto ip: o.itemProperties) {
const QString lc(snakeCase(ip.name)); const QString lc(snakeCase(ip.name));
@ -732,7 +774,7 @@ void writeRustImplementationObject(QTextStream& r, const Object& o) {
self.%1 = value; self.%1 = value;
self.emit.%1_changed(); self.emit.%1_changed();
} }
)").arg(lc, rustType(p)); )").arg(lc, rustType(p));
} }
} }
} }

2
tests/rust_list/src/implementation.rs
View File

@ -3,7 +3,7 @@
#![allow(dead_code)] #![allow(dead_code)]
use interface::*; use interface::*;
#[derive (Default, Clone)] #[derive(Default, Clone)]
struct PersonsItem { struct PersonsItem {
user_name: String, user_name: String,
} }

63
tests/rust_list/src/interface.rs
View File

@ -16,17 +16,20 @@ pub struct COption<T> {
some: bool, some: bool,
} }
impl<T> From<Option<T>> for COption<T> where T: Default { impl<T> From<Option<T>> for COption<T>
fn from(t: Option<T>) -> COption <T> { where
T: Default,
{
fn from(t: Option<T>) -> COption<T> {
if let Some(v) = t { if let Some(v) = t {
COption { COption {
data: v, data: v,
some: true some: true,
} }
} else { } else {
COption { COption {
data: T::default(), data: T::default(),
some: false some: false,
} }
} }
} }
@ -65,7 +68,7 @@ impl<'a> From<&'a String> for QString {
#[repr(C)] #[repr(C)]
pub enum SortOrder { pub enum SortOrder {
Ascending = 0, Ascending = 0,
Descending = 1 Descending = 1,
} }
#[repr(C)] #[repr(C)]
@ -76,7 +79,7 @@ pub struct QModelIndex {
pub struct PersonsQObject {} pub struct PersonsQObject {}
#[derive (Clone)] #[derive(Clone)]
pub struct PersonsEmitter { pub struct PersonsEmitter {
qobject: Arc<Mutex<*const PersonsQObject>>, qobject: Arc<Mutex<*const PersonsQObject>>,
new_data_ready: fn(*const PersonsQObject), new_data_ready: fn(*const PersonsQObject),
@ -135,7 +138,9 @@ pub trait PersonsTrait {
fn create(emit: PersonsEmitter, model: PersonsList) -> Self; fn create(emit: PersonsEmitter, model: PersonsList) -> Self;
fn emit(&self) -> &PersonsEmitter; fn emit(&self) -> &PersonsEmitter;
fn row_count(&self) -> usize; fn row_count(&self) -> usize;
fn can_fetch_more(&self) -> bool { false } fn can_fetch_more(&self) -> bool {
false
}
fn fetch_more(&mut self) {} fn fetch_more(&mut self) {}
fn sort(&mut self, u8, SortOrder) {} fn sort(&mut self, u8, SortOrder) {}
fn user_name(&self, item: usize) -> String; fn user_name(&self, item: usize) -> String;
@ -143,20 +148,17 @@ pub trait PersonsTrait {
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn persons_new(persons: *mut PersonsQObject, pub extern "C" fn persons_new(
new_data_ready: fn(*const PersonsQObject), persons: *mut PersonsQObject,
data_changed: fn(*const PersonsQObject, usize, usize), new_data_ready: fn(*const PersonsQObject),
begin_reset_model: fn(*const PersonsQObject), data_changed: fn(*const PersonsQObject, usize, usize),
end_reset_model: fn(*const PersonsQObject), begin_reset_model: fn(*const PersonsQObject),
begin_insert_rows: fn(*const PersonsQObject, end_reset_model: fn(*const PersonsQObject),
usize, begin_insert_rows: fn(*const PersonsQObject, usize, usize),
usize), end_insert_rows: fn(*const PersonsQObject),
end_insert_rows: fn(*const PersonsQObject), begin_remove_rows: fn(*const PersonsQObject, usize, usize),
begin_remove_rows: fn(*const PersonsQObject, end_remove_rows: fn(*const PersonsQObject),
usize, ) -> *mut Persons {
usize),
end_remove_rows: fn(*const PersonsQObject))
-> *mut Persons {
let persons_emit = PersonsEmitter { let persons_emit = PersonsEmitter {
qobject: Arc::new(Mutex::new(persons)), qobject: Arc::new(Mutex::new(persons)),
new_data_ready: new_data_ready, new_data_ready: new_data_ready,
@ -193,19 +195,28 @@ pub unsafe extern "C" fn persons_fetch_more(ptr: *mut Persons) {
(&mut *ptr).fetch_more() (&mut *ptr).fetch_more()
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn persons_sort(ptr: *mut Persons, column: u8, order: SortOrder) { pub unsafe extern "C" fn persons_sort(
ptr: *mut Persons,
column: u8,
order: SortOrder,
) {
(&mut *ptr).sort(column, order) (&mut *ptr).sort(column, order)
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn persons_data_user_name(ptr: *const Persons, row: c_int, pub unsafe extern "C" fn persons_data_user_name(
d: *mut c_void, ptr: *const Persons, row: c_int,
set: fn(*mut c_void, QString)) { d: *mut c_void,
set: fn(*mut c_void, QString),
) {
let data = (&*ptr).user_name(row as usize); let data = (&*ptr).user_name(row as usize);
set(d, QString::from(&data)); set(d, QString::from(&data));
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn persons_set_data_user_name(ptr: *mut Persons, row: c_int, v: QStringIn) -> bool { pub unsafe extern "C" fn persons_set_data_user_name(
ptr: *mut Persons, row: c_int,
v: QStringIn,
) -> bool {
(&mut *ptr).set_user_name(row as usize, v.convert()) (&mut *ptr).set_user_name(row as usize, v.convert())
} }

2
tests/rust_object/src/implementation.rs
View File

@ -25,5 +25,5 @@ impl PersonTrait for Person {
self.user_name = value; self.user_name = value;
self.emit.user_name_changed(); self.emit.user_name_changed();
} }
} }

17
tests/rust_object/src/interface.rs
View File

@ -40,7 +40,7 @@ impl<'a> From<&'a String> for QString {
pub struct PersonQObject {} pub struct PersonQObject {}
#[derive (Clone)] #[derive(Clone)]
pub struct PersonEmitter { pub struct PersonEmitter {
qobject: Arc<Mutex<*const PersonQObject>>, qobject: Arc<Mutex<*const PersonQObject>>,
user_name_changed: fn(*const PersonQObject), user_name_changed: fn(*const PersonQObject),
@ -68,9 +68,10 @@ pub trait PersonTrait {
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn person_new(person: *mut PersonQObject, pub extern "C" fn person_new(
user_name_changed: fn(*const PersonQObject)) person: *mut PersonQObject,
-> *mut Person { user_name_changed: fn(*const PersonQObject),
) -> *mut Person {
let person_emit = PersonEmitter { let person_emit = PersonEmitter {
qobject: Arc::new(Mutex::new(person)), qobject: Arc::new(Mutex::new(person)),
user_name_changed: user_name_changed, user_name_changed: user_name_changed,
@ -85,9 +86,11 @@ pub unsafe extern "C" fn person_free(ptr: *mut Person) {
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn person_user_name_get(ptr: *const Person, pub unsafe extern "C" fn person_user_name_get(
p: *mut c_void, ptr: *const Person,
set: fn(*mut c_void, QString)) { p: *mut c_void,
set: fn(*mut c_void, QString),
) {
let data = (&*ptr).get_user_name(); let data = (&*ptr).get_user_name();
set(p, QString::from(&data)); set(p, QString::from(&data));
} }

16
tests/rust_object_types/src/implementation.rs
View File

@ -39,54 +39,54 @@ impl ObjectTrait for Object {
self.boolean = value; self.boolean = value;
self.emit.boolean_changed(); self.emit.boolean_changed();
} }
fn get_bytearray(&self) -> Vec<u8> { fn get_bytearray(&self) -> Vec<u8> {
self.bytearray.clone() self.bytearray.clone()
} }
fn set_bytearray(&mut self, value: Vec<u8>) { fn set_bytearray(&mut self, value: Vec<u8>) {
self.bytearray = value; self.bytearray = value;
self.emit.bytearray_changed(); self.emit.bytearray_changed();
} }
fn get_integer(&self) -> i32 { fn get_integer(&self) -> i32 {
self.integer self.integer
} }
fn set_integer(&mut self, value: i32) { fn set_integer(&mut self, value: i32) {
self.integer = value; self.integer = value;
self.emit.integer_changed(); self.emit.integer_changed();
} }
fn get_optional_bytearray(&self) -> Option<Vec<u8>> { fn get_optional_bytearray(&self) -> Option<Vec<u8>> {
self.optional_bytearray.clone() self.optional_bytearray.clone()
} }
fn set_optional_bytearray(&mut self, value: Option<Vec<u8>>) { fn set_optional_bytearray(&mut self, value: Option<Vec<u8>>) {
self.optional_bytearray = value; self.optional_bytearray = value;
self.emit.optional_bytearray_changed(); self.emit.optional_bytearray_changed();
} }
fn get_optional_string(&self) -> Option<String> { fn get_optional_string(&self) -> Option<String> {
self.optional_string.clone() self.optional_string.clone()
} }
fn set_optional_string(&mut self, value: Option<String>) { fn set_optional_string(&mut self, value: Option<String>) {
self.optional_string = value; self.optional_string = value;
self.emit.optional_string_changed(); self.emit.optional_string_changed();
} }
fn get_string(&self) -> String { fn get_string(&self) -> String {
self.string.clone() self.string.clone()
} }
fn set_string(&mut self, value: String) { fn set_string(&mut self, value: String) {
self.string = value; self.string = value;
self.emit.string_changed(); self.emit.string_changed();
} }
fn get_u64(&self) -> u64 { fn get_u64(&self) -> u64 {
self.u64 self.u64
} }
fn set_u64(&mut self, value: u64) { fn set_u64(&mut self, value: u64) {
self.u64 = value; self.u64 = value;
self.emit.u64_changed(); self.emit.u64_changed();
} }
fn get_uinteger(&self) -> u32 { fn get_uinteger(&self) -> u32 {
self.uinteger self.uinteger
} }
fn set_uinteger(&mut self, value: u32) { fn set_uinteger(&mut self, value: u32) {
self.uinteger = value; self.uinteger = value;
self.emit.uinteger_changed(); self.emit.uinteger_changed();
} }
} }

66
tests/rust_object_types/src/interface.rs
View File

@ -16,17 +16,20 @@ pub struct COption<T> {
some: bool, some: bool,
} }
impl<T> From<Option<T>> for COption<T> where T: Default { impl<T> From<Option<T>> for COption<T>
fn from(t: Option<T>) -> COption <T> { where
T: Default,
{
fn from(t: Option<T>) -> COption<T> {
if let Some(v) = t { if let Some(v) = t {
COption { COption {
data: v, data: v,
some: true some: true,
} }
} else { } else {
COption { COption {
data: T::default(), data: T::default(),
some: false some: false,
} }
} }
} }
@ -86,7 +89,7 @@ impl<'a> From<&'a Vec<u8>> for QByteArray {
pub struct ObjectQObject {} pub struct ObjectQObject {}
#[derive (Clone)] #[derive(Clone)]
pub struct ObjectEmitter { pub struct ObjectEmitter {
qobject: Arc<Mutex<*const ObjectQObject>>, qobject: Arc<Mutex<*const ObjectQObject>>,
boolean_changed: fn(*const ObjectQObject), boolean_changed: fn(*const ObjectQObject),
@ -177,16 +180,17 @@ pub trait ObjectTrait {
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn object_new(object: *mut ObjectQObject, pub extern "C" fn object_new(
boolean_changed: fn(*const ObjectQObject), object: *mut ObjectQObject,
bytearray_changed: fn(*const ObjectQObject), boolean_changed: fn(*const ObjectQObject),
integer_changed: fn(*const ObjectQObject), bytearray_changed: fn(*const ObjectQObject),
optional_bytearray_changed: fn(*const ObjectQObject), integer_changed: fn(*const ObjectQObject),
optional_string_changed: fn(*const ObjectQObject), optional_bytearray_changed: fn(*const ObjectQObject),
string_changed: fn(*const ObjectQObject), optional_string_changed: fn(*const ObjectQObject),
u64_changed: fn(*const ObjectQObject), string_changed: fn(*const ObjectQObject),
uinteger_changed: fn(*const ObjectQObject)) u64_changed: fn(*const ObjectQObject),
-> *mut Object { uinteger_changed: fn(*const ObjectQObject),
) -> *mut Object {
let object_emit = ObjectEmitter { let object_emit = ObjectEmitter {
qobject: Arc::new(Mutex::new(object)), qobject: Arc::new(Mutex::new(object)),
boolean_changed: boolean_changed, boolean_changed: boolean_changed,
@ -218,9 +222,11 @@ pub unsafe extern "C" fn object_boolean_set(ptr: *mut Object, v: bool) {
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn object_bytearray_get(ptr: *const Object, pub unsafe extern "C" fn object_bytearray_get(
p: *mut c_void, ptr: *const Object,
set: fn(*mut c_void, QByteArray)) { p: *mut c_void,
set: fn(*mut c_void, QByteArray),
) {
let data = (&*ptr).get_bytearray(); let data = (&*ptr).get_bytearray();
set(p, QByteArray::from(&data)); set(p, QByteArray::from(&data));
} }
@ -241,9 +247,11 @@ pub unsafe extern "C" fn object_integer_set(ptr: *mut Object, v: i32) {
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn object_optional_bytearray_get(ptr: *const Object, pub unsafe extern "C" fn object_optional_bytearray_get(
p: *mut c_void, ptr: *const Object,
set: fn(*mut c_void, QByteArray)) { p: *mut c_void,
set: fn(*mut c_void, QByteArray),
) {
let data = (&*ptr).get_optional_bytearray(); let data = (&*ptr).get_optional_bytearray();
if let Some(data) = data { if let Some(data) = data {
set(p, QByteArray::from(&data)); set(p, QByteArray::from(&data));
@ -260,9 +268,11 @@ pub unsafe extern "C" fn object_optional_bytearray_set_none(ptr: *mut Object) {
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn object_optional_string_get(ptr: *const Object, pub unsafe extern "C" fn object_optional_string_get(
p: *mut c_void, ptr: *const Object,
set: fn(*mut c_void, QString)) { p: *mut c_void,
set: fn(*mut c_void, QString),
) {
let data = (&*ptr).get_optional_string(); let data = (&*ptr).get_optional_string();
if let Some(data) = data { if let Some(data) = data {
set(p, QString::from(&data)); set(p, QString::from(&data));
@ -279,9 +289,11 @@ pub unsafe extern "C" fn object_optional_string_set_none(ptr: *mut Object) {
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn object_string_get(ptr: *const Object, pub unsafe extern "C" fn object_string_get(
p: *mut c_void, ptr: *const Object,
set: fn(*mut c_void, QString)) { p: *mut c_void,
set: fn(*mut c_void, QString),
) {
let data = (&*ptr).get_string(); let data = (&*ptr).get_string();
set(p, QString::from(&data)); set(p, QString::from(&data));
} }

2
tests/rust_objects/src/implementation.rs
View File

@ -48,7 +48,7 @@ impl InnerObjectTrait for InnerObject {
self.description = value; self.description = value;
self.emit.description_changed(); self.emit.description_changed();
} }
} }
pub struct Person { pub struct Person {
emit: PersonEmitter, emit: PersonEmitter,

38
tests/rust_objects/src/interface.rs
View File

@ -40,7 +40,7 @@ impl<'a> From<&'a String> for QString {
pub struct GroupQObject {} pub struct GroupQObject {}
#[derive (Clone)] #[derive(Clone)]
pub struct GroupEmitter { pub struct GroupEmitter {
qobject: Arc<Mutex<*const GroupQObject>>, qobject: Arc<Mutex<*const GroupQObject>>,
} }
@ -62,9 +62,12 @@ pub trait GroupTrait {
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn group_new(group: *mut GroupQObject, person: *mut PersonQObject, object: *mut InnerObjectQObject, pub extern "C" fn group_new(
description_changed: fn(*const InnerObjectQObject)) group: *mut GroupQObject,
-> *mut Group { person: *mut PersonQObject,
object: *mut InnerObjectQObject,
description_changed: fn(*const InnerObjectQObject),
) -> *mut Group {
let object_emit = InnerObjectEmitter { let object_emit = InnerObjectEmitter {
qobject: Arc::new(Mutex::new(object)), qobject: Arc::new(Mutex::new(object)),
description_changed: description_changed, description_changed: description_changed,
@ -95,7 +98,7 @@ pub unsafe extern "C" fn group_person_get(ptr: *mut Group) -> *mut Person {
pub struct InnerObjectQObject {} pub struct InnerObjectQObject {}
#[derive (Clone)] #[derive(Clone)]
pub struct InnerObjectEmitter { pub struct InnerObjectEmitter {
qobject: Arc<Mutex<*const InnerObjectQObject>>, qobject: Arc<Mutex<*const InnerObjectQObject>>,
description_changed: fn(*const InnerObjectQObject), description_changed: fn(*const InnerObjectQObject),
@ -123,9 +126,10 @@ pub trait InnerObjectTrait {
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn inner_object_new(inner_object: *mut InnerObjectQObject, pub extern "C" fn inner_object_new(
description_changed: fn(*const InnerObjectQObject)) inner_object: *mut InnerObjectQObject,
-> *mut InnerObject { description_changed: fn(*const InnerObjectQObject),
) -> *mut InnerObject {
let inner_object_emit = InnerObjectEmitter { let inner_object_emit = InnerObjectEmitter {
qobject: Arc::new(Mutex::new(inner_object)), qobject: Arc::new(Mutex::new(inner_object)),
description_changed: description_changed, description_changed: description_changed,
@ -140,9 +144,11 @@ pub unsafe extern "C" fn inner_object_free(ptr: *mut InnerObject) {
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn inner_object_description_get(ptr: *const InnerObject, pub unsafe extern "C" fn inner_object_description_get(
p: *mut c_void, ptr: *const InnerObject,
set: fn(*mut c_void, QString)) { p: *mut c_void,
set: fn(*mut c_void, QString),
) {
let data = (&*ptr).get_description(); let data = (&*ptr).get_description();
set(p, QString::from(&data)); set(p, QString::from(&data));
} }
@ -154,7 +160,7 @@ pub unsafe extern "C" fn inner_object_description_set(ptr: *mut InnerObject, v:
pub struct PersonQObject {} pub struct PersonQObject {}
#[derive (Clone)] #[derive(Clone)]
pub struct PersonEmitter { pub struct PersonEmitter {
qobject: Arc<Mutex<*const PersonQObject>>, qobject: Arc<Mutex<*const PersonQObject>>,
} }
@ -176,9 +182,11 @@ pub trait PersonTrait {
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn person_new(person: *mut PersonQObject, object: *mut InnerObjectQObject, pub extern "C" fn person_new(
description_changed: fn(*const InnerObjectQObject)) person: *mut PersonQObject,
-> *mut Person { object: *mut InnerObjectQObject,
description_changed: fn(*const InnerObjectQObject),
) -> *mut Person {
let object_emit = InnerObjectEmitter { let object_emit = InnerObjectEmitter {
qobject: Arc::new(Mutex::new(object)), qobject: Arc::new(Mutex::new(object)),
description_changed: description_changed, description_changed: description_changed,

2
tests/rust_tree/src/implementation.rs
View File

@ -3,7 +3,7 @@
#![allow(dead_code)] #![allow(dead_code)]
use interface::*; use interface::*;
#[derive (Default, Clone)] #[derive(Default, Clone)]
struct PersonsItem { struct PersonsItem {
user_name: String, user_name: String,
} }

94
tests/rust_tree/src/interface.rs
View File

@ -16,17 +16,20 @@ pub struct COption<T> {
some: bool, some: bool,
} }
impl<T> From<Option<T>> for COption<T> where T: Default { impl<T> From<Option<T>> for COption<T>
fn from(t: Option<T>) -> COption <T> { where
T: Default,
{
fn from(t: Option<T>) -> COption<T> {
if let Some(v) = t { if let Some(v) = t {
COption { COption {
data: v, data: v,
some: true some: true,
} }
} else { } else {
COption { COption {
data: T::default(), data: T::default(),
some: false some: false,
} }
} }
} }
@ -65,7 +68,7 @@ impl<'a> From<&'a String> for QString {
#[repr(C)] #[repr(C)]
pub enum SortOrder { pub enum SortOrder {
Ascending = 0, Ascending = 0,
Descending = 1 Descending = 1,
} }
#[repr(C)] #[repr(C)]
@ -76,7 +79,7 @@ pub struct QModelIndex {
pub struct PersonsQObject {} pub struct PersonsQObject {}
#[derive (Clone)] #[derive(Clone)]
pub struct PersonsEmitter { pub struct PersonsEmitter {
qobject: Arc<Mutex<*const PersonsQObject>>, qobject: Arc<Mutex<*const PersonsQObject>>,
new_data_ready: fn(*const PersonsQObject, item: usize, valid: bool), new_data_ready: fn(*const PersonsQObject, item: usize, valid: bool),
@ -91,7 +94,7 @@ impl PersonsEmitter {
pub fn new_data_ready(&self, item: Option<usize>) { pub fn new_data_ready(&self, item: Option<usize>) {
let ptr = *self.qobject.lock().unwrap(); let ptr = *self.qobject.lock().unwrap();
if !ptr.is_null() { if !ptr.is_null() {
(self.new_data_ready)(ptr, item.unwrap_or(13), item.is_some()); (self.new_data_ready)(ptr, item.unwrap_or(13), item.is_some());
} }
} }
} }
@ -135,7 +138,9 @@ pub trait PersonsTrait {
fn create(emit: PersonsEmitter, model: PersonsUniformTree) -> Self; fn create(emit: PersonsEmitter, model: PersonsUniformTree) -> Self;
fn emit(&self) -> &PersonsEmitter; fn emit(&self) -> &PersonsEmitter;
fn row_count(&self, Option<usize>) -> usize; fn row_count(&self, Option<usize>) -> usize;
fn can_fetch_more(&self, Option<usize>) -> bool { false } fn can_fetch_more(&self, Option<usize>) -> bool {
false
}
fn fetch_more(&mut self, Option<usize>) {} fn fetch_more(&mut self, Option<usize>) {}
fn sort(&mut self, u8, SortOrder) {} fn sort(&mut self, u8, SortOrder) {}
fn index(&self, item: Option<usize>, row: usize) -> usize; fn index(&self, item: Option<usize>, row: usize) -> usize;
@ -146,20 +151,17 @@ pub trait PersonsTrait {
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn persons_new(persons: *mut PersonsQObject, pub extern "C" fn persons_new(
new_data_ready: fn(*const PersonsQObject, item: usize, valid: bool), persons: *mut PersonsQObject,
data_changed: fn(*const PersonsQObject, usize, usize), new_data_ready: fn(*const PersonsQObject, item: usize, valid: bool),
begin_reset_model: fn(*const PersonsQObject), data_changed: fn(*const PersonsQObject, usize, usize),
end_reset_model: fn(*const PersonsQObject), begin_reset_model: fn(*const PersonsQObject),
begin_insert_rows: fn(*const PersonsQObject, item: usize, valid: bool, end_reset_model: fn(*const PersonsQObject),
usize, begin_insert_rows: fn(*const PersonsQObject, item: usize, valid: bool, usize, usize),
usize), end_insert_rows: fn(*const PersonsQObject),
end_insert_rows: fn(*const PersonsQObject), begin_remove_rows: fn(*const PersonsQObject, item: usize, valid: bool, usize, usize),
begin_remove_rows: fn(*const PersonsQObject, item: usize, valid: bool, end_remove_rows: fn(*const PersonsQObject),
usize, ) -> *mut Persons {
usize),
end_remove_rows: fn(*const PersonsQObject))
-> *mut Persons {
let persons_emit = PersonsEmitter { let persons_emit = PersonsEmitter {
qobject: Arc::new(Mutex::new(persons)), qobject: Arc::new(Mutex::new(persons)),
new_data_ready: new_data_ready, new_data_ready: new_data_ready,
@ -184,7 +186,11 @@ pub unsafe extern "C" fn persons_free(ptr: *mut Persons) {
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn persons_row_count(ptr: *const Persons, item: usize, valid: bool) -> c_int { pub unsafe extern "C" fn persons_row_count(
ptr: *const Persons,
item: usize,
valid: bool,
) -> c_int {
if valid { if valid {
(&*ptr).row_count(Some(item)) as c_int (&*ptr).row_count(Some(item)) as c_int
} else { } else {
@ -192,7 +198,11 @@ pub unsafe extern "C" fn persons_row_count(ptr: *const Persons, item: usize, val
} }
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn persons_can_fetch_more(ptr: *const Persons, item: usize, valid: bool) -> bool { pub unsafe extern "C" fn persons_can_fetch_more(
ptr: *const Persons,
item: usize,
valid: bool,
) -> bool {
if valid { if valid {
(&*ptr).can_fetch_more(Some(item)) (&*ptr).can_fetch_more(Some(item))
} else { } else {
@ -208,11 +218,20 @@ pub unsafe extern "C" fn persons_fetch_more(ptr: *mut Persons, item: usize, vali
} }
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn persons_sort(ptr: *mut Persons, column: u8, order: SortOrder) { pub unsafe extern "C" fn persons_sort(
ptr: *mut Persons,
column: u8,
order: SortOrder
) {
(&mut *ptr).sort(column, order) (&mut *ptr).sort(column, order)
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn persons_index(ptr: *const Persons, item: usize, valid: bool, row: c_int) -> usize { pub unsafe extern "C" fn persons_index(
ptr: *const Persons,
item: usize,
valid: bool,
row: c_int,
) -> usize {
if !valid { if !valid {
(&*ptr).index(None, row as usize) (&*ptr).index(None, row as usize)
} else { } else {
@ -222,9 +241,15 @@ pub unsafe extern "C" fn persons_index(ptr: *const Persons, item: usize, valid:
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn persons_parent(ptr: *const Persons, index: usize) -> QModelIndex { pub unsafe extern "C" fn persons_parent(ptr: *const Persons, index: usize) -> QModelIndex {
if let Some(parent) = (&*ptr).parent(index) { if let Some(parent) = (&*ptr).parent(index) {
QModelIndex{row: (&*ptr).row(parent) as c_int, internal_id: parent} QModelIndex {
row: (&*ptr).row(parent) as c_int,
internal_id: parent,
}
} else { } else {
QModelIndex{row: -1, internal_id: 0} QModelIndex {
row: -1,
internal_id: 0,
}
} }
} }
#[no_mangle] #[no_mangle]
@ -233,14 +258,19 @@ pub unsafe extern "C" fn persons_row(ptr: *const Persons, item: usize) -> c_int
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn persons_data_user_name(ptr: *const Persons, item: usize, pub unsafe extern "C" fn persons_data_user_name(
d: *mut c_void, ptr: *const Persons, item: usize,
set: fn(*mut c_void, QString)) { d: *mut c_void,
set: fn(*mut c_void, QString),
) {
let data = (&*ptr).user_name(item); let data = (&*ptr).user_name(item);
set(d, QString::from(&data)); set(d, QString::from(&data));
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn persons_set_data_user_name(ptr: *mut Persons, item: usize, v: QStringIn) -> bool { pub unsafe extern "C" fn persons_set_data_user_name(
ptr: *mut Persons, item: usize,
v: QStringIn,
) -> bool {
(&mut *ptr).set_user_name(item, v.convert()) (&mut *ptr).set_user_name(item, v.convert())
} }