diff --git a/demo/rust/src/implementation/demo.rs b/demo/rust/src/implementation/demo.rs
index 6891058..58f1105 100644
--- a/demo/rust/src/implementation/demo.rs
+++ b/demo/rust/src/implementation/demo.rs
@@ -1,80 +1,80 @@
 // Copyright 2017  Jos van den Oever <jos@vandenoever.info>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
 // published by the Free Software Foundation; either version 2 of
 // the License or (at your option) version 3 or any later version
 // accepted by the membership of KDE e.V. (or its successor approved
 // by the membership of KDE e.V.), which shall act as a proxy
 // defined in Section 14 of version 3 of the license.
 //
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use interface::*;
 use super::*;
 
 pub struct Demo {
     emit: DemoEmitter,
     fibonacci: Fibonacci,
     fibonacci_list: FibonacciList,
     file_system_tree: FileSystemTree,
     processes: Processes,
     time_series: TimeSeries
 }
 
 impl DemoTrait for Demo {
     fn new(emit: DemoEmitter,
         fibonacci: Fibonacci,
         fibonacci_list: FibonacciList,
         file_system_tree: FileSystemTree,
         processes: Processes,
         time_series: TimeSeries) -> Self {
         Demo {
-            emit: emit,
-            fibonacci: fibonacci,
-            fibonacci_list: fibonacci_list,
-            file_system_tree: file_system_tree,
-            processes: processes,
-            time_series: time_series
+            emit,
+            fibonacci,
+            fibonacci_list,
+            file_system_tree,
+            processes,
+            time_series
         }
     }
     fn emit(&self) -> &DemoEmitter {
         &self.emit
     }
     fn fibonacci(&self) -> &Fibonacci {
         &self.fibonacci
     }
     fn fibonacci_mut(&mut self) -> &mut Fibonacci {
         &mut self.fibonacci
     }
     fn fibonacci_list(&self) -> &FibonacciList {
         &self.fibonacci_list
     }
     fn fibonacci_list_mut(&mut self) -> &mut FibonacciList {
         &mut self.fibonacci_list
     }
     fn file_system_tree(&self) -> &FileSystemTree {
         &self.file_system_tree
     }
     fn file_system_tree_mut(&mut self) -> &mut FileSystemTree {
         &mut self.file_system_tree
     }
     fn processes(&self) -> &Processes {
         &self.processes
     }
     fn processes_mut(&mut self) -> &mut Processes {
         &mut self.processes
     }
     fn time_series(&self) -> &TimeSeries {
         &self.time_series
     }
     fn time_series_mut(&mut self) -> &mut TimeSeries {
         &mut self.time_series
     }
 }
diff --git a/demo/rust/src/implementation/fibonacci.rs b/demo/rust/src/implementation/fibonacci.rs
index bc2a37d..b2fb3b2 100644
--- a/demo/rust/src/implementation/fibonacci.rs
+++ b/demo/rust/src/implementation/fibonacci.rs
@@ -1,102 +1,102 @@
 // Copyright 2017  Jos van den Oever <jos@vandenoever.info>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
 // published by the Free Software Foundation; either version 2 of
 // the License or (at your option) version 3 or any later version
 // accepted by the membership of KDE e.V. (or its successor approved
 // by the membership of KDE e.V.), which shall act as a proxy
 // defined in Section 14 of version 3 of the license.
 //
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::thread;
 use interface::*;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 
 fn fibonacci(input: u32) -> usize {
     if input <= 1 {
         return input as usize;
     }
     let mut i = 0;
     let mut sum = 0;
     let mut last = 0;
     let mut cur = 1;
     while i < input - 1 {
         sum = last + cur;
         last = cur;
         cur = sum;
         i += 1;
     }
     sum
 }
 
 pub struct Fibonacci {
     emit: FibonacciEmitter,
     input: u32,
     result: Arc<AtomicUsize>,
 }
 
 impl FibonacciTrait for Fibonacci {
     fn new(emit: FibonacciEmitter) -> Fibonacci {
         Fibonacci {
-            emit: emit,
+            emit,
             input: 0,
             result: Arc::new(AtomicUsize::new(0)),
         }
     }
     fn emit(&self) -> &FibonacciEmitter {
         &self.emit
     }
     fn input(&self) -> u32 {
         self.input
     }
     fn set_input(&mut self, value: u32) {
         self.input = value;
         self.emit.input_changed();
         let emit = self.emit.clone();
         let result = self.result.clone();
         result.swap(0, Ordering::SeqCst);
         emit.result_changed();
         thread::spawn(move || {
             let r = fibonacci(value);
             result.swap(r, Ordering::SeqCst);
             emit.result_changed();
         });
     }
     fn result(&self) -> u64 {
         self.result.fetch_add(0, Ordering::SeqCst) as u64
     }
 }
 
 pub struct FibonacciList {
     emit: FibonacciListEmitter,
 }
 
 impl FibonacciListTrait for FibonacciList {
     fn new(emit: FibonacciListEmitter, _: FibonacciListList) -> FibonacciList {
         FibonacciList {
-            emit: emit,
+            emit,
         }
     }
     fn emit(&self) -> &FibonacciListEmitter {
         &self.emit
     }
     fn row_count(&self) -> usize {
         93
     }
     fn row(&self, row: usize) -> u64 {
         row as u64 + 1
     }
     fn fibonacci_number(&self, row: usize) -> u64 {
         fibonacci(row as u32 + 1) as u64
     }
 }
diff --git a/demo/rust/src/implementation/file_system_tree.rs b/demo/rust/src/implementation/file_system_tree.rs
index a405cbb..38000dd 100644
--- a/demo/rust/src/implementation/file_system_tree.rs
+++ b/demo/rust/src/implementation/file_system_tree.rs
@@ -1,309 +1,309 @@
 // Copyright 2017  Jos van den Oever <jos@vandenoever.info>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
 // published by the Free Software Foundation; either version 2 of
 // the License or (at your option) version 3 or any later version
 // accepted by the membership of KDE e.V. (or its successor approved
 // by the membership of KDE e.V.), which shall act as a proxy
 // defined in Section 14 of version 3 of the license.
 //
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use interface::*;
 use std::fs::*;
 use std::fs::read_dir;
 use std::path::PathBuf;
 use std::ffi::OsString;
 use std::default::Default;
 use std::thread;
 use std::sync::{Arc, Mutex};
 use std::marker::Sync;
 use std::collections::HashMap;
 
 pub struct DirEntry {
     name: OsString,
     metadata: Option<Metadata>,
     path: Option<PathBuf>,
     icon: Vec<u8>,
 }
 
 type Incoming<T> = Arc<Mutex<HashMap<usize, Vec<T>>>>;
 
 impl Item for DirEntry {
     fn new(name: &str) -> DirEntry {
         DirEntry {
             name: OsString::from(name),
             metadata: metadata(name).ok(),
             path: None,
             icon: Vec::new()
         }
     }
     fn can_fetch_more(&self) -> bool {
         self.metadata.as_ref().map_or(false, |m| m.is_dir())
     }
     fn file_name(&self) -> String {
         self.name.to_string_lossy().to_string()
     }
     fn file_path(&self) -> Option<String> {
         self.path.as_ref().map(|p| p.to_string_lossy().into())
     }
     fn file_permissions(&self) -> i32 {
         42
     }
     fn file_type(&self) -> i32 {
         0
     }
     fn file_size(&self) -> Option<u64> {
         self.metadata.as_ref().map(|m| m.len())
     }
     fn icon(&self) -> &[u8] {
         &self.icon
     }
     fn retrieve(id: usize, parents: Vec<&DirEntry>, q: Incoming<Self>, emit: FileSystemTreeEmitter) {
         let mut v = Vec::new();
         let path: PathBuf = parents.into_iter().map(|e| &e.name).collect();
         thread::spawn(move || {
             if let Ok(it) = read_dir(&path) {
                 for i in it.filter_map(|v| v.ok()) {
                     let de = DirEntry {
                         name: i.file_name(),
                         metadata: i.metadata().ok(),
                         path: Some(i.path()),
                         icon: Vec::new(),
                     };
                     v.push(de);
                 }
             }
             v.sort_by(|a, b| a.name.cmp(&b.name));
             let mut map = q.lock().unwrap();
             if !map.contains_key(&id) {
                 map.insert(id, v);
                 emit.new_data_ready(Some(id));
             }
         });
     }
 }
 
 impl Default for DirEntry {
     fn default() -> DirEntry {
         DirEntry {
             name: OsString::new(),
             metadata: None,
             path: None,
             icon: Vec::new(),
         }
     }
 }
 
 pub trait Item: Default {
     fn new(name: &str) -> Self;
     fn can_fetch_more(&self) -> bool;
     fn retrieve(id: usize, parents: Vec<&Self>, q: Incoming<Self>, emit: FileSystemTreeEmitter);
     fn file_name(&self) -> String;
     fn file_path(&self) -> Option<String>;
     fn file_permissions(&self) -> i32;
     fn file_type(&self) -> i32;
     fn file_size(&self) -> Option<u64>;
     fn icon(&self) -> &[u8];
 }
 
 pub type FileSystemTree = RGeneralItemModel<DirEntry>;
 
 struct Entry<T: Item> {
     parent: Option<usize>,
     row: usize,
     children: Option<Vec<usize>>,
     data: T,
 }
 
 pub struct RGeneralItemModel<T: Item> {
     emit: FileSystemTreeEmitter,
     model: FileSystemTreeTree,
     entries: Vec<Entry<T>>,
     path: Option<String>,
     incoming: Incoming<T>,
 }
 
 impl<T: Item> RGeneralItemModel<T>
 where
     T: Sync + Send,
 {
     fn reset(&mut self) {
         self.model.begin_reset_model();
         self.entries.clear();
         if let Some(ref path) = self.path {
             let root = Entry {
                 parent: None,
                 row: 0,
                 children: None,
                 data: T::new(path),
             };
             self.entries.push(root);
         }
         self.model.end_reset_model();
     }
     fn get(&self, index: usize) -> &Entry<T> {
         &self.entries[index]
     }
     fn retrieve(&mut self, index: usize) {
         let parents = self.get_parents(index);
         let incoming = self.incoming.clone();
         T::retrieve(index, parents, incoming, self.emit.clone());
     }
     fn process_incoming(&mut self) {
         if let Ok(ref mut incoming) = self.incoming.try_lock() {
             for (id, entries) in incoming.drain() {
                 if self.entries[id].children.is_some() {
                     continue;
                 }
                 let mut new_entries = Vec::new();
                 let mut children = Vec::new();
                 {
                     for (r, d) in entries.into_iter().enumerate() {
                         let e = Entry {
                             parent: Some(id),
                             row: r,
                             children: None,
                             data: d,
                         };
                         children.push(self.entries.len() + r);
                         new_entries.push(e);
                     }
                     if !new_entries.is_empty() {
                         self.model.begin_insert_rows(
                             Some(id),
                             0,
                             new_entries.len() - 1,
                         );
                     }
                 }
                 self.entries[id].children = Some(children);
                 if !new_entries.is_empty() {
                     self.entries.append(&mut new_entries);
                     self.model.end_insert_rows();
                 }
             }
         }
     }
     fn get_parents(&self, id: usize) -> Vec<&T> {
         let mut pos = Some(id);
         let mut e = Vec::new();
         while let Some(p) = pos {
             e.push(p);
             pos = self.entries[p].parent;
         }
         e.into_iter().rev().map(|i| &self.entries[i].data).collect()
     }
 }
 
 impl<T: Item> FileSystemTreeTrait for RGeneralItemModel<T>
 where
     T: Sync + Send,
 {
     fn new(emit: FileSystemTreeEmitter, model: FileSystemTreeTree) -> Self {
         let mut tree = RGeneralItemModel {
-            emit: emit,
-            model: model,
+            emit,
+            model,
             entries: Vec::new(),
             path: None,
             incoming: Arc::new(Mutex::new(HashMap::new())),
         };
         tree.reset();
         tree
     }
     fn emit(&self) -> &FileSystemTreeEmitter {
         &self.emit
     }
     fn path(&self) -> Option<&str> {
         self.path.as_ref().map(|s|&s[..])
     }
     fn set_path(&mut self, value: Option<String>) {
         if self.path != value {
             self.path = value;
             self.emit.path_changed();
             self.reset();
         }
     }
     fn can_fetch_more(&self, index: Option<usize>) -> bool {
         if let Some(index) = index {
             let entry = self.get(index);
             entry.children.is_none() && entry.data.can_fetch_more()
         } else {
             false
         }
     }
     fn fetch_more(&mut self, index: Option<usize>) {
         self.process_incoming();
         if !self.can_fetch_more(index) {
             return;
         }
         if let Some(index) = index {
             self.retrieve(index);
         }
     }
     fn row_count(&self, index: Option<usize>) -> usize {
         if self.entries.is_empty() {
             return 0;
         }
         if let Some(i) = index {
             let entry = self.get(i);
             if let Some(ref children) = entry.children {
                 children.len()
             } else {
                 // model does lazy loading, signal that data may be available
                 if self.can_fetch_more(index) {
                     self.emit.new_data_ready(index);
                 }
                 0
             }
         } else {
             1
         }
     }
     fn index(&self, index: Option<usize>, row: usize) -> usize {
         if let Some(index) = index {
             self.get(index).children.as_ref().unwrap()[row]
         } else {
             0
         }
     }
     fn parent(&self, index: usize) -> Option<usize> {
         self.entries[index].parent
     }
     fn row(&self, index: usize) -> usize {
         self.entries[index].row
     }
     fn check_row(&self, index: usize, _row: usize) -> Option<usize> {
         if index < self.entries.len() {
             Some(self.row(index))
         } else {
             None
         }
     }
     fn file_name(&self, index: usize) -> String {
         self.get(index).data.file_name()
     }
     fn file_permissions(&self, index: usize) -> i32 {
         self.get(index).data.file_permissions()
     }
     #[allow(unused_variables)]
     fn file_icon(&self, index: usize) -> &[u8] {
         self.get(index).data.icon()
     }
     fn file_path(&self, index: usize) -> Option<String> {
         self.get(index).data.file_path()
     }
     fn file_type(&self, index: usize) -> i32 {
         self.get(index).data.file_type()
     }
     fn file_size(&self, index: usize) -> Option<u64> {
         self.get(index).data.file_size()
     }
 }
diff --git a/demo/rust/src/implementation/processes.rs b/demo/rust/src/implementation/processes.rs
index 29fbefa..44cdc4b 100644
--- a/demo/rust/src/implementation/processes.rs
+++ b/demo/rust/src/implementation/processes.rs
@@ -1,442 +1,442 @@
 // Copyright 2017  Jos van den Oever <jos@vandenoever.info>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
 // published by the Free Software Foundation; either version 2 of
 // the License or (at your option) version 3 or any later version
 // accepted by the membership of KDE e.V. (or its successor approved
 // by the membership of KDE e.V.), which shall act as a proxy
 // defined in Section 14 of version 3 of the license.
 //
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use interface::*;
 use sysinfo::*;
 use std::sync::{Arc, Mutex};
 use std::collections::HashMap;
 use libc::pid_t;
 use std::thread;
 use std::time::Duration;
 use std::sync::mpsc::{channel, Sender, Receiver, RecvTimeoutError};
 
 struct ProcessItem {
     row: usize,
     tasks: Vec<pid_t>,
     process: Process,
 }
 
 #[derive(Default)]
 struct ProcessTree {
     top: Vec<pid_t>,
     processes: HashMap<pid_t, ProcessItem>,
     cpusum: f32,
 }
 
 enum ChangeState {
     Active,
     Inactive,
     Quit
 }
 
 pub struct Processes {
     emit: ProcessesEmitter,
     model: ProcessesTree,
     p: ProcessTree,
     incoming: Arc<Mutex<Option<ProcessTree>>>,
     active: bool,
     channel: Sender<ChangeState>
 }
 
 fn check_process_hierarchy(parent: Option<pid_t>, processes: &HashMap<pid_t, Process>) {
     for (pid, process) in processes {
         assert_eq!(process.pid, *pid);
-        if !parent.is_none() {
+        if parent.is_some() {
             assert_eq!(process.parent, parent);
         }
         check_process_hierarchy(Some(*pid), &process.tasks);
     }
 }
 
 fn collect_processes(
     tasks: &HashMap<pid_t, Process>,
     mut processes: &mut HashMap<pid_t, ProcessItem>,
 ) -> f32 {
     let mut cpusum = 0.0;
     for process in tasks.values() {
         processes.insert(
             process.pid,
             ProcessItem {
                 row: 0,
                 tasks: Vec::new(),
                 process: process.clone(),
             },
         );
         let s = collect_processes(&process.tasks, &mut processes);
         cpusum += process.cpu_usage + s;
     }
     cpusum
 }
 
 // reconstruct process hierarchy
 fn handle_tasks(processes: &mut HashMap<pid_t, ProcessItem>) -> Vec<pid_t> {
     let mut top = Vec::new();
     let pids: Vec<pid_t> = processes.keys().cloned().collect();
     for pid in pids {
         if let Some(parent) = processes[&pid].process.parent {
             let p = processes.get_mut(&parent).unwrap();
             p.tasks.push(pid);
         } else {
             top.push(pid);
         }
     }
     top
 }
 
 fn update_rows(list: &[pid_t], processes: &mut HashMap<pid_t, ProcessItem>) {
     for (row, pid) in list.iter().enumerate() {
         processes.get_mut(pid).unwrap().row = row;
         let l = processes[pid].tasks.clone();
         update_rows(&l, processes);
     }
 }
 
 fn sort_tasks(p: &mut ProcessTree) {
     for process in p.processes.values_mut() {
         process.tasks.sort();
     }
     p.top.sort();
     update_rows(&p.top, &mut p.processes);
 }
 
 fn update() -> ProcessTree {
     let mut p = ProcessTree::default();
     let mut sysinfo = System::new();
     sysinfo.refresh_processes();
     let list = sysinfo.get_process_list();
     check_process_hierarchy(None, list);
     p.cpusum = collect_processes(list, &mut p.processes);
     p.top = handle_tasks(&mut p.processes);
     sort_tasks(&mut p);
     p
 }
 
 fn update_thread(
     emit: ProcessesEmitter,
     incoming: Arc<Mutex<Option<ProcessTree>>>,
     mut active: bool,
     status_channel: Receiver<ChangeState>,
 ) {
     thread::spawn(move || {
         loop {
             let timeout = if active {
                 *incoming.lock().unwrap() = Some(update());
                 emit.new_data_ready(None);
                 Duration::from_secs(1)
             } else {
                 Duration::from_secs(10_000)
             };
             match status_channel.recv_timeout(timeout) {
                 Err(RecvTimeoutError::Timeout) => {},
                 Err(RecvTimeoutError::Disconnected)
                 | Ok(ChangeState::Quit) => { return; },
                 Ok(ChangeState::Active) => { active = true; },
                 Ok(ChangeState::Inactive) => { active = false; },
             }
         }
     });
 }
 
 impl Processes {
     fn get(&self, index: usize) -> &ProcessItem {
         let pid = index as pid_t;
         &self.p.processes[&pid]
     }
     fn process(&self, index: usize) -> &Process {
         let pid = index as pid_t;
         &self.p.processes[&pid].process
     }
 }
 
 fn move_process(
     pid: pid_t,
     amap: &mut HashMap<pid_t, ProcessItem>,
     bmap: &mut HashMap<pid_t, ProcessItem>,
 ) {
     if let Some(e) = bmap.remove(&pid) {
         amap.insert(pid, e);
         let ts = amap[&pid].tasks.clone();
         for t in ts {
             move_process(t, amap, bmap);
         }
     }
 }
 
 fn remove_row(
     model: &ProcessesTree,
     parent: pid_t,
     row: usize,
     map: &mut HashMap<pid_t, ProcessItem>,
 ) {
     let pid = map[&parent].tasks[row];
     println!(
         "removing {} '{}' {}",
         pid,
         map[&pid].process.exe,
         map[&pid].process.cmd.join(" ")
     );
     model.begin_remove_rows(Some(parent as usize), row, row);
     map.remove(&pid);
     let len = {
         let tasks = &mut map.get_mut(&parent).unwrap().tasks;
         tasks.remove(row);
         tasks.len()
     };
     for r in row..len {
         let pid = map.get_mut(&parent).unwrap().tasks[r];
         map.get_mut(&pid).unwrap().row = r;
     }
     model.end_remove_rows();
 }
 
 fn insert_row(
     model: &ProcessesTree,
     parent: pid_t,
     row: usize,
     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);
     move_process(pid, map, source);
     let len = {
         let tasks = &mut map.get_mut(&parent).unwrap().tasks;
         tasks.insert(row, pid);
         tasks.len()
     };
     for r in row..len {
         let pid = map.get_mut(&parent).unwrap().tasks[r];
         map.get_mut(&pid).unwrap().row = r;
     }
     model.end_insert_rows();
 }
 
 fn cmp_f32(a: f32, b: f32) -> bool {
     ((a - b) / a).abs() < 0.01
 }
 
 fn sync_row(model: &ProcessesTree, pid: pid_t, a: &mut Process, b: &Process) -> f32 {
     let mut changed = a.name != b.name;
     if changed {
         a.name.clone_from(&b.name);
     }
     if !cmp_f32(a.cpu_usage, b.cpu_usage) {
         a.cpu_usage = b.cpu_usage;
         changed = true;
     }
     if a.cmd != b.cmd {
         a.cmd.clone_from(&b.cmd);
         changed = true;
     }
     if a.exe != b.exe {
         a.exe.clone_from(&b.exe);
         changed = true;
     }
     if a.memory != b.memory {
         a.memory = b.memory;
         changed = true;
     }
     if changed {
         model.data_changed(pid as usize, pid as usize);
     }
     b.cpu_usage
 }
 
 fn sync_tree(
     model: &ProcessesTree,
     parent: pid_t,
     amap: &mut HashMap<pid_t, ProcessItem>,
     bmap: &mut HashMap<pid_t, ProcessItem>,
 ) -> f32 {
     let mut a = 0;
     let mut b = 0;
     let mut alen = amap[&parent].tasks.len();
     let blen = bmap[&parent].tasks.len();
     let mut cpu_total = bmap[&parent].process.cpu_usage;
 
     while a < alen && b < blen {
         let apid = amap[&parent].tasks[a];
         let bpid = bmap[&parent].tasks[b];
         if apid < bpid {
             // a process has disappeared
             remove_row(model, parent, a, amap);
             alen -= 1;
         } else if apid > bpid {
             // a process has appeared
             insert_row(model, parent, a, amap, bpid, bmap);
             cpu_total += amap[&bpid].process.cpu_usage;
             a += 1;
             alen += 1;
             b += 1;
         } else {
             cpu_total += sync_row(
                 model,
                 apid,
                 &mut amap.get_mut(&apid).unwrap().process,
                 &bmap[&apid].process,
             );
             cpu_total += sync_tree(model, apid, amap, bmap);
             a += 1;
             b += 1;
         }
     }
     while a < blen {
         let bpid = bmap[&parent].tasks[b];
         insert_row(model, parent, a, amap, bpid, bmap);
         a += 1;
         alen += 1;
         b += 1;
     }
     while b < alen {
         remove_row(model, parent, a, amap);
         alen -= 1;
     }
     if !cmp_f32(cpu_total, bmap[&parent].process.cpu_usage) {
         amap.get_mut(&parent).unwrap().process.cpu_usage = cpu_total;
         model.data_changed(parent as usize, parent as usize);
     }
     assert_eq!(a, b);
     cpu_total
 }
 
 impl ProcessesTrait for Processes {
     fn new(emit: ProcessesEmitter, model: ProcessesTree) -> Processes {
         let (tx, rx) = channel();
         let p = Processes {
             emit: emit.clone(),
-            model: model,
+            model,
             p: ProcessTree::default(),
             incoming: Arc::new(Mutex::new(None)),
             active: false,
             channel: tx,
         };
         update_thread(emit, p.incoming.clone(), p.active, rx);
         p
     }
     fn emit(&self) -> &ProcessesEmitter {
         &self.emit
     }
     fn row_count(&self, index: Option<usize>) -> usize {
         if let Some(index) = index {
             self.get(index).tasks.len()
         } else {
             self.p.top.len()
         }
     }
     fn index(&self, index: Option<usize>, row: usize) -> usize {
         if let Some(index) = index {
             self.get(index).tasks[row] as usize
         } else {
             self.p.top[row] as usize
         }
     }
     fn parent(&self, index: usize) -> Option<usize> {
         self.get(index).process.parent.map(|pid| pid as usize)
     }
     fn can_fetch_more(&self, index: Option<usize>) -> bool {
         if index.is_some() || !self.active {
             return false;
         }
         if let Ok(ref incoming) = self.incoming.try_lock() {
             incoming.is_some()
         } else {
             false
         }
     }
     fn fetch_more(&mut self, index: Option<usize>) {
         if index.is_some() || !self.active {
             return;
         }
         let new = if let Ok(ref mut incoming) = self.incoming.try_lock() {
             incoming.take()
         } else {
             None
         };
         if let Some(mut new) = new {
             // alert! at the top level, only adding is supported!
             if self.p.top.is_empty() {
                 self.model.begin_reset_model();
                 self.p = new;
                 self.model.end_reset_model();
             } else {
                 let top = self.p.top.clone();
                 for pid in top {
                     sync_tree(&self.model, pid, &mut self.p.processes, &mut new.processes);
                 }
             }
         }
     }
     fn row(&self, index: usize) -> usize {
         self.get(index).row
     }
     fn check_row(&self, index: usize, _row: usize) -> Option<usize> {
         let pid = index as pid_t;
         if self.p.processes.contains_key(&pid) {
             Some(self.row(index))
         } else {
             None
         }
     }
     fn pid(&self, index: usize) -> u32 {
         self.process(index).pid as u32
     }
     fn uid(&self, index: usize) -> u32 {
         self.process(index).uid as u32
     }
     fn cpu_usage(&self, index: usize) -> f32 {
         self.process(index).cpu_usage
     }
     fn cpu_percentage(&self, index: usize) -> u8 {
         let cpu = self.process(index).cpu_usage / self.p.cpusum;
         (cpu * 100.0) as u8
     }
     fn memory(&self, index: usize) -> u64 {
         self.process(index).memory
     }
     fn name(&self, index: usize) -> &str {
         &self.process(index).name
     }
     fn cmd(&self, index: usize) -> String {
         self.process(index).cmd.join(" ")
     }
     fn active(&self) -> bool {
         self.active
     }
     fn set_active(&mut self, active: bool) {
         if self.active != active {
             self.active = active;
             if active {
                 self.channel.send(ChangeState::Active)
             } else {
                 self.channel.send(ChangeState::Inactive)
             }.expect("Process thread died.");
         }
     }
 }
 
 impl Drop for Processes {
     fn drop(&mut self) {
         self.channel.send(ChangeState::Quit).expect("Process thread died.");
     }
 }
diff --git a/demo/rust/src/implementation/time_series.rs b/demo/rust/src/implementation/time_series.rs
index 95318bf..9bc2b9a 100644
--- a/demo/rust/src/implementation/time_series.rs
+++ b/demo/rust/src/implementation/time_series.rs
@@ -1,76 +1,76 @@
 // Copyright 2017  Jos van den Oever <jos@vandenoever.info>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
 // published by the Free Software Foundation; either version 2 of
 // the License or (at your option) version 3 or any later version
 // accepted by the membership of KDE e.V. (or its successor approved
 // by the membership of KDE e.V.), which shall act as a proxy
 // defined in Section 14 of version 3 of the license.
 //
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use interface::*;
 
 #[derive(Default, Clone)]
 struct TimeSeriesItem {
     time: f32,
     sin: f32,
     cos: f32,
 }
 
 pub struct TimeSeries {
     emit: TimeSeriesEmitter,
     list: Vec<TimeSeriesItem>,
 }
 
 impl TimeSeriesTrait for TimeSeries {
     fn new(emit: TimeSeriesEmitter, _: TimeSeriesList) -> TimeSeries {
         let mut series = TimeSeries {
-            emit: emit,
+            emit,
             list: Vec::new(),
         };
         for i in 0..101 {
             let x = i as f32 / 10.;
             series.list.push(TimeSeriesItem {
                 time: x,
                 sin: x.sin(),
                 cos: x.cos(),
             });
         }
         series
     }
     fn emit(&self) -> &TimeSeriesEmitter {
         &self.emit
     }
     fn row_count(&self) -> usize {
         self.list.len() as usize
     }
     fn time(&self, row: usize) -> f32 {
         self.list[row as usize].time
     }
     fn set_time(&mut self, row: usize, v: f32) -> bool {
         self.list[row as usize].time = v;
         true
     }
     fn sin(&self, row: usize) -> f32 {
         self.list[row as usize].sin
     }
     fn set_sin(&mut self, row: usize, v: f32) -> bool {
         self.list[row as usize].sin = v;
         true
     }
     fn cos(&self, row: usize) -> f32 {
         self.list[row as usize].cos
     }
     fn set_cos(&mut self, row: usize, v: f32) -> bool {
         self.list[row as usize].cos = v;
         true
     }
 }
diff --git a/demo/rust/src/interface.rs b/demo/rust/src/interface.rs
index 3ceed02..45a9630 100644
--- a/demo/rust/src/interface.rs
+++ b/demo/rust/src/interface.rs
@@ -1,1338 +1,1337 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
 use libc::{c_char, c_ushort, c_int};
 use std::slice;
 use std::char::decode_utf16;
 
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use implementation::*;
 
 
 #[repr(C)]
 pub struct COption<T> {
     data: T,
     some: bool,
 }
 
 impl<T> COption<T> {
     #![allow(dead_code)]
     fn into(self) -> Option<T> {
         if self.some {
             Some(self.data)
         } else {
             None
         }
     }
 }
 
 impl<T> From<Option<T>> for COption<T>
 where
     T: Default,
 {
     fn from(t: Option<T>) -> COption<T> {
         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())
-        .into_iter()
         .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 {}
 
 #[derive(Clone)]
 pub struct DemoEmitter {
     qobject: Arc<Mutex<*const DemoQObject>>,
 }
 
 unsafe impl Send for DemoEmitter {}
 
 impl DemoEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
 }
 
 pub trait DemoTrait {
     fn new(emit: DemoEmitter,
         fibonacci: Fibonacci,
         fibonacci_list: FibonacciList,
         file_system_tree: FileSystemTree,
         processes: Processes,
         time_series: TimeSeries) -> Self;
     fn emit(&self) -> &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(*const FibonacciQObject),
     fibonacci_result_changed: fn(*const FibonacciQObject),
     fibonacci_list: *mut FibonacciListQObject,
     fibonacci_list_new_data_ready: fn(*const FibonacciListQObject),
     fibonacci_list_layout_about_to_be_changed: fn(*const FibonacciListQObject),
     fibonacci_list_layout_changed: fn(*const FibonacciListQObject),
     fibonacci_list_data_changed: fn(*const FibonacciListQObject, usize, usize),
     fibonacci_list_begin_reset_model: fn(*const FibonacciListQObject),
     fibonacci_list_end_reset_model: fn(*const FibonacciListQObject),
     fibonacci_list_begin_insert_rows: fn(*const FibonacciListQObject, usize, usize),
     fibonacci_list_end_insert_rows: fn(*const FibonacciListQObject),
     fibonacci_list_begin_move_rows: fn(*const FibonacciListQObject, usize, usize, usize),
     fibonacci_list_end_move_rows: fn(*const FibonacciListQObject),
     fibonacci_list_begin_remove_rows: fn(*const FibonacciListQObject, usize, usize),
     fibonacci_list_end_remove_rows: fn(*const FibonacciListQObject),
     file_system_tree: *mut FileSystemTreeQObject,
     file_system_tree_path_changed: fn(*const FileSystemTreeQObject),
     file_system_tree_new_data_ready: fn(*const FileSystemTreeQObject, index: COption<usize>),
     file_system_tree_layout_about_to_be_changed: fn(*const FileSystemTreeQObject),
     file_system_tree_layout_changed: fn(*const FileSystemTreeQObject),
     file_system_tree_data_changed: fn(*const FileSystemTreeQObject, usize, usize),
     file_system_tree_begin_reset_model: fn(*const FileSystemTreeQObject),
     file_system_tree_end_reset_model: fn(*const FileSystemTreeQObject),
     file_system_tree_begin_insert_rows: fn(*const FileSystemTreeQObject, index: COption<usize>, usize, usize),
     file_system_tree_end_insert_rows: fn(*const FileSystemTreeQObject),
     file_system_tree_begin_move_rows: fn(*const FileSystemTreeQObject, index: COption<usize>, usize, usize, index: COption<usize>, usize),
     file_system_tree_end_move_rows: fn(*const FileSystemTreeQObject),
     file_system_tree_begin_remove_rows: fn(*const FileSystemTreeQObject, index: COption<usize>, usize, usize),
     file_system_tree_end_remove_rows: fn(*const FileSystemTreeQObject),
     processes: *mut ProcessesQObject,
     processes_active_changed: fn(*const ProcessesQObject),
     processes_new_data_ready: fn(*const ProcessesQObject, index: COption<usize>),
     processes_layout_about_to_be_changed: fn(*const ProcessesQObject),
     processes_layout_changed: fn(*const ProcessesQObject),
     processes_data_changed: fn(*const ProcessesQObject, usize, usize),
     processes_begin_reset_model: fn(*const ProcessesQObject),
     processes_end_reset_model: fn(*const ProcessesQObject),
     processes_begin_insert_rows: fn(*const ProcessesQObject, index: COption<usize>, usize, usize),
     processes_end_insert_rows: fn(*const ProcessesQObject),
     processes_begin_move_rows: fn(*const ProcessesQObject, index: COption<usize>, usize, usize, index: COption<usize>, usize),
     processes_end_move_rows: fn(*const ProcessesQObject),
     processes_begin_remove_rows: fn(*const ProcessesQObject, index: COption<usize>, usize, usize),
     processes_end_remove_rows: fn(*const ProcessesQObject),
     time_series: *mut TimeSeriesQObject,
     time_series_new_data_ready: fn(*const TimeSeriesQObject),
     time_series_layout_about_to_be_changed: fn(*const TimeSeriesQObject),
     time_series_layout_changed: fn(*const TimeSeriesQObject),
     time_series_data_changed: fn(*const TimeSeriesQObject, usize, usize),
     time_series_begin_reset_model: fn(*const TimeSeriesQObject),
     time_series_end_reset_model: fn(*const TimeSeriesQObject),
     time_series_begin_insert_rows: fn(*const TimeSeriesQObject, usize, usize),
     time_series_end_insert_rows: fn(*const TimeSeriesQObject),
     time_series_begin_move_rows: fn(*const TimeSeriesQObject, usize, usize, usize),
     time_series_end_move_rows: fn(*const TimeSeriesQObject),
     time_series_begin_remove_rows: fn(*const TimeSeriesQObject, usize, usize),
     time_series_end_remove_rows: fn(*const TimeSeriesQObject),
 ) -> *mut Demo {
     let fibonacci_emit = FibonacciEmitter {
         qobject: Arc::new(Mutex::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(Mutex::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(Mutex::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(Mutex::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(Mutex::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(Mutex::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 {}
 
 #[derive(Clone)]
 pub struct FibonacciEmitter {
     qobject: Arc<Mutex<*const FibonacciQObject>>,
     input_changed: fn(*const FibonacciQObject),
     result_changed: fn(*const FibonacciQObject),
 }
 
 unsafe impl Send for FibonacciEmitter {}
 
 impl FibonacciEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
     pub fn input_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.input_changed)(ptr);
         }
     }
     pub fn result_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.result_changed)(ptr);
         }
     }
 }
 
 pub trait FibonacciTrait {
     fn new(emit: FibonacciEmitter) -> Self;
     fn emit(&self) -> &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(*const FibonacciQObject),
     fibonacci_result_changed: fn(*const FibonacciQObject),
 ) -> *mut Fibonacci {
     let fibonacci_emit = FibonacciEmitter {
         qobject: Arc::new(Mutex::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 {}
 
 #[derive(Clone)]
 pub struct FibonacciListEmitter {
     qobject: Arc<Mutex<*const FibonacciListQObject>>,
     new_data_ready: fn(*const FibonacciListQObject),
 }
 
 unsafe impl Send for FibonacciListEmitter {}
 
 impl FibonacciListEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
     pub fn new_data_ready(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.new_data_ready)(ptr);
         }
     }
 }
 
 #[derive(Clone)]
 pub struct FibonacciListList {
     qobject: *const FibonacciListQObject,
     layout_about_to_be_changed: fn(*const FibonacciListQObject),
     layout_changed: fn(*const FibonacciListQObject),
     data_changed: fn(*const FibonacciListQObject, usize, usize),
     begin_reset_model: fn(*const FibonacciListQObject),
     end_reset_model: fn(*const FibonacciListQObject),
     begin_insert_rows: fn(*const FibonacciListQObject, usize, usize),
     end_insert_rows: fn(*const FibonacciListQObject),
     begin_move_rows: fn(*const FibonacciListQObject, usize, usize, usize),
     end_move_rows: fn(*const FibonacciListQObject),
     begin_remove_rows: fn(*const FibonacciListQObject, usize, usize),
     end_remove_rows: fn(*const FibonacciListQObject),
 }
 
 impl FibonacciListList {
     pub fn layout_about_to_be_changed(&self) {
         (self.layout_about_to_be_changed)(self.qobject);
     }
     pub fn layout_changed(&self) {
         (self.layout_changed)(self.qobject);
     }
     pub fn data_changed(&self, first: usize, last: usize) {
         (self.data_changed)(self.qobject, first, last);
     }
     pub fn begin_reset_model(&self) {
         (self.begin_reset_model)(self.qobject);
     }
     pub fn end_reset_model(&self) {
         (self.end_reset_model)(self.qobject);
     }
     pub fn begin_insert_rows(&self, first: usize, last: usize) {
         (self.begin_insert_rows)(self.qobject, first, last);
     }
     pub fn end_insert_rows(&self) {
         (self.end_insert_rows)(self.qobject);
     }
     pub fn begin_move_rows(&self, first: usize, last: usize, destination: usize) {
         (self.begin_move_rows)(self.qobject, first, last, destination);
     }
     pub fn end_move_rows(&self) {
         (self.end_move_rows)(self.qobject);
     }
     pub fn begin_remove_rows(&self, first: usize, last: usize) {
         (self.begin_remove_rows)(self.qobject, first, last);
     }
     pub fn end_remove_rows(&self) {
         (self.end_remove_rows)(self.qobject);
     }
 }
 
 pub trait FibonacciListTrait {
     fn new(emit: FibonacciListEmitter, model: FibonacciListList) -> Self;
     fn emit(&self) -> &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 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(*const FibonacciListQObject),
     fibonacci_list_layout_about_to_be_changed: fn(*const FibonacciListQObject),
     fibonacci_list_layout_changed: fn(*const FibonacciListQObject),
     fibonacci_list_data_changed: fn(*const FibonacciListQObject, usize, usize),
     fibonacci_list_begin_reset_model: fn(*const FibonacciListQObject),
     fibonacci_list_end_reset_model: fn(*const FibonacciListQObject),
     fibonacci_list_begin_insert_rows: fn(*const FibonacciListQObject, usize, usize),
     fibonacci_list_end_insert_rows: fn(*const FibonacciListQObject),
     fibonacci_list_begin_move_rows: fn(*const FibonacciListQObject, usize, usize, usize),
     fibonacci_list_end_move_rows: fn(*const FibonacciListQObject),
     fibonacci_list_begin_remove_rows: fn(*const FibonacciListQObject, usize, usize),
     fibonacci_list_end_remove_rows: fn(*const FibonacciListQObject),
 ) -> *mut FibonacciList {
     let fibonacci_list_emit = FibonacciListEmitter {
         qobject: Arc::new(Mutex::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 extern "C" fn fibonacci_list_data_fibonacci_number(ptr: *const FibonacciList, row: c_int) -> u64 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn fibonacci_list_data_row(ptr: *const FibonacciList, row: c_int) -> u64 {
-    let o = unsafe { &*ptr };
+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 {}
 
 #[derive(Clone)]
 pub struct FileSystemTreeEmitter {
     qobject: Arc<Mutex<*const FileSystemTreeQObject>>,
     path_changed: fn(*const FileSystemTreeQObject),
     new_data_ready: fn(*const FileSystemTreeQObject, index: COption<usize>),
 }
 
 unsafe impl Send for FileSystemTreeEmitter {}
 
 impl FileSystemTreeEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
     pub fn path_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.path_changed)(ptr);
         }
     }
     pub fn new_data_ready(&self, item: Option<usize>) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.new_data_ready)(ptr, item.into());
         }
     }
 }
 
 #[derive(Clone)]
 pub struct FileSystemTreeTree {
     qobject: *const FileSystemTreeQObject,
     layout_about_to_be_changed: fn(*const FileSystemTreeQObject),
     layout_changed: fn(*const FileSystemTreeQObject),
     data_changed: fn(*const FileSystemTreeQObject, usize, usize),
     begin_reset_model: fn(*const FileSystemTreeQObject),
     end_reset_model: fn(*const FileSystemTreeQObject),
     begin_insert_rows: fn(*const FileSystemTreeQObject, index: COption<usize>, usize, usize),
     end_insert_rows: fn(*const FileSystemTreeQObject),
     begin_move_rows: fn(*const FileSystemTreeQObject, index: COption<usize>, usize, usize, dest: COption<usize>, usize),
     end_move_rows: fn(*const FileSystemTreeQObject),
     begin_remove_rows: fn(*const FileSystemTreeQObject, index: COption<usize>, usize, usize),
     end_remove_rows: fn(*const FileSystemTreeQObject),
 }
 
 impl FileSystemTreeTree {
     pub fn layout_about_to_be_changed(&self) {
         (self.layout_about_to_be_changed)(self.qobject);
     }
     pub fn layout_changed(&self) {
         (self.layout_changed)(self.qobject);
     }
     pub fn data_changed(&self, first: usize, last: usize) {
         (self.data_changed)(self.qobject, first, last);
     }
     pub fn begin_reset_model(&self) {
         (self.begin_reset_model)(self.qobject);
     }
     pub fn end_reset_model(&self) {
         (self.end_reset_model)(self.qobject);
     }
     pub fn begin_insert_rows(&self, index: Option<usize>, first: usize, last: usize) {
         (self.begin_insert_rows)(self.qobject, index.into(), first, last);
     }
     pub fn end_insert_rows(&self) {
         (self.end_insert_rows)(self.qobject);
     }
     pub fn begin_move_rows(&self, index: Option<usize>, first: usize, last: usize, dest: Option<usize>, destination: usize) {
         (self.begin_move_rows)(self.qobject, index.into(), first, last, dest.into(), destination);
     }
     pub fn end_move_rows(&self) {
         (self.end_move_rows)(self.qobject);
     }
     pub fn begin_remove_rows(&self, index: Option<usize>, first: usize, last: usize) {
         (self.begin_remove_rows)(self.qobject, index.into(), first, last);
     }
     pub fn end_remove_rows(&self) {
         (self.end_remove_rows)(self.qobject);
     }
 }
 
 pub trait FileSystemTreeTrait {
     fn new(emit: FileSystemTreeEmitter, model: FileSystemTreeTree) -> Self;
     fn emit(&self) -> &FileSystemTreeEmitter;
     fn path(&self) -> Option<&str>;
     fn set_path(&mut self, value: Option<String>);
     fn row_count(&self, Option<usize>) -> usize;
     fn can_fetch_more(&self, Option<usize>) -> bool {
         false
     }
     fn fetch_more(&mut self, Option<usize>) {}
     fn sort(&mut self, u8, SortOrder) {}
     fn check_row(&self, index: usize, row: usize) -> Option<usize>;
     fn index(&self, item: Option<usize>, row: usize) -> usize;
     fn parent(&self, index: usize) -> Option<usize>;
     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<String>;
     fn file_permissions(&self, index: usize) -> i32;
     fn file_size(&self, index: usize) -> Option<u64>;
     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(*const FileSystemTreeQObject),
     file_system_tree_new_data_ready: fn(*const FileSystemTreeQObject, index: COption<usize>),
     file_system_tree_layout_about_to_be_changed: fn(*const FileSystemTreeQObject),
     file_system_tree_layout_changed: fn(*const FileSystemTreeQObject),
     file_system_tree_data_changed: fn(*const FileSystemTreeQObject, usize, usize),
     file_system_tree_begin_reset_model: fn(*const FileSystemTreeQObject),
     file_system_tree_end_reset_model: fn(*const FileSystemTreeQObject),
     file_system_tree_begin_insert_rows: fn(*const FileSystemTreeQObject, index: COption<usize>, usize, usize),
     file_system_tree_end_insert_rows: fn(*const FileSystemTreeQObject),
     file_system_tree_begin_move_rows: fn(*const FileSystemTreeQObject, index: COption<usize>, usize, usize, index: COption<usize>, usize),
     file_system_tree_end_move_rows: fn(*const FileSystemTreeQObject),
     file_system_tree_begin_remove_rows: fn(*const FileSystemTreeQObject, index: COption<usize>, usize, usize),
     file_system_tree_end_remove_rows: fn(*const FileSystemTreeQObject),
 ) -> *mut FileSystemTree {
     let file_system_tree_emit = FileSystemTreeEmitter {
         qobject: Arc::new(Mutex::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 extern "C" fn file_system_tree_path_get(
+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 = unsafe { &*ptr };
+    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 extern "C" fn file_system_tree_path_set(ptr: *mut FileSystemTree, v: *const c_ushort, len: c_int) {
-    let o = unsafe { &mut *ptr };
+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 extern "C" fn file_system_tree_path_set_none(ptr: *mut FileSystemTree) {
-    let o = unsafe { &mut *ptr };
+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<usize>,
 ) -> 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<usize>,
 ) -> bool {
     (&*ptr).can_fetch_more(index.into())
 }
 #[no_mangle]
 pub unsafe extern "C" fn file_system_tree_fetch_more(ptr: *mut FileSystemTree, index: COption<usize>) {
     (&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<usize> {
     (&*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<usize>,
     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 extern "C" fn file_system_tree_data_file_icon(
+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 = unsafe { &*ptr };
+    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 extern "C" fn file_system_tree_data_file_name(
+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 = unsafe { &*ptr };
+    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 extern "C" fn file_system_tree_data_file_path(
+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 = unsafe { &*ptr };
+    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 extern "C" fn file_system_tree_data_file_permissions(ptr: *const FileSystemTree, index: usize) -> i32 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn file_system_tree_data_file_size(ptr: *const FileSystemTree, index: usize) -> COption<u64> {
-    let o = unsafe { &*ptr };
+pub unsafe extern "C" fn file_system_tree_data_file_size(ptr: *const FileSystemTree, index: usize) -> COption<u64> {
+    let o = &*ptr;
     o.file_size(index).into()
 }
 
 #[no_mangle]
-pub extern "C" fn file_system_tree_data_file_type(ptr: *const FileSystemTree, index: usize) -> i32 {
-    let o = unsafe { &*ptr };
+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 {}
 
 #[derive(Clone)]
 pub struct ProcessesEmitter {
     qobject: Arc<Mutex<*const ProcessesQObject>>,
     active_changed: fn(*const ProcessesQObject),
     new_data_ready: fn(*const ProcessesQObject, index: COption<usize>),
 }
 
 unsafe impl Send for ProcessesEmitter {}
 
 impl ProcessesEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
     pub fn active_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.active_changed)(ptr);
         }
     }
     pub fn new_data_ready(&self, item: Option<usize>) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.new_data_ready)(ptr, item.into());
         }
     }
 }
 
 #[derive(Clone)]
 pub struct ProcessesTree {
     qobject: *const ProcessesQObject,
     layout_about_to_be_changed: fn(*const ProcessesQObject),
     layout_changed: fn(*const ProcessesQObject),
     data_changed: fn(*const ProcessesQObject, usize, usize),
     begin_reset_model: fn(*const ProcessesQObject),
     end_reset_model: fn(*const ProcessesQObject),
     begin_insert_rows: fn(*const ProcessesQObject, index: COption<usize>, usize, usize),
     end_insert_rows: fn(*const ProcessesQObject),
     begin_move_rows: fn(*const ProcessesQObject, index: COption<usize>, usize, usize, dest: COption<usize>, usize),
     end_move_rows: fn(*const ProcessesQObject),
     begin_remove_rows: fn(*const ProcessesQObject, index: COption<usize>, usize, usize),
     end_remove_rows: fn(*const ProcessesQObject),
 }
 
 impl ProcessesTree {
     pub fn layout_about_to_be_changed(&self) {
         (self.layout_about_to_be_changed)(self.qobject);
     }
     pub fn layout_changed(&self) {
         (self.layout_changed)(self.qobject);
     }
     pub fn data_changed(&self, first: usize, last: usize) {
         (self.data_changed)(self.qobject, first, last);
     }
     pub fn begin_reset_model(&self) {
         (self.begin_reset_model)(self.qobject);
     }
     pub fn end_reset_model(&self) {
         (self.end_reset_model)(self.qobject);
     }
     pub fn begin_insert_rows(&self, index: Option<usize>, first: usize, last: usize) {
         (self.begin_insert_rows)(self.qobject, index.into(), first, last);
     }
     pub fn end_insert_rows(&self) {
         (self.end_insert_rows)(self.qobject);
     }
     pub fn begin_move_rows(&self, index: Option<usize>, first: usize, last: usize, dest: Option<usize>, destination: usize) {
         (self.begin_move_rows)(self.qobject, index.into(), first, last, dest.into(), destination);
     }
     pub fn end_move_rows(&self) {
         (self.end_move_rows)(self.qobject);
     }
     pub fn begin_remove_rows(&self, index: Option<usize>, first: usize, last: usize) {
         (self.begin_remove_rows)(self.qobject, index.into(), first, last);
     }
     pub fn end_remove_rows(&self) {
         (self.end_remove_rows)(self.qobject);
     }
 }
 
 pub trait ProcessesTrait {
     fn new(emit: ProcessesEmitter, model: ProcessesTree) -> Self;
     fn emit(&self) -> &ProcessesEmitter;
     fn active(&self) -> bool;
     fn set_active(&mut self, value: bool);
     fn row_count(&self, Option<usize>) -> usize;
     fn can_fetch_more(&self, Option<usize>) -> bool {
         false
     }
     fn fetch_more(&mut self, Option<usize>) {}
     fn sort(&mut self, u8, SortOrder) {}
     fn check_row(&self, index: usize, row: usize) -> Option<usize>;
     fn index(&self, item: Option<usize>, row: usize) -> usize;
     fn parent(&self, index: usize) -> Option<usize>;
     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(*const ProcessesQObject),
     processes_new_data_ready: fn(*const ProcessesQObject, index: COption<usize>),
     processes_layout_about_to_be_changed: fn(*const ProcessesQObject),
     processes_layout_changed: fn(*const ProcessesQObject),
     processes_data_changed: fn(*const ProcessesQObject, usize, usize),
     processes_begin_reset_model: fn(*const ProcessesQObject),
     processes_end_reset_model: fn(*const ProcessesQObject),
     processes_begin_insert_rows: fn(*const ProcessesQObject, index: COption<usize>, usize, usize),
     processes_end_insert_rows: fn(*const ProcessesQObject),
     processes_begin_move_rows: fn(*const ProcessesQObject, index: COption<usize>, usize, usize, index: COption<usize>, usize),
     processes_end_move_rows: fn(*const ProcessesQObject),
     processes_begin_remove_rows: fn(*const ProcessesQObject, index: COption<usize>, usize, usize),
     processes_end_remove_rows: fn(*const ProcessesQObject),
 ) -> *mut Processes {
     let processes_emit = ProcessesEmitter {
         qobject: Arc::new(Mutex::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<usize>,
 ) -> 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<usize>,
 ) -> bool {
     (&*ptr).can_fetch_more(index.into())
 }
 #[no_mangle]
 pub unsafe extern "C" fn processes_fetch_more(ptr: *mut Processes, index: COption<usize>) {
     (&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<usize> {
     (&*ptr).check_row(index.into(), to_usize(row)).into()
 }
 #[no_mangle]
 pub unsafe extern "C" fn processes_index(
     ptr: *const Processes,
     index: COption<usize>,
     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 extern "C" fn processes_data_cmd(
+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 = unsafe { &*ptr };
+    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 extern "C" fn processes_data_cpu_percentage(ptr: *const Processes, index: usize) -> u8 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn processes_data_cpu_usage(ptr: *const Processes, index: usize) -> f32 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn processes_data_memory(ptr: *const Processes, index: usize) -> u64 {
-    let o = unsafe { &*ptr };
+pub unsafe extern "C" fn processes_data_memory(ptr: *const Processes, index: usize) -> u64 {
+    let o = &*ptr;
     o.memory(index).into()
 }
 
 #[no_mangle]
-pub extern "C" fn processes_data_name(
+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 = unsafe { &*ptr };
+    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 extern "C" fn processes_data_pid(ptr: *const Processes, index: usize) -> u32 {
-    let o = unsafe { &*ptr };
+pub unsafe extern "C" fn processes_data_pid(ptr: *const Processes, index: usize) -> u32 {
+    let o = &*ptr;
     o.pid(index).into()
 }
 
 #[no_mangle]
-pub extern "C" fn processes_data_uid(ptr: *const Processes, index: usize) -> u32 {
-    let o = unsafe { &*ptr };
+pub unsafe extern "C" fn processes_data_uid(ptr: *const Processes, index: usize) -> u32 {
+    let o = &*ptr;
     o.uid(index).into()
 }
 
 pub struct TimeSeriesQObject {}
 
 #[derive(Clone)]
 pub struct TimeSeriesEmitter {
     qobject: Arc<Mutex<*const TimeSeriesQObject>>,
     new_data_ready: fn(*const TimeSeriesQObject),
 }
 
 unsafe impl Send for TimeSeriesEmitter {}
 
 impl TimeSeriesEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
     pub fn new_data_ready(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.new_data_ready)(ptr);
         }
     }
 }
 
 #[derive(Clone)]
 pub struct TimeSeriesList {
     qobject: *const TimeSeriesQObject,
     layout_about_to_be_changed: fn(*const TimeSeriesQObject),
     layout_changed: fn(*const TimeSeriesQObject),
     data_changed: fn(*const TimeSeriesQObject, usize, usize),
     begin_reset_model: fn(*const TimeSeriesQObject),
     end_reset_model: fn(*const TimeSeriesQObject),
     begin_insert_rows: fn(*const TimeSeriesQObject, usize, usize),
     end_insert_rows: fn(*const TimeSeriesQObject),
     begin_move_rows: fn(*const TimeSeriesQObject, usize, usize, usize),
     end_move_rows: fn(*const TimeSeriesQObject),
     begin_remove_rows: fn(*const TimeSeriesQObject, usize, usize),
     end_remove_rows: fn(*const TimeSeriesQObject),
 }
 
 impl TimeSeriesList {
     pub fn layout_about_to_be_changed(&self) {
         (self.layout_about_to_be_changed)(self.qobject);
     }
     pub fn layout_changed(&self) {
         (self.layout_changed)(self.qobject);
     }
     pub fn data_changed(&self, first: usize, last: usize) {
         (self.data_changed)(self.qobject, first, last);
     }
     pub fn begin_reset_model(&self) {
         (self.begin_reset_model)(self.qobject);
     }
     pub fn end_reset_model(&self) {
         (self.end_reset_model)(self.qobject);
     }
     pub fn begin_insert_rows(&self, first: usize, last: usize) {
         (self.begin_insert_rows)(self.qobject, first, last);
     }
     pub fn end_insert_rows(&self) {
         (self.end_insert_rows)(self.qobject);
     }
     pub fn begin_move_rows(&self, first: usize, last: usize, destination: usize) {
         (self.begin_move_rows)(self.qobject, first, last, destination);
     }
     pub fn end_move_rows(&self) {
         (self.end_move_rows)(self.qobject);
     }
     pub fn begin_remove_rows(&self, first: usize, last: usize) {
         (self.begin_remove_rows)(self.qobject, first, last);
     }
     pub fn end_remove_rows(&self) {
         (self.end_remove_rows)(self.qobject);
     }
 }
 
 pub trait TimeSeriesTrait {
     fn new(emit: TimeSeriesEmitter, model: TimeSeriesList) -> Self;
     fn emit(&self) -> &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 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(*const TimeSeriesQObject),
     time_series_layout_about_to_be_changed: fn(*const TimeSeriesQObject),
     time_series_layout_changed: fn(*const TimeSeriesQObject),
     time_series_data_changed: fn(*const TimeSeriesQObject, usize, usize),
     time_series_begin_reset_model: fn(*const TimeSeriesQObject),
     time_series_end_reset_model: fn(*const TimeSeriesQObject),
     time_series_begin_insert_rows: fn(*const TimeSeriesQObject, usize, usize),
     time_series_end_insert_rows: fn(*const TimeSeriesQObject),
     time_series_begin_move_rows: fn(*const TimeSeriesQObject, usize, usize, usize),
     time_series_end_move_rows: fn(*const TimeSeriesQObject),
     time_series_begin_remove_rows: fn(*const TimeSeriesQObject, usize, usize),
     time_series_end_remove_rows: fn(*const TimeSeriesQObject),
 ) -> *mut TimeSeries {
     let time_series_emit = TimeSeriesEmitter {
         qobject: Arc::new(Mutex::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 extern "C" fn time_series_data_cos(ptr: *const TimeSeries, row: c_int) -> f32 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn time_series_data_sin(ptr: *const TimeSeries, row: c_int) -> f32 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn time_series_data_time(ptr: *const TimeSeries, row: c_int) -> f32 {
-    let o = unsafe { &*ptr };
+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.cpp b/src/rust.cpp
index b8237ef..0ba12f7 100644
--- a/src/rust.cpp
+++ b/src/rust.cpp
@@ -1,1117 +1,1116 @@
 /*
  *   Copyright 2017  Jos van den Oever <jos@vandenoever.info>
  *
  *   This program is free software; you can redistribute it and/or
  *   modify it under the terms of the GNU General Public License as
  *   published by the Free Software Foundation; either version 2 of
  *   the License or (at your option) version 3 or any later version
  *   accepted by the membership of KDE e.V. (or its successor approved
  *   by the membership of KDE e.V.), which shall act as a proxy
  *   defined in Section 14 of version 3 of the license.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "structs.h"
 #include "helper.h"
 
 template <typename T>
 QString rustType(const T& p)
 {
     if (p.optional) {
         return "Option<" + p.type.rustType + ">";
     }
     return p.type.rustType;
 }
 
 template <typename T>
 QString rustReturnType(const T& p)
 {
     QString type = p.type.rustType;
     if (type == "String" && !p.rustByValue) {
         type = "str";
     }
     if (type == "Vec<u8>" && !p.rustByValue) {
         type = "[u8]";
     }
     if (p.type.isComplex() && !p.rustByValue) {
         type = "&" + type;
     }
     if (p.optional) {
         return "Option<" + type + ">";
     }
     return type;
 }
 
 template <typename T>
 QString rustCType(const T& p)
 {
     if (p.optional) {
         return "COption<" + p.type.rustType + ">";
     }
     return p.type.rustType;
 }
 
 template <typename T>
 QString rustTypeInit(const T& p)
 {
     if (p.optional) {
         return "None";
     }
     return p.type.rustTypeInit;
 }
 
 void rConstructorArgsDecl(QTextStream& r, const QString& name, const Object& o, const Configuration& conf) {
     r << QString("    %2: *mut %1QObject").arg(o.name, snakeCase(name));
     for (const Property& p: o.properties) {
         if (p.type.type == BindingType::Object) {
             r << QString(",\n");
             rConstructorArgsDecl(r, p.name, conf.findObject(p.type.name), conf);
         } else {
             r << QString(",\n    %3_%2_changed: fn(*const %1QObject)")
                 .arg(o.name, snakeCase(p.name), snakeCase(name));
         }
     }
     if (o.type == ObjectType::List) {
         r << QString(",\n    %2_new_data_ready: fn(*const %1QObject)")
             .arg(o.name, snakeCase(name));
     } else if (o.type == ObjectType::Tree) {
         r << QString(",\n    %2_new_data_ready: fn(*const %1QObject, index: COption<usize>)")
             .arg(o.name, snakeCase(name));
     }
     if (o.type != ObjectType::Object) {
         QString indexDecl;
         if (o.type == ObjectType::Tree) {
             indexDecl = " index: COption<usize>,";
         }
         QString destDecl;
         if (o.type == ObjectType::Tree) {
             destDecl = " index: COption<usize>,";
         }
         r << QString(R"(,
     %3_layout_about_to_be_changed: fn(*const %1QObject),
     %3_layout_changed: fn(*const %1QObject),
     %3_data_changed: fn(*const %1QObject, usize, usize),
     %3_begin_reset_model: fn(*const %1QObject),
     %3_end_reset_model: fn(*const %1QObject),
     %3_begin_insert_rows: fn(*const %1QObject,%2 usize, usize),
     %3_end_insert_rows: fn(*const %1QObject),
     %3_begin_move_rows: fn(*const %1QObject,%2 usize, usize,%4 usize),
     %3_end_move_rows: fn(*const %1QObject),
     %3_begin_remove_rows: fn(*const %1QObject,%2 usize, usize),
     %3_end_remove_rows: fn(*const %1QObject))").arg(o.name, indexDecl,
           snakeCase(name), destDecl);
     }
 }
 
 void rConstructorArgs(QTextStream& r, const QString& name, const Object& o, const Configuration& conf) {
     const QString lcname(snakeCase(o.name));
     for (const Property& p: o.properties) {
         if (p.type.type == BindingType::Object) {
             rConstructorArgs(r, p.name, conf.findObject(p.type.name), conf);
         }
     }
     r << QString(R"(    let %2_emit = %1Emitter {
         qobject: Arc::new(Mutex::new(%2)),
 )").arg(o.name, snakeCase(name));
     for (const Property& p: o.properties) {
         if (p.type.type == BindingType::Object) continue;
         r << QString("        %1_changed: %2_%1_changed,\n").arg(snakeCase(p.name), snakeCase(name));
     }
     if (o.type != ObjectType::Object) {
         r << QString("        new_data_ready: %1_new_data_ready,\n")
             .arg(snakeCase(name));
     }
     QString model = "";
     if (o.type != ObjectType::Object) {
         const QString type = o.type == ObjectType::List ? "List" : "Tree";
         model = ", model";
         r << QString(R"(    };
     let model = %1%2 {
         qobject: %3,
         layout_about_to_be_changed: %4_layout_about_to_be_changed,
         layout_changed: %4_layout_changed,
         data_changed: %4_data_changed,
         begin_reset_model: %4_begin_reset_model,
         end_reset_model: %4_end_reset_model,
         begin_insert_rows: %4_begin_insert_rows,
         end_insert_rows: %4_end_insert_rows,
         begin_move_rows: %4_begin_move_rows,
         end_move_rows: %4_end_move_rows,
         begin_remove_rows: %4_begin_remove_rows,
         end_remove_rows: %4_end_remove_rows,
 )").arg(o.name, type, snakeCase(name), snakeCase(name));
     }
     r << QString("    };\n    let d_%3 = %1::new(%3_emit%2")
          .arg(o.name, model, snakeCase(name));
     for (const Property& p: o.properties) {
         if (p.type.type == BindingType::Object) {
             r << ",\n        d_" << snakeCase(p.name);
         }
     }
     r << ");\n";
 }
 
 void writeFunction(QTextStream& r, const Function& f, const QString& lcname, const Object& o) {
     const QString lc(snakeCase(f.name));
     r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %1_%2(ptr: *%3 %4)").arg(lcname, lc, f.mut ? "mut" : "const", o.name);
+pub unsafe extern "C" fn %1_%2(ptr: *%3 %4)").arg(lcname, lc, f.mut ? "mut" : "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 (auto a = f.args.begin(); a < f.args.end(); a++) {
         r << ", ";
         if (a->type.name == "QString") {
             r << QString("%1_str: *const c_ushort, %1_len: c_int").arg(a->name);
         } else if (a->type.name == "QByteArray") {
             r << QString("%1_str: *const c_char, %1_len: c_int").arg(a->name);
         } else {
             r << a->name << ": " << a->type.rustType;
         }
     }
     // 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.type.isComplex()) {
         r << QString(", d: *mut %1, set: fn(*mut %1, str: *const c_char, len: c_int)) {\n").arg(f.type.name);
     } else {
         r << ") -> " << f.type.rustType << " {\n";
     }
     for (auto a = f.args.begin(); a < f.args.end(); a++) {
         if (a->type.name == "QString") {
             r << "    let mut " << a->name << " = String::new();\n";
             r << QString("    set_string_from_utf16(&mut %1, %1_str, %1_len);\n").arg(a->name);
         } else if (a->type.name == "QByteArray") {
-            r << QString("    let %1 = unsafe { slice::from_raw_parts(%1_str as *const u8, to_usize(%1_len)) };\n").arg(a->name);
+            r << QString("    let %1 = { slice::from_raw_parts(%1_str as *const u8, to_usize(%1_len)) };\n").arg(a->name);
         }
     }
     if (f.mut) {
-        r << "    let o = unsafe { &mut *ptr };\n";
+        r << "    let o = &mut *ptr;\n";
     } else {
-        r << "    let o = unsafe { &*ptr };\n";
+        r << "    let o = &*ptr;\n";
     }
     r << "    let r = o." << lc << "(";
     for (auto a = f.args.begin(); a < f.args.end(); a++) {
         if (a != f.args.begin()) {
             r << ", ";
         }
         r << a->name;
     }
     r << ");\n";
     if (f.type.isComplex()) {
         r << "    let s: *const c_char = r.as_ptr() as (*const c_char);\n";
         r << "    set(d, s, r.len() as i32);\n";
     } else {
         r << "    r\n";
     }
     r << "}\n";
 }
 
 void writeRustInterfaceObject(QTextStream& r, const Object& o, const Configuration& conf) {
     const QString lcname(snakeCase(o.name));
     r << QString(R"(
 pub struct %1QObject {}
 
 #[derive(Clone)]
 pub struct %1Emitter {
     qobject: Arc<Mutex<*const %1QObject>>,
 )").arg(o.name);
     for (const Property& p: o.properties) {
         if (p.type.type == BindingType::Object) {
             continue;
         }
         r << QString("    %2_changed: fn(*const %1QObject),\n")
             .arg(o.name, snakeCase(p.name));
     }
     if (o.type == ObjectType::List) {
         r << QString("    new_data_ready: fn(*const %1QObject),\n")
             .arg(o.name);
     } else if (o.type == ObjectType::Tree) {
         r << QString("    new_data_ready: fn(*const %1QObject, index: COption<usize>),\n")
             .arg(o.name);
     }
     r << QString(R"(}
 
 unsafe impl Send for %1Emitter {}
 
 impl %1Emitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
 )").arg(o.name);
     for (const Property& p: o.properties) {
         if (p.type.type == BindingType::Object) {
             continue;
         }
         r << QString(R"(    pub fn %1_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.%1_changed)(ptr);
         }
     }
 )").arg(snakeCase(p.name));
     }
     if (o.type == ObjectType::List) {
         r << R"(    pub fn new_data_ready(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.new_data_ready)(ptr);
         }
     }
 )";
     } else if (o.type == ObjectType::Tree) {
         r << R"(    pub fn new_data_ready(&self, item: Option<usize>) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.new_data_ready)(ptr, item.into());
         }
     }
 )";
     }
 
     QString modelStruct = "";
     if (o.type != ObjectType::Object) {
         QString type = o.type == ObjectType::List ? "List" : "Tree";
         modelStruct = ", model: " + o.name + type;
         QString index;
         QString indexDecl;
         QString indexCDecl;
         QString dest;
         QString destDecl;
         QString destCDecl;
         if (o.type == ObjectType::Tree) {
             indexDecl = " index: Option<usize>,";
             indexCDecl = " index: COption<usize>,";
             index = " index.into(),";
             destDecl = " dest: Option<usize>,";
             destCDecl = " dest: COption<usize>,";
             dest = " dest.into(),";
         }
         r << QString(R"(}
 
 #[derive(Clone)]
 pub struct %1%2 {
     qobject: *const %1QObject,
     layout_about_to_be_changed: fn(*const %1QObject),
     layout_changed: fn(*const %1QObject),
     data_changed: fn(*const %1QObject, usize, usize),
     begin_reset_model: fn(*const %1QObject),
     end_reset_model: fn(*const %1QObject),
     begin_insert_rows: fn(*const %1QObject,%5 usize, usize),
     end_insert_rows: fn(*const %1QObject),
     begin_move_rows: fn(*const %1QObject,%5 usize, usize,%8 usize),
     end_move_rows: fn(*const %1QObject),
     begin_remove_rows: fn(*const %1QObject,%5 usize, usize),
     end_remove_rows: fn(*const %1QObject),
 }
 
 impl %1%2 {
     pub fn layout_about_to_be_changed(&self) {
         (self.layout_about_to_be_changed)(self.qobject);
     }
     pub fn layout_changed(&self) {
         (self.layout_changed)(self.qobject);
     }
     pub fn data_changed(&self, first: usize, last: usize) {
         (self.data_changed)(self.qobject, first, last);
     }
     pub fn begin_reset_model(&self) {
         (self.begin_reset_model)(self.qobject);
     }
     pub fn end_reset_model(&self) {
         (self.end_reset_model)(self.qobject);
     }
     pub fn begin_insert_rows(&self,%3 first: usize, last: usize) {
         (self.begin_insert_rows)(self.qobject,%4 first, last);
     }
     pub fn end_insert_rows(&self) {
         (self.end_insert_rows)(self.qobject);
     }
     pub fn begin_move_rows(&self,%3 first: usize, last: usize,%6 destination: usize) {
         (self.begin_move_rows)(self.qobject,%4 first, last,%7 destination);
     }
     pub fn end_move_rows(&self) {
         (self.end_move_rows)(self.qobject);
     }
     pub fn begin_remove_rows(&self,%3 first: usize, last: usize) {
         (self.begin_remove_rows)(self.qobject,%4 first, last);
     }
     pub fn end_remove_rows(&self) {
         (self.end_remove_rows)(self.qobject);
     }
 )").arg(o.name, type, indexDecl, index, indexCDecl, destDecl, dest, destCDecl);
     }
 
     r << QString(R"(}
 
 pub trait %1Trait {
     fn new(emit: %1Emitter%2)").arg(o.name, modelStruct);
     for (const Property& p: o.properties) {
         if (p.type.type == BindingType::Object) {
             r << ",\n        " << snakeCase(p.name) << ": " << p.type.name;
         }
     }
     r << QString(R"() -> Self;
     fn emit(&self) -> &%1Emitter;
 )").arg(o.name);
     for (const Property& p: o.properties) {
         const QString lc(snakeCase(p.name));
         if (p.type.type == BindingType::Object) {
             r << QString("    fn %1(&self) -> &%2;\n").arg(lc, rustType(p));
             r << QString("    fn %1_mut(&mut self) -> &mut %2;\n").arg(lc, rustType(p));
         } else {
             if (p.rustByFunction) {
                 r << QString("    fn %1<F>(&self, getter: F) where F: FnOnce(%2);").arg(lc, rustReturnType(p));
             } else {
                 r << QString("    fn %1(&self) -> %2;\n").arg(lc, rustReturnType(p));
             }
             if (p.write) {
                 if (p.type.name == "QByteArray") {
                     if (p.optional) {
                         r << QString("    fn set_%1(&mut self, value: Option<&[u8]>);\n").arg(lc);
                     } else {
                         r << QString("    fn set_%1(&mut self, value: &[u8]);\n").arg(lc);
                     }
                 } else {
                     r << QString("    fn set_%1(&mut self, value: %2);\n").arg(lc, rustType(p));
                 }
             }
         }
     }
     for (const Function& f: o.functions) {
         const QString lc(snakeCase(f.name));
         QString argList;
         if (f.args.size() > 0) {
             for (auto a = f.args.begin(); a < f.args.end(); a++) {
                 auto t = a->type.name == "QByteArray" ?"&[u8]" :a->type.rustType;
                 argList.append(QString(", %1: %2").arg(a->name, t));
             }
         }
         r << QString("    fn %1(&%2self%4) -> %3;\n")
             .arg(lc, f.mut ? "mut " : "", f.type.rustType, argList);
     }
     if (o.type == ObjectType::List) {
         r << 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.type == ObjectType::Tree) {
         r << R"(    fn row_count(&self, Option<usize>) -> usize;
     fn can_fetch_more(&self, Option<usize>) -> bool {
         false
     }
     fn fetch_more(&mut self, Option<usize>) {}
     fn sort(&mut self, u8, SortOrder) {}
     fn check_row(&self, index: usize, row: usize) -> Option<usize>;
     fn index(&self, item: Option<usize>, row: usize) -> usize;
     fn parent(&self, index: usize) -> Option<usize>;
     fn row(&self, index: usize) -> usize;
 )";
     }
     if (o.type != ObjectType::Object) {
         for (auto ip: o.itemProperties) {
             r << QString("    fn %1(&self, index: usize) -> %2;\n")
                     .arg(snakeCase(ip.name), rustReturnType(ip));
             if (ip.write) {
                 if (ip.type.name == "QByteArray") {
                     if (ip.optional) {
                         r << QString("    fn set_%1(&mut self, index: usize, Option<&[u8]>) -> bool;\n")
                             .arg(snakeCase(ip.name));
                     } else {
                         r << QString("    fn set_%1(&mut self, index: usize, &[u8]) -> bool;\n")
                             .arg(snakeCase(ip.name));
                     }
                 } else {
                     r << QString("    fn set_%1(&mut self, index: usize, %2) -> bool;\n")
                         .arg(snakeCase(ip.name), rustType(ip));
                 }
             }
         }
     }
 
     r << QString(R"(}
 
 #[no_mangle]
 pub extern "C" fn %1_new(
 )").arg(lcname);
     rConstructorArgsDecl(r, lcname, o, conf);
     r << QString(",\n) -> *mut %1 {\n").arg(o.name);
     rConstructorArgs(r, lcname, o, conf);
     r << QString(R"(    Box::into_raw(Box::new(d_%2))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn %2_free(ptr: *mut %1) {
     Box::from_raw(ptr).emit().clear();
 }
 )").arg(o.name, lcname);
     for (const Property& p: o.properties) {
         const QString base = QString("%1_%2").arg(lcname, snakeCase(p.name));
         QString ret = ") -> " + rustType(p);
         if (p.type.type == BindingType::Object) {
             r << QString(R"(
 #[no_mangle]
 pub unsafe extern "C" fn %2_get(ptr: *mut %1) -> *mut %4 {
     (&mut *ptr).%3_mut()
 }
 )").arg(o.name, base, snakeCase(p.name), rustType(p));
 
         } else if (p.type.isComplex() && !p.optional) {
             if (p.rustByFunction) {
                 r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %2_get(
+pub unsafe extern "C" fn %2_get(
     ptr: *const %1,
     p: *mut %4,
     set: fn(*mut %4, *const c_char, c_int),
 ) {
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     o.%3(|v| {
         let s: *const c_char = v.as_ptr() as (*const c_char);
         set(p, s, to_c_int(v.len()));
     });
 }
 )").arg(o.name, base, snakeCase(p.name), p.type.name);
             } else {
                 r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %2_get(
+pub unsafe extern "C" fn %2_get(
     ptr: *const %1,
     p: *mut %4,
     set: fn(*mut %4, *const c_char, c_int),
 ) {
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     let v = o.%3();
     let s: *const c_char = v.as_ptr() as (*const c_char);
     set(p, s, to_c_int(v.len()));
 }
 )").arg(o.name, base, snakeCase(p.name), p.type.name);
             }
             if (p.write && p.type.name == "QString") {
                 r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %2_set(ptr: *mut %1, v: *const c_ushort, len: c_int) {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn %2_set(ptr: *mut %1, 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_%3(s);
 }
 )").arg(o.name, base, snakeCase(p.name));
             } else if (p.write) {
                 r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %2_set(ptr: *mut %1, v: *const c_char, len: c_int) {
-    let o = unsafe { &mut *ptr };
-    let v = unsafe { slice::from_raw_parts(v as *const u8, to_usize(len)) };
+pub unsafe extern "C" fn %2_set(ptr: *mut %1, 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_%3(v);
 }
 )").arg(o.name, base, snakeCase(p.name));
             }
         } else if (p.type.isComplex()) {
             r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %2_get(
+pub unsafe extern "C" fn %2_get(
     ptr: *const %1,
     p: *mut %4,
     set: fn(*mut %4, *const c_char, c_int),
 ) {
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     let v = o.%3();
     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()));
     }
 }
 )").arg(o.name, base, snakeCase(p.name), p.type.name);
             if (p.write && p.type.name == "QString") {
                 r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %2_set(ptr: *mut %1, v: *const c_ushort, len: c_int) {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn %2_set(ptr: *mut %1, 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_%3(Some(s));
 }
 )").arg(o.name, base, snakeCase(p.name));
             } else if (p.write) {
                 r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %2_set(ptr: *mut %1, v: *const c_char, len: c_int) {
-    let o = unsafe { &mut *ptr };
-    let v = unsafe { slice::from_raw_parts(v as *const u8, to_usize(len)) };
+pub unsafe extern "C" fn %2_set(ptr: *mut %1, 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_%3(Some(v.into()));
 }
 )").arg(o.name, base, snakeCase(p.name));
             }
         } else if (p.optional) {
             r << QString(R"(
 #[no_mangle]
 pub unsafe extern "C" fn %2_get(ptr: *const %1) -> COption<%4> {
     match (&*ptr).%3() {
         Some(value) => COption { data: value, some: true },
         None => COption { data: %4::default(), some: false}
     }
 }
 )").arg(o.name, base, snakeCase(p.name), p.type.rustType);
             if (p.write) {
                 r << QString(R"(
 #[no_mangle]
 pub unsafe extern "C" fn %2_set(ptr: *mut %1, v: %4) {
     (&mut *ptr).set_%3(Some(v));
 }
 )").arg(o.name, base, snakeCase(p.name), p.type.rustType);
             }
         } else {
             r << QString(R"(
 #[no_mangle]
 pub unsafe extern "C" fn %2_get(ptr: *const %1) -> %4 {
     (&*ptr).%3()
 }
 )").arg(o.name, base, snakeCase(p.name), rustType(p));
             if (p.write) {
                 r << QString(R"(
 #[no_mangle]
 pub unsafe extern "C" fn %2_set(ptr: *mut %1, v: %4) {
     (&mut *ptr).set_%3(v);
 }
 )").arg(o.name, base, snakeCase(p.name), rustType(p));
             }
         }
         if (p.write && p.optional) {
             r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %2_set_none(ptr: *mut %1) {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn %2_set_none(ptr: *mut %1) {
+    let o = &mut *ptr;
     o.set_%3(None);
 }
 )").arg(o.name, base, snakeCase(p.name));
         }
     }
     for (const Function& f: o.functions) {
         writeFunction(r, f, lcname, o);
     }
     if (o.type == ObjectType::List) {
         r << QString(R"(
 #[no_mangle]
 pub unsafe extern "C" fn %2_row_count(ptr: *const %1) -> c_int {
     to_c_int((&*ptr).row_count())
 }
 #[no_mangle]
 pub unsafe extern "C" fn %2_insert_rows(ptr: *mut %1, row: c_int, count: c_int) -> bool {
     (&mut *ptr).insert_rows(to_usize(row), to_usize(count))
 }
 #[no_mangle]
 pub unsafe extern "C" fn %2_remove_rows(ptr: *mut %1, row: c_int, count: c_int) -> bool {
     (&mut *ptr).remove_rows(to_usize(row), to_usize(count))
 }
 #[no_mangle]
 pub unsafe extern "C" fn %2_can_fetch_more(ptr: *const %1) -> bool {
     (&*ptr).can_fetch_more()
 }
 #[no_mangle]
 pub unsafe extern "C" fn %2_fetch_more(ptr: *mut %1) {
     (&mut *ptr).fetch_more()
 }
 #[no_mangle]
 pub unsafe extern "C" fn %2_sort(
     ptr: *mut %1,
     column: u8,
     order: SortOrder,
 ) {
     (&mut *ptr).sort(column, order)
 }
 )").arg(o.name, lcname);
     } else if (o.type == ObjectType::Tree) {
         r << QString(R"(
 #[no_mangle]
 pub unsafe extern "C" fn %2_row_count(
     ptr: *const %1,
     index: COption<usize>,
 ) -> c_int {
     to_c_int((&*ptr).row_count(index.into()))
 }
 #[no_mangle]
 pub unsafe extern "C" fn %2_can_fetch_more(
     ptr: *const %1,
     index: COption<usize>,
 ) -> bool {
     (&*ptr).can_fetch_more(index.into())
 }
 #[no_mangle]
 pub unsafe extern "C" fn %2_fetch_more(ptr: *mut %1, index: COption<usize>) {
     (&mut *ptr).fetch_more(index.into())
 }
 #[no_mangle]
 pub unsafe extern "C" fn %2_sort(
     ptr: *mut %1,
     column: u8,
     order: SortOrder
 ) {
     (&mut *ptr).sort(column, order)
 }
 #[no_mangle]
 pub unsafe extern "C" fn %2_check_row(
     ptr: *const %1,
     index: usize,
     row: c_int,
 ) -> COption<usize> {
     (&*ptr).check_row(index.into(), to_usize(row)).into()
 }
 #[no_mangle]
 pub unsafe extern "C" fn %2_index(
     ptr: *const %1,
     index: COption<usize>,
     row: c_int,
 ) -> usize {
     (&*ptr).index(index.into(), to_usize(row))
 }
 #[no_mangle]
 pub unsafe extern "C" fn %2_parent(ptr: *const %1, 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 %2_row(ptr: *const %1, index: usize) -> c_int {
     to_c_int((&*ptr).row(index))
 }
 )").arg(o.name, lcname);
     }
     if (o.type != ObjectType::Object) {
         QString indexDecl = ", row: c_int";
         QString index = "to_usize(row)";
         if (o.type == ObjectType::Tree) {
             indexDecl = ", index: usize";
             index = "index";
         }
         for (auto ip: o.itemProperties) {
             if (ip.type.isComplex() && !ip.optional) {
                 r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %2_data_%3(
+pub unsafe extern "C" fn %2_data_%3(
     ptr: *const %1%4,
     d: *mut %6,
     set: fn(*mut %6, *const c_char, len: c_int),
 ) {
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     let data = o.%3(%5);
     let s: *const c_char = data.as_ptr() as (*const c_char);
     set(d, s, to_c_int(data.len()));
 }
 )").arg(o.name, lcname, snakeCase(ip.name), indexDecl, index, ip.type.name);
             } else if (ip.type.isComplex()) {
                 r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %2_data_%3(
+pub unsafe extern "C" fn %2_data_%3(
     ptr: *const %1%4,
     d: *mut %6,
     set: fn(*mut %6, *const c_char, len: c_int),
 ) {
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     let data = o.%3(%5);
     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()));
     }
 }
 )").arg(o.name, lcname, snakeCase(ip.name), indexDecl, index, ip.type.name);
             } else {
                 r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %2_data_%3(ptr: *const %1%5) -> %4 {
-    let o = unsafe { &*ptr };
+pub unsafe extern "C" fn %2_data_%3(ptr: *const %1%5) -> %4 {
+    let o = &*ptr;
     o.%3(%6).into()
 }
 )").arg(o.name, lcname, snakeCase(ip.name), rustCType(ip), indexDecl, index);
             }
             if (ip.write) {
                 QString val = "v";
                 if (ip.optional) {
                     val = "Some(" + val + ")";
                 }
                 if (ip.type.name == "QString") {
                     r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %2_set_data_%3(
+pub unsafe extern "C" fn %2_set_data_%3(
     ptr: *mut %1%4,
     s: *const c_ushort, len: c_int,
 ) -> bool {
-    let o = unsafe { &mut *ptr };
+    let o = &mut *ptr;
     let mut v = String::new();
     set_string_from_utf16(&mut v, s, len);
     o.set_%3(%5, %6)
 }
 )").arg(o.name, lcname, snakeCase(ip.name), indexDecl, index, val);
                 } else if (ip.type.name == "QByteArray") {
                     r << QString(R"(
 #[no_mangle]
-pub extern "C" fn %2_set_data_%3(
+pub unsafe extern "C" fn %2_set_data_%3(
     ptr: *mut %1%4,
     s: *const c_char, len: c_int,
 ) -> bool {
-    let o = unsafe { &mut *ptr };
-    let slice = unsafe { ::std::slice::from_raw_parts(s as *const u8, to_usize(len)) };
+    let o = &mut *ptr;
+    let slice = ::std::slice::from_raw_parts(s as *const u8, to_usize(len));
     o.set_%3(%5, %6)
 }
 )").arg(o.name, lcname, snakeCase(ip.name), indexDecl, index, ip.optional ?"Some(slice)" :"slice");
                 } else {
                     const QString type = ip.type.rustType;
                     r << QString(R"(
 #[no_mangle]
 pub unsafe extern "C" fn %2_set_data_%3(
     ptr: *mut %1%4,
     v: %6,
 ) -> bool {
     (&mut *ptr).set_%3(%5, %7)
 }
 )").arg(o.name, lcname, snakeCase(ip.name), indexDecl, index, type, val);
                 }
             }
             if (ip.write && ip.optional) {
                 r << QString(R"(
 #[no_mangle]
 pub unsafe extern "C" fn %2_set_data_%3_none(ptr: *mut %1%4) -> bool {
     (&mut *ptr).set_%3(%5, None)
 }
 )").arg(o.name, lcname, snakeCase(ip.name), indexDecl, index);
             }
         }
     }
 }
 
 QString rustFile(const QDir rustdir, const QString& module) {
     QDir src(rustdir.absoluteFilePath("src"));
     QString modulePath = src.absoluteFilePath(module + "/mod.rs");
     if (QFile::exists(modulePath)) {
         return modulePath;
     }
     return src.absoluteFilePath(module + ".rs");
 }
 
 void writeRustTypes(const Configuration& conf, QTextStream& r) {
     bool hasOption = false;
     bool hasString = false;
     bool hasByteArray = false;
     bool hasListOrTree = false;
 
     for (auto o: conf.objects) {
         hasListOrTree |= o.type != ObjectType::Object;
         for (auto p: o.properties) {
             hasOption |= p.optional;
             hasString |= p.type.type == BindingType::QString;
             hasByteArray |= p.type.type == BindingType::QByteArray;
         }
         for (auto p: o.itemProperties) {
             hasOption |= p.optional;
             hasString |= p.type.type == BindingType::QString;
             hasByteArray |= p.type.type == BindingType::QByteArray;
         }
         for (auto f: o.functions) {
             hasString |= f.type.type == BindingType::QString;
             hasByteArray |= f.type.type == BindingType::QByteArray;
             for (auto a: f.args) {
                 hasString |= a.type.type == BindingType::QString;
                 hasByteArray |= a.type.type == BindingType::QByteArray;
             }
         }
     }
 
     if (hasOption || hasListOrTree) {
         r << R"(
 
 #[repr(C)]
 pub struct COption<T> {
     data: T,
     some: bool,
 }
 
 impl<T> COption<T> {
     #![allow(dead_code)]
     fn into(self) -> Option<T> {
         if self.some {
             Some(self.data)
         } else {
             None
         }
     }
 }
 
 impl<T> From<Option<T>> for COption<T>
 where
     T: Default,
 {
     fn from(t: Option<T>) -> COption<T> {
         if let Some(v) = t {
             COption {
                 data: v,
                 some: true,
             }
         } else {
             COption {
                 data: T::default(),
                 some: false,
             }
         }
     }
 }
 )";
     }
     if (hasString) {
         r << 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())
-        .into_iter()
         .map(|r| r.unwrap());
     s.clear();
     s.extend(characters);
 }
 
 )";
                  }
     if (hasByteArray) {
         r << R"(
 
 pub enum QByteArray {}
 )";
     }
     if (hasListOrTree) {
         r << 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 (hasString || hasByteArray || hasListOrTree) {
         r << R"(
 
 fn to_usize(n: c_int) -> usize {
     if n < 0 {
         panic!("Cannot cast {} to usize", n);
     }
     n as usize
 }
 
 )";
     }
 
     if (hasString || hasByteArray || hasListOrTree) {
         r << 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
 }
 
 )";
     }
 }
 
 void writeRustInterface(const Configuration& conf) {
     DifferentFileWriter w(rustFile(conf.rustdir, conf.interfaceModule));
     QTextStream r(&w.buffer);
     r << QString(R"(/* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
 use libc::{c_char, c_ushort, c_int};
 use std::slice;
 use std::char::decode_utf16;
 
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use %1::*;
 )").arg(conf.implementationModule);
 
     writeRustTypes(conf, r);
 
     for (auto object: conf.objects) {
         writeRustInterfaceObject(r, object, conf);
     }
 }
 
 void writeRustImplementationObject(QTextStream& r, const Object& o) {
     const QString lcname(snakeCase(o.name));
     if (o.type != ObjectType::Object) {
         r << "#[derive(Default, Clone)]\n";
         r << QString("struct %1Item {\n").arg(o.name);
         for (auto ip: o.itemProperties) {
             const QString lc(snakeCase(ip.name));
             r << QString("    %1: %2,\n").arg(lc, ip.type.rustType);
         }
         r << "}\n\n";
     }
     QString modelStruct = "";
     r << QString("pub struct %1 {\n    emit: %1Emitter,\n").arg((o.name));
     if (o.type == ObjectType::List) {
         modelStruct = ", model: " + o.name + "List";
         r << QString("    model: %1List,\n").arg(o.name);
     } else if (o.type == ObjectType::Tree) {
         modelStruct = ", model: " + o.name + "Tree";
         r << QString("    model: %1Tree,\n").arg(o.name);
     }
     for (const Property& p: o.properties) {
         const QString lc(snakeCase(p.name));
         r << QString("    %1: %2,\n").arg(lc, rustType(p));
     }
     if (o.type != ObjectType::Object) {
         r << QString("    list: Vec<%1Item>,\n").arg(o.name);
     }
     r << "}\n\n";
     for (const Property& p: o.properties) {
         if (p.type.type == BindingType::Object) {
             modelStruct += ", " + p.name + ": " + p.type.name;
         }
     }
     r << QString(R"(impl %1Trait for %1 {
     fn new(emit: %1Emitter%2) -> %1 {
         %1 {
             emit: emit,
 )").arg(o.name, modelStruct);
     if (o.type != ObjectType::Object) {
         r << QString("            model: model,\n");
     }
     for (const Property& p: o.properties) {
         const QString lc(snakeCase(p.name));
         if (p.type.type == BindingType::Object) {
             r << QString("            %1: %1,\n").arg(lc);
         } else {
             r << QString("            %1: %2,\n").arg(lc, rustTypeInit(p));
         }
     }
     r << QString(R"(        }
     }
     fn emit(&self) -> &%1Emitter {
         &self.emit
     }
 )").arg(o.name);
     for (const Property& p: o.properties) {
         const QString lc(snakeCase(p.name));
         if (p.type.type == BindingType::Object) {
             r << QString(R"(    fn %1(&self) -> &%2 {
         &self.%1
     }
     fn %1_mut(&mut self) -> &mut %2 {
         &mut self.%1
     }
 )").arg(lc, rustReturnType(p));
         } else {
             r << QString("    fn %1(&self) -> %2 {\n").arg(lc, rustReturnType(p));
             if (p.type.isComplex()) {
                 if (p.optional) {
 /*
                     if (rustType(p) == "Option<String>") {
                         r << QString("        self.%1.as_ref().map(|p|p.as_str())\n").arg(lc);
                     } else {
                     }
 */
                     r << QString("        self.%1.as_ref().map(|p|&p[..])\n").arg(lc);
                 } else {
                     r << QString("        &self.%1\n").arg(lc);
                 }
             } else {
                 r << QString("        self.%1\n").arg(lc);
             }
             r << "    }\n";
             if (p.write) {
                 r << QString(R"(    fn set_%1(&mut self, value: %2) {
         self.%1 = value;
         self.emit.%1_changed();
     }
 )").arg(lc, rustType(p));
             }
         }
     }
     if (o.type == ObjectType::List) {
         r << "    fn row_count(&self) -> usize {\n        self.list.len()\n    }\n";
     } else if (o.type == ObjectType::Tree) {
         r << R"(    fn row_count(&self, item: Option<usize>) -> usize {
         self.list.len()
     }
     fn index(&self, item: Option<usize>, row: usize) -> usize {
         0
     }
     fn parent(&self, index: usize) -> Option<usize> {
         None
     }
     fn row(&self, index: usize) -> usize {
         item
     }
 )";
     }
     if (o.type != ObjectType::Object) {
         QString index;
         if (o.type == ObjectType::Tree) {
             index = ", index: usize";
         }
         for (auto ip: o.itemProperties) {
             const QString lc(snakeCase(ip.name));
             r << QString("    fn %1(&self, index: usize) -> %2 {\n")
                     .arg(lc, rustReturnType(ip));
             if (ip.type.isComplex()) {
                 r << "        &self.list[index]." << lc << "\n";
             } else {
                 r << "        self.list[index]." << lc << "\n";
             }
             r << "    }\n";
             if (ip.write) {
                 r << QString("    fn set_%1(&mut self, index: usize, v: %2) -> bool {\n")
                         .arg(snakeCase(ip.name), rustType(ip));
                 r << "        self.list[index]." << lc << " = v;\n";
                 r << "        true\n";
                 r << "    }\n";
             }
         }
     }
     r << "}\n\n";
 }
 
 void writeRustImplementation(const Configuration& conf) {
     DifferentFileWriter w(rustFile(conf.rustdir, conf.implementationModule),
         conf.overwriteImplementation);
     QTextStream r(&w.buffer);
     r << QString(R"(#![allow(unused_imports)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
 use %1::*;
 
 )").arg(conf.interfaceModule);
 
     for (auto object: conf.objects) {
         writeRustImplementationObject(r, object);
     }
 }
diff --git a/tests/rust_functions/src/interface.rs b/tests/rust_functions/src/interface.rs
index 7b69b5e..cbf8930 100644
--- a/tests/rust_functions/src/interface.rs
+++ b/tests/rust_functions/src/interface.rs
@@ -1,172 +1,171 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
 use libc::{c_char, c_ushort, c_int};
 use std::slice;
 use std::char::decode_utf16;
 
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use implementation::*;
 
 
 pub enum QString {}
 
 fn set_string_from_utf16(s: &mut String, str: *const c_ushort, len: c_int) {
     let utf16 = unsafe { slice::from_raw_parts(str, to_usize(len)) };
     let characters = decode_utf16(utf16.iter().cloned())
-        .into_iter()
         .map(|r| r.unwrap());
     s.clear();
     s.extend(characters);
 }
 
 
 
 pub enum QByteArray {}
 
 
 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 PersonQObject {}
 
 #[derive(Clone)]
 pub struct PersonEmitter {
     qobject: Arc<Mutex<*const PersonQObject>>,
     user_name_changed: fn(*const PersonQObject),
 }
 
 unsafe impl Send for PersonEmitter {}
 
 impl PersonEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
     pub fn user_name_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.user_name_changed)(ptr);
         }
     }
 }
 
 pub trait PersonTrait {
     fn new(emit: PersonEmitter) -> Self;
     fn emit(&self) -> &PersonEmitter;
     fn user_name(&self) -> &str;
     fn set_user_name(&mut self, value: String);
     fn append(&mut self, suffix: String, amount: u32) -> ();
     fn double_name(&mut self) -> ();
     fn greet(&self, name: String) -> String;
     fn quote(&self, prefix: String, suffix: String) -> String;
     fn quote_bytes(&self, prefix: &[u8], suffix: &[u8]) -> Vec<u8>;
     fn vowels_in_name(&self) -> u8;
 }
 
 #[no_mangle]
 pub extern "C" fn person_new(
     person: *mut PersonQObject,
     person_user_name_changed: fn(*const PersonQObject),
 ) -> *mut Person {
     let person_emit = PersonEmitter {
         qobject: Arc::new(Mutex::new(person)),
         user_name_changed: person_user_name_changed,
     };
     let d_person = Person::new(person_emit);
     Box::into_raw(Box::new(d_person))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn person_free(ptr: *mut Person) {
     Box::from_raw(ptr).emit().clear();
 }
 
 #[no_mangle]
-pub extern "C" fn person_user_name_get(
+pub unsafe extern "C" fn person_user_name_get(
     ptr: *const Person,
     p: *mut QString,
     set: fn(*mut QString, *const c_char, c_int),
 ) {
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     let v = o.user_name();
     let s: *const c_char = v.as_ptr() as (*const c_char);
     set(p, s, to_c_int(v.len()));
 }
 
 #[no_mangle]
-pub extern "C" fn person_user_name_set(ptr: *mut Person, v: *const c_ushort, len: c_int) {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn person_user_name_set(ptr: *mut Person, 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_user_name(s);
 }
 
 #[no_mangle]
-pub extern "C" fn person_append(ptr: *mut Person, suffix_str: *const c_ushort, suffix_len: c_int, amount: u32) -> () {
+pub unsafe extern "C" fn person_append(ptr: *mut Person, suffix_str: *const c_ushort, suffix_len: c_int, amount: u32) -> () {
     let mut suffix = String::new();
     set_string_from_utf16(&mut suffix, suffix_str, suffix_len);
-    let o = unsafe { &mut *ptr };
+    let o = &mut *ptr;
     let r = o.append(suffix, amount);
     r
 }
 
 #[no_mangle]
-pub extern "C" fn person_double_name(ptr: *mut Person) -> () {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn person_double_name(ptr: *mut Person) -> () {
+    let o = &mut *ptr;
     let r = o.double_name();
     r
 }
 
 #[no_mangle]
-pub extern "C" fn person_greet(ptr: *const Person, name_str: *const c_ushort, name_len: c_int, d: *mut QString, set: fn(*mut QString, str: *const c_char, len: c_int)) {
+pub unsafe extern "C" fn person_greet(ptr: *const Person, name_str: *const c_ushort, name_len: c_int, d: *mut QString, set: fn(*mut QString, str: *const c_char, len: c_int)) {
     let mut name = String::new();
     set_string_from_utf16(&mut name, name_str, name_len);
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     let r = o.greet(name);
     let s: *const c_char = r.as_ptr() as (*const c_char);
     set(d, s, r.len() as i32);
 }
 
 #[no_mangle]
-pub extern "C" fn person_quote(ptr: *const Person, prefix_str: *const c_ushort, prefix_len: c_int, suffix_str: *const c_ushort, suffix_len: c_int, d: *mut QString, set: fn(*mut QString, str: *const c_char, len: c_int)) {
+pub unsafe extern "C" fn person_quote(ptr: *const Person, prefix_str: *const c_ushort, prefix_len: c_int, suffix_str: *const c_ushort, suffix_len: c_int, d: *mut QString, set: fn(*mut QString, str: *const c_char, len: c_int)) {
     let mut prefix = String::new();
     set_string_from_utf16(&mut prefix, prefix_str, prefix_len);
     let mut suffix = String::new();
     set_string_from_utf16(&mut suffix, suffix_str, suffix_len);
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     let r = o.quote(prefix, suffix);
     let s: *const c_char = r.as_ptr() as (*const c_char);
     set(d, s, r.len() as i32);
 }
 
 #[no_mangle]
-pub extern "C" fn person_quote_bytes(ptr: *const Person, prefix_str: *const c_char, prefix_len: c_int, suffix_str: *const c_char, suffix_len: c_int, d: *mut QByteArray, set: fn(*mut QByteArray, str: *const c_char, len: c_int)) {
-    let prefix = unsafe { slice::from_raw_parts(prefix_str as *const u8, to_usize(prefix_len)) };
-    let suffix = unsafe { slice::from_raw_parts(suffix_str as *const u8, to_usize(suffix_len)) };
-    let o = unsafe { &*ptr };
+pub unsafe extern "C" fn person_quote_bytes(ptr: *const Person, prefix_str: *const c_char, prefix_len: c_int, suffix_str: *const c_char, suffix_len: c_int, d: *mut QByteArray, set: fn(*mut QByteArray, str: *const c_char, len: c_int)) {
+    let prefix = { slice::from_raw_parts(prefix_str as *const u8, to_usize(prefix_len)) };
+    let suffix = { slice::from_raw_parts(suffix_str as *const u8, to_usize(suffix_len)) };
+    let o = &*ptr;
     let r = o.quote_bytes(prefix, suffix);
     let s: *const c_char = r.as_ptr() as (*const c_char);
     set(d, s, r.len() as i32);
 }
 
 #[no_mangle]
-pub extern "C" fn person_vowels_in_name(ptr: *const Person) -> u8 {
-    let o = unsafe { &*ptr };
+pub unsafe extern "C" fn person_vowels_in_name(ptr: *const Person) -> u8 {
+    let o = &*ptr;
     let r = o.vowels_in_name();
     r
 }
diff --git a/tests/rust_list/src/interface.rs b/tests/rust_list/src/interface.rs
index 411cf6f..c97e3e5 100644
--- a/tests/rust_list/src/interface.rs
+++ b/tests/rust_list/src/interface.rs
@@ -1,476 +1,475 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
 use libc::{c_char, c_ushort, c_int};
 use std::slice;
 use std::char::decode_utf16;
 
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use implementation::*;
 
 
 #[repr(C)]
 pub struct COption<T> {
     data: T,
     some: bool,
 }
 
 impl<T> COption<T> {
     #![allow(dead_code)]
     fn into(self) -> Option<T> {
         if self.some {
             Some(self.data)
         } else {
             None
         }
     }
 }
 
 impl<T> From<Option<T>> for COption<T>
 where
     T: Default,
 {
     fn from(t: Option<T>) -> COption<T> {
         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())
-        .into_iter()
         .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 {}
 
 #[derive(Clone)]
 pub struct NoRoleEmitter {
     qobject: Arc<Mutex<*const NoRoleQObject>>,
     new_data_ready: fn(*const NoRoleQObject),
 }
 
 unsafe impl Send for NoRoleEmitter {}
 
 impl NoRoleEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
     pub fn new_data_ready(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.new_data_ready)(ptr);
         }
     }
 }
 
 #[derive(Clone)]
 pub struct NoRoleList {
     qobject: *const NoRoleQObject,
     layout_about_to_be_changed: fn(*const NoRoleQObject),
     layout_changed: fn(*const NoRoleQObject),
     data_changed: fn(*const NoRoleQObject, usize, usize),
     begin_reset_model: fn(*const NoRoleQObject),
     end_reset_model: fn(*const NoRoleQObject),
     begin_insert_rows: fn(*const NoRoleQObject, usize, usize),
     end_insert_rows: fn(*const NoRoleQObject),
     begin_move_rows: fn(*const NoRoleQObject, usize, usize, usize),
     end_move_rows: fn(*const NoRoleQObject),
     begin_remove_rows: fn(*const NoRoleQObject, usize, usize),
     end_remove_rows: fn(*const NoRoleQObject),
 }
 
 impl NoRoleList {
     pub fn layout_about_to_be_changed(&self) {
         (self.layout_about_to_be_changed)(self.qobject);
     }
     pub fn layout_changed(&self) {
         (self.layout_changed)(self.qobject);
     }
     pub fn data_changed(&self, first: usize, last: usize) {
         (self.data_changed)(self.qobject, first, last);
     }
     pub fn begin_reset_model(&self) {
         (self.begin_reset_model)(self.qobject);
     }
     pub fn end_reset_model(&self) {
         (self.end_reset_model)(self.qobject);
     }
     pub fn begin_insert_rows(&self, first: usize, last: usize) {
         (self.begin_insert_rows)(self.qobject, first, last);
     }
     pub fn end_insert_rows(&self) {
         (self.end_insert_rows)(self.qobject);
     }
     pub fn begin_move_rows(&self, first: usize, last: usize, destination: usize) {
         (self.begin_move_rows)(self.qobject, first, last, destination);
     }
     pub fn end_move_rows(&self) {
         (self.end_move_rows)(self.qobject);
     }
     pub fn begin_remove_rows(&self, first: usize, last: usize) {
         (self.begin_remove_rows)(self.qobject, first, last);
     }
     pub fn end_remove_rows(&self) {
         (self.end_remove_rows)(self.qobject);
     }
 }
 
 pub trait NoRoleTrait {
     fn new(emit: NoRoleEmitter, model: NoRoleList) -> Self;
     fn emit(&self) -> &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 user_age(&self, index: usize) -> u8;
     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;
 }
 
 #[no_mangle]
 pub extern "C" fn no_role_new(
     no_role: *mut NoRoleQObject,
     no_role_new_data_ready: fn(*const NoRoleQObject),
     no_role_layout_about_to_be_changed: fn(*const NoRoleQObject),
     no_role_layout_changed: fn(*const NoRoleQObject),
     no_role_data_changed: fn(*const NoRoleQObject, usize, usize),
     no_role_begin_reset_model: fn(*const NoRoleQObject),
     no_role_end_reset_model: fn(*const NoRoleQObject),
     no_role_begin_insert_rows: fn(*const NoRoleQObject, usize, usize),
     no_role_end_insert_rows: fn(*const NoRoleQObject),
     no_role_begin_move_rows: fn(*const NoRoleQObject, usize, usize, usize),
     no_role_end_move_rows: fn(*const NoRoleQObject),
     no_role_begin_remove_rows: fn(*const NoRoleQObject, usize, usize),
     no_role_end_remove_rows: fn(*const NoRoleQObject),
 ) -> *mut NoRole {
     let no_role_emit = NoRoleEmitter {
         qobject: Arc::new(Mutex::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 extern "C" fn no_role_data_user_age(ptr: *const NoRole, row: c_int) -> u8 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn no_role_data_user_name(
+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 = unsafe { &*ptr };
+    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 extern "C" fn no_role_set_data_user_name(
+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 = unsafe { &mut *ptr };
+    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 {}
 
 #[derive(Clone)]
 pub struct PersonsEmitter {
     qobject: Arc<Mutex<*const PersonsQObject>>,
     new_data_ready: fn(*const PersonsQObject),
 }
 
 unsafe impl Send for PersonsEmitter {}
 
 impl PersonsEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
     pub fn new_data_ready(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.new_data_ready)(ptr);
         }
     }
 }
 
 #[derive(Clone)]
 pub struct PersonsList {
     qobject: *const PersonsQObject,
     layout_about_to_be_changed: fn(*const PersonsQObject),
     layout_changed: fn(*const PersonsQObject),
     data_changed: fn(*const PersonsQObject, usize, usize),
     begin_reset_model: fn(*const PersonsQObject),
     end_reset_model: fn(*const PersonsQObject),
     begin_insert_rows: fn(*const PersonsQObject, usize, usize),
     end_insert_rows: fn(*const PersonsQObject),
     begin_move_rows: fn(*const PersonsQObject, usize, usize, usize),
     end_move_rows: fn(*const PersonsQObject),
     begin_remove_rows: fn(*const PersonsQObject, usize, usize),
     end_remove_rows: fn(*const PersonsQObject),
 }
 
 impl PersonsList {
     pub fn layout_about_to_be_changed(&self) {
         (self.layout_about_to_be_changed)(self.qobject);
     }
     pub fn layout_changed(&self) {
         (self.layout_changed)(self.qobject);
     }
     pub fn data_changed(&self, first: usize, last: usize) {
         (self.data_changed)(self.qobject, first, last);
     }
     pub fn begin_reset_model(&self) {
         (self.begin_reset_model)(self.qobject);
     }
     pub fn end_reset_model(&self) {
         (self.end_reset_model)(self.qobject);
     }
     pub fn begin_insert_rows(&self, first: usize, last: usize) {
         (self.begin_insert_rows)(self.qobject, first, last);
     }
     pub fn end_insert_rows(&self) {
         (self.end_insert_rows)(self.qobject);
     }
     pub fn begin_move_rows(&self, first: usize, last: usize, destination: usize) {
         (self.begin_move_rows)(self.qobject, first, last, destination);
     }
     pub fn end_move_rows(&self) {
         (self.end_move_rows)(self.qobject);
     }
     pub fn begin_remove_rows(&self, first: usize, last: usize) {
         (self.begin_remove_rows)(self.qobject, first, last);
     }
     pub fn end_remove_rows(&self) {
         (self.end_remove_rows)(self.qobject);
     }
 }
 
 pub trait PersonsTrait {
     fn new(emit: PersonsEmitter, model: PersonsList) -> Self;
     fn emit(&self) -> &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 user_name(&self, index: usize) -> &str;
     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(*const PersonsQObject),
     persons_layout_about_to_be_changed: fn(*const PersonsQObject),
     persons_layout_changed: fn(*const PersonsQObject),
     persons_data_changed: fn(*const PersonsQObject, usize, usize),
     persons_begin_reset_model: fn(*const PersonsQObject),
     persons_end_reset_model: fn(*const PersonsQObject),
     persons_begin_insert_rows: fn(*const PersonsQObject, usize, usize),
     persons_end_insert_rows: fn(*const PersonsQObject),
     persons_begin_move_rows: fn(*const PersonsQObject, usize, usize, usize),
     persons_end_move_rows: fn(*const PersonsQObject),
     persons_begin_remove_rows: fn(*const PersonsQObject, usize, usize),
     persons_end_remove_rows: fn(*const PersonsQObject),
 ) -> *mut Persons {
     let persons_emit = PersonsEmitter {
         qobject: Arc::new(Mutex::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 extern "C" fn persons_data_user_name(
+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 = unsafe { &*ptr };
+    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 extern "C" fn persons_set_data_user_name(
+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 = unsafe { &mut *ptr };
+    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 38b1235..cd2bef1 100644
--- a/tests/rust_list_types/src/interface.rs
+++ b/tests/rust_list_types/src/interface.rs
@@ -1,563 +1,562 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
 use libc::{c_char, c_ushort, c_int};
 use std::slice;
 use std::char::decode_utf16;
 
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use implementation::*;
 
 
 #[repr(C)]
 pub struct COption<T> {
     data: T,
     some: bool,
 }
 
 impl<T> COption<T> {
     #![allow(dead_code)]
     fn into(self) -> Option<T> {
         if self.some {
             Some(self.data)
         } else {
             None
         }
     }
 }
 
 impl<T> From<Option<T>> for COption<T>
 where
     T: Default,
 {
     fn from(t: Option<T>) -> COption<T> {
         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())
-        .into_iter()
         .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 {}
 
 #[derive(Clone)]
 pub struct ListEmitter {
     qobject: Arc<Mutex<*const ListQObject>>,
     new_data_ready: fn(*const ListQObject),
 }
 
 unsafe impl Send for ListEmitter {}
 
 impl ListEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
     pub fn new_data_ready(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.new_data_ready)(ptr);
         }
     }
 }
 
 #[derive(Clone)]
 pub struct ListList {
     qobject: *const ListQObject,
     layout_about_to_be_changed: fn(*const ListQObject),
     layout_changed: fn(*const ListQObject),
     data_changed: fn(*const ListQObject, usize, usize),
     begin_reset_model: fn(*const ListQObject),
     end_reset_model: fn(*const ListQObject),
     begin_insert_rows: fn(*const ListQObject, usize, usize),
     end_insert_rows: fn(*const ListQObject),
     begin_move_rows: fn(*const ListQObject, usize, usize, usize),
     end_move_rows: fn(*const ListQObject),
     begin_remove_rows: fn(*const ListQObject, usize, usize),
     end_remove_rows: fn(*const ListQObject),
 }
 
 impl ListList {
     pub fn layout_about_to_be_changed(&self) {
         (self.layout_about_to_be_changed)(self.qobject);
     }
     pub fn layout_changed(&self) {
         (self.layout_changed)(self.qobject);
     }
     pub fn data_changed(&self, first: usize, last: usize) {
         (self.data_changed)(self.qobject, first, last);
     }
     pub fn begin_reset_model(&self) {
         (self.begin_reset_model)(self.qobject);
     }
     pub fn end_reset_model(&self) {
         (self.end_reset_model)(self.qobject);
     }
     pub fn begin_insert_rows(&self, first: usize, last: usize) {
         (self.begin_insert_rows)(self.qobject, first, last);
     }
     pub fn end_insert_rows(&self) {
         (self.end_insert_rows)(self.qobject);
     }
     pub fn begin_move_rows(&self, first: usize, last: usize, destination: usize) {
         (self.begin_move_rows)(self.qobject, first, last, destination);
     }
     pub fn end_move_rows(&self) {
         (self.end_move_rows)(self.qobject);
     }
     pub fn begin_remove_rows(&self, first: usize, last: usize) {
         (self.begin_remove_rows)(self.qobject, first, last);
     }
     pub fn end_remove_rows(&self) {
         (self.end_remove_rows)(self.qobject);
     }
 }
 
 pub trait ListTrait {
     fn new(emit: ListEmitter, model: ListList) -> Self;
     fn emit(&self) -> &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 boolean(&self, index: usize) -> 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 f32(&self, index: usize) -> f32;
     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 i16(&self, index: usize) -> i16;
     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 i64(&self, index: usize) -> i64;
     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 optional_boolean(&self, index: usize) -> Option<bool>;
     fn set_optional_boolean(&mut self, index: usize, Option<bool>) -> bool;
     fn optional_bytearray(&self, index: usize) -> Option<&[u8]>;
     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<String>) -> bool;
     fn string(&self, index: usize) -> &str;
     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 u32(&self, index: usize) -> u32;
     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 u8(&self, index: usize) -> u8;
     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(*const ListQObject),
     list_layout_about_to_be_changed: fn(*const ListQObject),
     list_layout_changed: fn(*const ListQObject),
     list_data_changed: fn(*const ListQObject, usize, usize),
     list_begin_reset_model: fn(*const ListQObject),
     list_end_reset_model: fn(*const ListQObject),
     list_begin_insert_rows: fn(*const ListQObject, usize, usize),
     list_end_insert_rows: fn(*const ListQObject),
     list_begin_move_rows: fn(*const ListQObject, usize, usize, usize),
     list_end_move_rows: fn(*const ListQObject),
     list_begin_remove_rows: fn(*const ListQObject, usize, usize),
     list_end_remove_rows: fn(*const ListQObject),
 ) -> *mut List {
     let list_emit = ListEmitter {
         qobject: Arc::new(Mutex::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 extern "C" fn list_data_boolean(ptr: *const List, row: c_int) -> bool {
-    let o = unsafe { &*ptr };
+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 extern "C" fn list_data_bytearray(
+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 = unsafe { &*ptr };
+    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 extern "C" fn list_set_data_bytearray(
+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 = unsafe { &mut *ptr };
-    let slice = unsafe { ::std::slice::from_raw_parts(s as *const u8, to_usize(len)) };
+    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 extern "C" fn list_data_f32(ptr: *const List, row: c_int) -> f32 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn list_data_f64(ptr: *const List, row: c_int) -> f64 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn list_data_i16(ptr: *const List, row: c_int) -> i16 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn list_data_i32(ptr: *const List, row: c_int) -> i32 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn list_data_i64(ptr: *const List, row: c_int) -> i64 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn list_data_i8(ptr: *const List, row: c_int) -> i8 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn list_data_optional_boolean(ptr: *const List, row: c_int) -> COption<bool> {
-    let o = unsafe { &*ptr };
+pub unsafe extern "C" fn list_data_optional_boolean(ptr: *const List, row: c_int) -> COption<bool> {
+    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 extern "C" fn list_data_optional_bytearray(
+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 = unsafe { &*ptr };
+    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 extern "C" fn list_set_data_optional_bytearray(
+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 = unsafe { &mut *ptr };
-    let slice = unsafe { ::std::slice::from_raw_parts(s as *const u8, to_usize(len)) };
+    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 extern "C" fn list_data_optional_string(
+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 = unsafe { &*ptr };
+    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 extern "C" fn list_set_data_optional_string(
+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 = unsafe { &mut *ptr };
+    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 extern "C" fn list_data_string(
+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 = unsafe { &*ptr };
+    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 extern "C" fn list_set_data_string(
+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 = unsafe { &mut *ptr };
+    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 extern "C" fn list_data_u16(ptr: *const List, row: c_int) -> u16 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn list_data_u32(ptr: *const List, row: c_int) -> u32 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn list_data_u64(ptr: *const List, row: c_int) -> u64 {
-    let o = unsafe { &*ptr };
+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 extern "C" fn list_data_u8(ptr: *const List, row: c_int) -> u8 {
-    let o = unsafe { &*ptr };
+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_object/src/interface.rs b/tests/rust_object/src/interface.rs
index f8fedeb..150166d 100644
--- a/tests/rust_object/src/interface.rs
+++ b/tests/rust_object/src/interface.rs
@@ -1,108 +1,107 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
 use libc::{c_char, c_ushort, c_int};
 use std::slice;
 use std::char::decode_utf16;
 
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use implementation::*;
 
 
 pub enum QString {}
 
 fn set_string_from_utf16(s: &mut String, str: *const c_ushort, len: c_int) {
     let utf16 = unsafe { slice::from_raw_parts(str, to_usize(len)) };
     let characters = decode_utf16(utf16.iter().cloned())
-        .into_iter()
         .map(|r| r.unwrap());
     s.clear();
     s.extend(characters);
 }
 
 
 
 fn to_usize(n: c_int) -> usize {
     if n < 0 {
         panic!("Cannot cast {} to usize", n);
     }
     n as usize
 }
 
 
 fn to_c_int(n: usize) -> c_int {
     if n > c_int::max_value() as usize {
         panic!("Cannot cast {} to c_int", n);
     }
     n as c_int
 }
 
 
 pub struct PersonQObject {}
 
 #[derive(Clone)]
 pub struct PersonEmitter {
     qobject: Arc<Mutex<*const PersonQObject>>,
     user_name_changed: fn(*const PersonQObject),
 }
 
 unsafe impl Send for PersonEmitter {}
 
 impl PersonEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
     pub fn user_name_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.user_name_changed)(ptr);
         }
     }
 }
 
 pub trait PersonTrait {
     fn new(emit: PersonEmitter) -> Self;
     fn emit(&self) -> &PersonEmitter;
     fn user_name(&self) -> &str;
     fn set_user_name(&mut self, value: String);
 }
 
 #[no_mangle]
 pub extern "C" fn person_new(
     person: *mut PersonQObject,
     person_user_name_changed: fn(*const PersonQObject),
 ) -> *mut Person {
     let person_emit = PersonEmitter {
         qobject: Arc::new(Mutex::new(person)),
         user_name_changed: person_user_name_changed,
     };
     let d_person = Person::new(person_emit);
     Box::into_raw(Box::new(d_person))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn person_free(ptr: *mut Person) {
     Box::from_raw(ptr).emit().clear();
 }
 
 #[no_mangle]
-pub extern "C" fn person_user_name_get(
+pub unsafe extern "C" fn person_user_name_get(
     ptr: *const Person,
     p: *mut QString,
     set: fn(*mut QString, *const c_char, c_int),
 ) {
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     let v = o.user_name();
     let s: *const c_char = v.as_ptr() as (*const c_char);
     set(p, s, to_c_int(v.len()));
 }
 
 #[no_mangle]
-pub extern "C" fn person_user_name_set(ptr: *mut Person, v: *const c_ushort, len: c_int) {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn person_user_name_set(ptr: *mut Person, 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_user_name(s);
 }
diff --git a/tests/rust_object_types/src/interface.rs b/tests/rust_object_types/src/interface.rs
index a03e872..b2629bd 100644
--- a/tests/rust_object_types/src/interface.rs
+++ b/tests/rust_object_types/src/interface.rs
@@ -1,577 +1,576 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
 use libc::{c_char, c_ushort, c_int};
 use std::slice;
 use std::char::decode_utf16;
 
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use implementation::*;
 
 
 #[repr(C)]
 pub struct COption<T> {
     data: T,
     some: bool,
 }
 
 impl<T> COption<T> {
     #![allow(dead_code)]
     fn into(self) -> Option<T> {
         if self.some {
             Some(self.data)
         } else {
             None
         }
     }
 }
 
 impl<T> From<Option<T>> for COption<T>
 where
     T: Default,
 {
     fn from(t: Option<T>) -> COption<T> {
         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())
-        .into_iter()
         .map(|r| r.unwrap());
     s.clear();
     s.extend(characters);
 }
 
 
 
 pub enum QByteArray {}
 
 
 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 ObjectQObject {}
 
 #[derive(Clone)]
 pub struct ObjectEmitter {
     qobject: Arc<Mutex<*const ObjectQObject>>,
     boolean_changed: fn(*const ObjectQObject),
     bytearray_changed: fn(*const ObjectQObject),
     f32_changed: fn(*const ObjectQObject),
     f64_changed: fn(*const ObjectQObject),
     i16_changed: fn(*const ObjectQObject),
     i32_changed: fn(*const ObjectQObject),
     i64_changed: fn(*const ObjectQObject),
     i8_changed: fn(*const ObjectQObject),
     optional_boolean_changed: fn(*const ObjectQObject),
     optional_bytearray_changed: fn(*const ObjectQObject),
     optional_string_changed: fn(*const ObjectQObject),
     optional_u64_changed: fn(*const ObjectQObject),
     string_changed: fn(*const ObjectQObject),
     string_by_function_changed: fn(*const ObjectQObject),
     u16_changed: fn(*const ObjectQObject),
     u32_changed: fn(*const ObjectQObject),
     u64_changed: fn(*const ObjectQObject),
     u8_changed: fn(*const ObjectQObject),
 }
 
 unsafe impl Send for ObjectEmitter {}
 
 impl ObjectEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
     pub fn boolean_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.boolean_changed)(ptr);
         }
     }
     pub fn bytearray_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.bytearray_changed)(ptr);
         }
     }
     pub fn f32_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.f32_changed)(ptr);
         }
     }
     pub fn f64_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.f64_changed)(ptr);
         }
     }
     pub fn i16_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.i16_changed)(ptr);
         }
     }
     pub fn i32_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.i32_changed)(ptr);
         }
     }
     pub fn i64_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.i64_changed)(ptr);
         }
     }
     pub fn i8_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.i8_changed)(ptr);
         }
     }
     pub fn optional_boolean_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.optional_boolean_changed)(ptr);
         }
     }
     pub fn optional_bytearray_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.optional_bytearray_changed)(ptr);
         }
     }
     pub fn optional_string_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.optional_string_changed)(ptr);
         }
     }
     pub fn optional_u64_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.optional_u64_changed)(ptr);
         }
     }
     pub fn string_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.string_changed)(ptr);
         }
     }
     pub fn string_by_function_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.string_by_function_changed)(ptr);
         }
     }
     pub fn u16_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.u16_changed)(ptr);
         }
     }
     pub fn u32_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.u32_changed)(ptr);
         }
     }
     pub fn u64_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.u64_changed)(ptr);
         }
     }
     pub fn u8_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.u8_changed)(ptr);
         }
     }
 }
 
 pub trait ObjectTrait {
     fn new(emit: ObjectEmitter) -> Self;
     fn emit(&self) -> &ObjectEmitter;
     fn boolean(&self) -> bool;
     fn set_boolean(&mut self, value: bool);
     fn bytearray(&self) -> &[u8];
     fn set_bytearray(&mut self, value: &[u8]);
     fn f32(&self) -> f32;
     fn set_f32(&mut self, value: f32);
     fn f64(&self) -> f64;
     fn set_f64(&mut self, value: f64);
     fn i16(&self) -> i16;
     fn set_i16(&mut self, value: i16);
     fn i32(&self) -> i32;
     fn set_i32(&mut self, value: i32);
     fn i64(&self) -> i64;
     fn set_i64(&mut self, value: i64);
     fn i8(&self) -> i8;
     fn set_i8(&mut self, value: i8);
     fn optional_boolean(&self) -> Option<bool>;
     fn set_optional_boolean(&mut self, value: Option<bool>);
     fn optional_bytearray(&self) -> Option<&[u8]>;
     fn set_optional_bytearray(&mut self, value: Option<&[u8]>);
     fn optional_string(&self) -> Option<&str>;
     fn set_optional_string(&mut self, value: Option<String>);
     fn optional_u64(&self) -> Option<u64>;
     fn set_optional_u64(&mut self, value: Option<u64>);
     fn string(&self) -> &str;
     fn set_string(&mut self, value: String);
     fn string_by_function<F>(&self, getter: F) where F: FnOnce(&str);    fn set_string_by_function(&mut self, value: String);
     fn u16(&self) -> u16;
     fn set_u16(&mut self, value: u16);
     fn u32(&self) -> u32;
     fn set_u32(&mut self, value: u32);
     fn u64(&self) -> u64;
     fn set_u64(&mut self, value: u64);
     fn u8(&self) -> u8;
     fn set_u8(&mut self, value: u8);
 }
 
 #[no_mangle]
 pub extern "C" fn object_new(
     object: *mut ObjectQObject,
     object_boolean_changed: fn(*const ObjectQObject),
     object_bytearray_changed: fn(*const ObjectQObject),
     object_f32_changed: fn(*const ObjectQObject),
     object_f64_changed: fn(*const ObjectQObject),
     object_i16_changed: fn(*const ObjectQObject),
     object_i32_changed: fn(*const ObjectQObject),
     object_i64_changed: fn(*const ObjectQObject),
     object_i8_changed: fn(*const ObjectQObject),
     object_optional_boolean_changed: fn(*const ObjectQObject),
     object_optional_bytearray_changed: fn(*const ObjectQObject),
     object_optional_string_changed: fn(*const ObjectQObject),
     object_optional_u64_changed: fn(*const ObjectQObject),
     object_string_changed: fn(*const ObjectQObject),
     object_string_by_function_changed: fn(*const ObjectQObject),
     object_u16_changed: fn(*const ObjectQObject),
     object_u32_changed: fn(*const ObjectQObject),
     object_u64_changed: fn(*const ObjectQObject),
     object_u8_changed: fn(*const ObjectQObject),
 ) -> *mut Object {
     let object_emit = ObjectEmitter {
         qobject: Arc::new(Mutex::new(object)),
         boolean_changed: object_boolean_changed,
         bytearray_changed: object_bytearray_changed,
         f32_changed: object_f32_changed,
         f64_changed: object_f64_changed,
         i16_changed: object_i16_changed,
         i32_changed: object_i32_changed,
         i64_changed: object_i64_changed,
         i8_changed: object_i8_changed,
         optional_boolean_changed: object_optional_boolean_changed,
         optional_bytearray_changed: object_optional_bytearray_changed,
         optional_string_changed: object_optional_string_changed,
         optional_u64_changed: object_optional_u64_changed,
         string_changed: object_string_changed,
         string_by_function_changed: object_string_by_function_changed,
         u16_changed: object_u16_changed,
         u32_changed: object_u32_changed,
         u64_changed: object_u64_changed,
         u8_changed: object_u8_changed,
     };
     let d_object = Object::new(object_emit);
     Box::into_raw(Box::new(d_object))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_free(ptr: *mut Object) {
     Box::from_raw(ptr).emit().clear();
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_boolean_get(ptr: *const Object) -> bool {
     (&*ptr).boolean()
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_boolean_set(ptr: *mut Object, v: bool) {
     (&mut *ptr).set_boolean(v);
 }
 
 #[no_mangle]
-pub extern "C" fn object_bytearray_get(
+pub unsafe extern "C" fn object_bytearray_get(
     ptr: *const Object,
     p: *mut QByteArray,
     set: fn(*mut QByteArray, *const c_char, c_int),
 ) {
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     let v = o.bytearray();
     let s: *const c_char = v.as_ptr() as (*const c_char);
     set(p, s, to_c_int(v.len()));
 }
 
 #[no_mangle]
-pub extern "C" fn object_bytearray_set(ptr: *mut Object, v: *const c_char, len: c_int) {
-    let o = unsafe { &mut *ptr };
-    let v = unsafe { slice::from_raw_parts(v as *const u8, to_usize(len)) };
+pub unsafe extern "C" fn object_bytearray_set(ptr: *mut Object, 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_bytearray(v);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_f32_get(ptr: *const Object) -> f32 {
     (&*ptr).f32()
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_f32_set(ptr: *mut Object, v: f32) {
     (&mut *ptr).set_f32(v);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_f64_get(ptr: *const Object) -> f64 {
     (&*ptr).f64()
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_f64_set(ptr: *mut Object, v: f64) {
     (&mut *ptr).set_f64(v);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_i16_get(ptr: *const Object) -> i16 {
     (&*ptr).i16()
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_i16_set(ptr: *mut Object, v: i16) {
     (&mut *ptr).set_i16(v);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_i32_get(ptr: *const Object) -> i32 {
     (&*ptr).i32()
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_i32_set(ptr: *mut Object, v: i32) {
     (&mut *ptr).set_i32(v);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_i64_get(ptr: *const Object) -> i64 {
     (&*ptr).i64()
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_i64_set(ptr: *mut Object, v: i64) {
     (&mut *ptr).set_i64(v);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_i8_get(ptr: *const Object) -> i8 {
     (&*ptr).i8()
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_i8_set(ptr: *mut Object, v: i8) {
     (&mut *ptr).set_i8(v);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_optional_boolean_get(ptr: *const Object) -> COption<bool> {
     match (&*ptr).optional_boolean() {
         Some(value) => COption { data: value, some: true },
         None => COption { data: bool::default(), some: false}
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_optional_boolean_set(ptr: *mut Object, v: bool) {
     (&mut *ptr).set_optional_boolean(Some(v));
 }
 
 #[no_mangle]
-pub extern "C" fn object_optional_boolean_set_none(ptr: *mut Object) {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn object_optional_boolean_set_none(ptr: *mut Object) {
+    let o = &mut *ptr;
     o.set_optional_boolean(None);
 }
 
 #[no_mangle]
-pub extern "C" fn object_optional_bytearray_get(
+pub unsafe extern "C" fn object_optional_bytearray_get(
     ptr: *const Object,
     p: *mut QByteArray,
     set: fn(*mut QByteArray, *const c_char, c_int),
 ) {
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     let v = o.optional_bytearray();
     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 extern "C" fn object_optional_bytearray_set(ptr: *mut Object, v: *const c_char, len: c_int) {
-    let o = unsafe { &mut *ptr };
-    let v = unsafe { slice::from_raw_parts(v as *const u8, to_usize(len)) };
+pub unsafe extern "C" fn object_optional_bytearray_set(ptr: *mut Object, 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_optional_bytearray(Some(v.into()));
 }
 
 #[no_mangle]
-pub extern "C" fn object_optional_bytearray_set_none(ptr: *mut Object) {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn object_optional_bytearray_set_none(ptr: *mut Object) {
+    let o = &mut *ptr;
     o.set_optional_bytearray(None);
 }
 
 #[no_mangle]
-pub extern "C" fn object_optional_string_get(
+pub unsafe extern "C" fn object_optional_string_get(
     ptr: *const Object,
     p: *mut QString,
     set: fn(*mut QString, *const c_char, c_int),
 ) {
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     let v = o.optional_string();
     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 extern "C" fn object_optional_string_set(ptr: *mut Object, v: *const c_ushort, len: c_int) {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn object_optional_string_set(ptr: *mut Object, 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_optional_string(Some(s));
 }
 
 #[no_mangle]
-pub extern "C" fn object_optional_string_set_none(ptr: *mut Object) {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn object_optional_string_set_none(ptr: *mut Object) {
+    let o = &mut *ptr;
     o.set_optional_string(None);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_optional_u64_get(ptr: *const Object) -> COption<u64> {
     match (&*ptr).optional_u64() {
         Some(value) => COption { data: value, some: true },
         None => COption { data: u64::default(), some: false}
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_optional_u64_set(ptr: *mut Object, v: u64) {
     (&mut *ptr).set_optional_u64(Some(v));
 }
 
 #[no_mangle]
-pub extern "C" fn object_optional_u64_set_none(ptr: *mut Object) {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn object_optional_u64_set_none(ptr: *mut Object) {
+    let o = &mut *ptr;
     o.set_optional_u64(None);
 }
 
 #[no_mangle]
-pub extern "C" fn object_string_get(
+pub unsafe extern "C" fn object_string_get(
     ptr: *const Object,
     p: *mut QString,
     set: fn(*mut QString, *const c_char, c_int),
 ) {
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     let v = o.string();
     let s: *const c_char = v.as_ptr() as (*const c_char);
     set(p, s, to_c_int(v.len()));
 }
 
 #[no_mangle]
-pub extern "C" fn object_string_set(ptr: *mut Object, v: *const c_ushort, len: c_int) {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn object_string_set(ptr: *mut Object, 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_string(s);
 }
 
 #[no_mangle]
-pub extern "C" fn object_string_by_function_get(
+pub unsafe extern "C" fn object_string_by_function_get(
     ptr: *const Object,
     p: *mut QString,
     set: fn(*mut QString, *const c_char, c_int),
 ) {
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     o.string_by_function(|v| {
         let s: *const c_char = v.as_ptr() as (*const c_char);
         set(p, s, to_c_int(v.len()));
     });
 }
 
 #[no_mangle]
-pub extern "C" fn object_string_by_function_set(ptr: *mut Object, v: *const c_ushort, len: c_int) {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn object_string_by_function_set(ptr: *mut Object, 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_string_by_function(s);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_u16_get(ptr: *const Object) -> u16 {
     (&*ptr).u16()
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_u16_set(ptr: *mut Object, v: u16) {
     (&mut *ptr).set_u16(v);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_u32_get(ptr: *const Object) -> u32 {
     (&*ptr).u32()
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_u32_set(ptr: *mut Object, v: u32) {
     (&mut *ptr).set_u32(v);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_u64_get(ptr: *const Object) -> u64 {
     (&*ptr).u64()
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_u64_set(ptr: *mut Object, v: u64) {
     (&mut *ptr).set_u64(v);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_u8_get(ptr: *const Object) -> u8 {
     (&*ptr).u8()
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn object_u8_set(ptr: *mut Object, v: u8) {
     (&mut *ptr).set_u8(v);
 }
diff --git a/tests/rust_objects/src/interface.rs b/tests/rust_objects/src/interface.rs
index 30cb4c7..349d7f2 100644
--- a/tests/rust_objects/src/interface.rs
+++ b/tests/rust_objects/src/interface.rs
@@ -1,218 +1,217 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
 use libc::{c_char, c_ushort, c_int};
 use std::slice;
 use std::char::decode_utf16;
 
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use implementation::*;
 
 
 pub enum QString {}
 
 fn set_string_from_utf16(s: &mut String, str: *const c_ushort, len: c_int) {
     let utf16 = unsafe { slice::from_raw_parts(str, to_usize(len)) };
     let characters = decode_utf16(utf16.iter().cloned())
-        .into_iter()
         .map(|r| r.unwrap());
     s.clear();
     s.extend(characters);
 }
 
 
 
 fn to_usize(n: c_int) -> usize {
     if n < 0 {
         panic!("Cannot cast {} to usize", n);
     }
     n as usize
 }
 
 
 fn to_c_int(n: usize) -> c_int {
     if n > c_int::max_value() as usize {
         panic!("Cannot cast {} to c_int", n);
     }
     n as c_int
 }
 
 
 pub struct GroupQObject {}
 
 #[derive(Clone)]
 pub struct GroupEmitter {
     qobject: Arc<Mutex<*const GroupQObject>>,
 }
 
 unsafe impl Send for GroupEmitter {}
 
 impl GroupEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
 }
 
 pub trait GroupTrait {
     fn new(emit: GroupEmitter,
         person: Person) -> Self;
     fn emit(&self) -> &GroupEmitter;
     fn person(&self) -> &Person;
     fn person_mut(&mut self) -> &mut Person;
 }
 
 #[no_mangle]
 pub extern "C" fn group_new(
     group: *mut GroupQObject,
     person: *mut PersonQObject,
     object: *mut InnerObjectQObject,
     object_description_changed: fn(*const InnerObjectQObject),
 ) -> *mut Group {
     let object_emit = InnerObjectEmitter {
         qobject: Arc::new(Mutex::new(object)),
         description_changed: object_description_changed,
     };
     let d_object = InnerObject::new(object_emit);
     let person_emit = PersonEmitter {
         qobject: Arc::new(Mutex::new(person)),
     };
     let d_person = Person::new(person_emit,
         d_object);
     let group_emit = GroupEmitter {
         qobject: Arc::new(Mutex::new(group)),
     };
     let d_group = Group::new(group_emit,
         d_person);
     Box::into_raw(Box::new(d_group))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn group_free(ptr: *mut Group) {
     Box::from_raw(ptr).emit().clear();
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn group_person_get(ptr: *mut Group) -> *mut Person {
     (&mut *ptr).person_mut()
 }
 
 pub struct InnerObjectQObject {}
 
 #[derive(Clone)]
 pub struct InnerObjectEmitter {
     qobject: Arc<Mutex<*const InnerObjectQObject>>,
     description_changed: fn(*const InnerObjectQObject),
 }
 
 unsafe impl Send for InnerObjectEmitter {}
 
 impl InnerObjectEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
     pub fn description_changed(&self) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.description_changed)(ptr);
         }
     }
 }
 
 pub trait InnerObjectTrait {
     fn new(emit: InnerObjectEmitter) -> Self;
     fn emit(&self) -> &InnerObjectEmitter;
     fn description(&self) -> &str;
     fn set_description(&mut self, value: String);
 }
 
 #[no_mangle]
 pub extern "C" fn inner_object_new(
     inner_object: *mut InnerObjectQObject,
     inner_object_description_changed: fn(*const InnerObjectQObject),
 ) -> *mut InnerObject {
     let inner_object_emit = InnerObjectEmitter {
         qobject: Arc::new(Mutex::new(inner_object)),
         description_changed: inner_object_description_changed,
     };
     let d_inner_object = InnerObject::new(inner_object_emit);
     Box::into_raw(Box::new(d_inner_object))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn inner_object_free(ptr: *mut InnerObject) {
     Box::from_raw(ptr).emit().clear();
 }
 
 #[no_mangle]
-pub extern "C" fn inner_object_description_get(
+pub unsafe extern "C" fn inner_object_description_get(
     ptr: *const InnerObject,
     p: *mut QString,
     set: fn(*mut QString, *const c_char, c_int),
 ) {
-    let o = unsafe { &*ptr };
+    let o = &*ptr;
     let v = o.description();
     let s: *const c_char = v.as_ptr() as (*const c_char);
     set(p, s, to_c_int(v.len()));
 }
 
 #[no_mangle]
-pub extern "C" fn inner_object_description_set(ptr: *mut InnerObject, v: *const c_ushort, len: c_int) {
-    let o = unsafe { &mut *ptr };
+pub unsafe extern "C" fn inner_object_description_set(ptr: *mut InnerObject, v: *const c_ushort, len: c_int) {
+    let o = &mut *ptr;
     let mut s = String::new();
     set_string_from_utf16(&mut s, v, len);
     o.set_description(s);
 }
 
 pub struct PersonQObject {}
 
 #[derive(Clone)]
 pub struct PersonEmitter {
     qobject: Arc<Mutex<*const PersonQObject>>,
 }
 
 unsafe impl Send for PersonEmitter {}
 
 impl PersonEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
 }
 
 pub trait PersonTrait {
     fn new(emit: PersonEmitter,
         object: InnerObject) -> Self;
     fn emit(&self) -> &PersonEmitter;
     fn object(&self) -> &InnerObject;
     fn object_mut(&mut self) -> &mut InnerObject;
 }
 
 #[no_mangle]
 pub extern "C" fn person_new(
     person: *mut PersonQObject,
     object: *mut InnerObjectQObject,
     object_description_changed: fn(*const InnerObjectQObject),
 ) -> *mut Person {
     let object_emit = InnerObjectEmitter {
         qobject: Arc::new(Mutex::new(object)),
         description_changed: object_description_changed,
     };
     let d_object = InnerObject::new(object_emit);
     let person_emit = PersonEmitter {
         qobject: Arc::new(Mutex::new(person)),
     };
     let d_person = Person::new(person_emit,
         d_object);
     Box::into_raw(Box::new(d_person))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn person_free(ptr: *mut Person) {
     Box::from_raw(ptr).emit().clear();
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn person_object_get(ptr: *mut Person) -> *mut InnerObject {
     (&mut *ptr).object_mut()
 }
diff --git a/tests/rust_tree/src/interface.rs b/tests/rust_tree/src/interface.rs
index d32faa8..26552ae 100644
--- a/tests/rust_tree/src/interface.rs
+++ b/tests/rust_tree/src/interface.rs
@@ -1,310 +1,309 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
 use libc::{c_char, c_ushort, c_int};
 use std::slice;
 use std::char::decode_utf16;
 
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use implementation::*;
 
 
 #[repr(C)]
 pub struct COption<T> {
     data: T,
     some: bool,
 }
 
 impl<T> COption<T> {
     #![allow(dead_code)]
     fn into(self) -> Option<T> {
         if self.some {
             Some(self.data)
         } else {
             None
         }
     }
 }
 
 impl<T> From<Option<T>> for COption<T>
 where
     T: Default,
 {
     fn from(t: Option<T>) -> COption<T> {
         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())
-        .into_iter()
         .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 {}
 
 #[derive(Clone)]
 pub struct PersonsEmitter {
     qobject: Arc<Mutex<*const PersonsQObject>>,
     new_data_ready: fn(*const PersonsQObject, index: COption<usize>),
 }
 
 unsafe impl Send for PersonsEmitter {}
 
 impl PersonsEmitter {
     fn clear(&self) {
         *self.qobject.lock().unwrap() = null();
     }
     pub fn new_data_ready(&self, item: Option<usize>) {
         let ptr = *self.qobject.lock().unwrap();
         if !ptr.is_null() {
             (self.new_data_ready)(ptr, item.into());
         }
     }
 }
 
 #[derive(Clone)]
 pub struct PersonsTree {
     qobject: *const PersonsQObject,
     layout_about_to_be_changed: fn(*const PersonsQObject),
     layout_changed: fn(*const PersonsQObject),
     data_changed: fn(*const PersonsQObject, usize, usize),
     begin_reset_model: fn(*const PersonsQObject),
     end_reset_model: fn(*const PersonsQObject),
     begin_insert_rows: fn(*const PersonsQObject, index: COption<usize>, usize, usize),
     end_insert_rows: fn(*const PersonsQObject),
     begin_move_rows: fn(*const PersonsQObject, index: COption<usize>, usize, usize, dest: COption<usize>, usize),
     end_move_rows: fn(*const PersonsQObject),
     begin_remove_rows: fn(*const PersonsQObject, index: COption<usize>, usize, usize),
     end_remove_rows: fn(*const PersonsQObject),
 }
 
 impl PersonsTree {
     pub fn layout_about_to_be_changed(&self) {
         (self.layout_about_to_be_changed)(self.qobject);
     }
     pub fn layout_changed(&self) {
         (self.layout_changed)(self.qobject);
     }
     pub fn data_changed(&self, first: usize, last: usize) {
         (self.data_changed)(self.qobject, first, last);
     }
     pub fn begin_reset_model(&self) {
         (self.begin_reset_model)(self.qobject);
     }
     pub fn end_reset_model(&self) {
         (self.end_reset_model)(self.qobject);
     }
     pub fn begin_insert_rows(&self, index: Option<usize>, first: usize, last: usize) {
         (self.begin_insert_rows)(self.qobject, index.into(), first, last);
     }
     pub fn end_insert_rows(&self) {
         (self.end_insert_rows)(self.qobject);
     }
     pub fn begin_move_rows(&self, index: Option<usize>, first: usize, last: usize, dest: Option<usize>, destination: usize) {
         (self.begin_move_rows)(self.qobject, index.into(), first, last, dest.into(), destination);
     }
     pub fn end_move_rows(&self) {
         (self.end_move_rows)(self.qobject);
     }
     pub fn begin_remove_rows(&self, index: Option<usize>, first: usize, last: usize) {
         (self.begin_remove_rows)(self.qobject, index.into(), first, last);
     }
     pub fn end_remove_rows(&self) {
         (self.end_remove_rows)(self.qobject);
     }
 }
 
 pub trait PersonsTrait {
     fn new(emit: PersonsEmitter, model: PersonsTree) -> Self;
     fn emit(&self) -> &PersonsEmitter;
     fn row_count(&self, Option<usize>) -> usize;
     fn can_fetch_more(&self, Option<usize>) -> bool {
         false
     }
     fn fetch_more(&mut self, Option<usize>) {}
     fn sort(&mut self, u8, SortOrder) {}
     fn check_row(&self, index: usize, row: usize) -> Option<usize>;
     fn index(&self, item: Option<usize>, row: usize) -> usize;
     fn parent(&self, index: usize) -> Option<usize>;
     fn row(&self, index: usize) -> usize;
     fn user_name(&self, index: usize) -> &str;
     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(*const PersonsQObject, index: COption<usize>),
     persons_layout_about_to_be_changed: fn(*const PersonsQObject),
     persons_layout_changed: fn(*const PersonsQObject),
     persons_data_changed: fn(*const PersonsQObject, usize, usize),
     persons_begin_reset_model: fn(*const PersonsQObject),
     persons_end_reset_model: fn(*const PersonsQObject),
     persons_begin_insert_rows: fn(*const PersonsQObject, index: COption<usize>, usize, usize),
     persons_end_insert_rows: fn(*const PersonsQObject),
     persons_begin_move_rows: fn(*const PersonsQObject, index: COption<usize>, usize, usize, index: COption<usize>, usize),
     persons_end_move_rows: fn(*const PersonsQObject),
     persons_begin_remove_rows: fn(*const PersonsQObject, index: COption<usize>, usize, usize),
     persons_end_remove_rows: fn(*const PersonsQObject),
 ) -> *mut Persons {
     let persons_emit = PersonsEmitter {
         qobject: Arc::new(Mutex::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<usize>,
 ) -> 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<usize>,
 ) -> bool {
     (&*ptr).can_fetch_more(index.into())
 }
 #[no_mangle]
 pub unsafe extern "C" fn persons_fetch_more(ptr: *mut Persons, index: COption<usize>) {
     (&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<usize> {
     (&*ptr).check_row(index.into(), to_usize(row)).into()
 }
 #[no_mangle]
 pub unsafe extern "C" fn persons_index(
     ptr: *const Persons,
     index: COption<usize>,
     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 extern "C" fn persons_data_user_name(
+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 = unsafe { &*ptr };
+    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 extern "C" fn persons_set_data_user_name(
+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 = unsafe { &mut *ptr };
+    let o = &mut *ptr;
     let mut v = String::new();
     set_string_from_utf16(&mut v, s, len);
     o.set_user_name(index, v)
 }