Put the contents of types.rs in the interface

demo/CMakeLists.txt

@@ -3,7 +3,6 @@ set(CMAKE_AUTORCC ON)
 # generate c++ and rust code from fibonacci.json
 add_custom_command(
   OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/rust/src/fibonacci_interface.rs"
-         "${CMAKE_CURRENT_SOURCE_DIR}/rust/src/fibonacci_types.rs"
          "${CMAKE_CURRENT_SOURCE_DIR}/src/Fibonacci.h"
   # if the cpp file is marked GENERATED, CMake will not check it for moc
   #      "${CMAKE_CURRENT_SOURCE_DIR}/src/Fibonacci.cpp"
@@ -14,7 +13,6 @@ add_custom_command(
 # generate c++ and rust code from tree.json
 add_custom_command(
   OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/rust/src/interface.rs"
-         "${CMAKE_CURRENT_SOURCE_DIR}/rust/src/types.rs"
          "${CMAKE_CURRENT_SOURCE_DIR}/src/Tree.h"
   # if the cpp file is marked GENERATED, CMake will not check it for moc
   #      "${CMAKE_CURRENT_SOURCE_DIR}/src/Tree.cpp"
@@ -25,7 +23,6 @@ add_custom_command(
 # generate c++ and rust code from processes.json
 add_custom_command(
   OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/rust/src/processes_interface.rs"
-         "${CMAKE_CURRENT_SOURCE_DIR}/rust/src/processes_types.rs"
          "${CMAKE_CURRENT_SOURCE_DIR}/src/Processes.h"
   # if the cpp file is marked GENERATED, CMake will not check it for moc
   #      "${CMAKE_CURRENT_SOURCE_DIR}/src/Processes.cpp"
@@ -36,7 +33,6 @@ add_custom_command(
 # generate c++ and rust code from time_series.json
 add_custom_command(
   OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/rust/src/time_series_interface.rs"
-         "${CMAKE_CURRENT_SOURCE_DIR}/rust/src/time_series_types.rs"
          "${CMAKE_CURRENT_SOURCE_DIR}/src/TimeSeries.h"
   # if the cpp file is marked GENERATED, CMake will not check it for moc
   #      "${CMAKE_CURRENT_SOURCE_DIR}/src/TimeSeries.cpp"
@@ -51,16 +47,12 @@ add_custom_command(
   DEPENDS rust/src/lib.rs
           rust/src/fibonacci_interface.rs
           rust/src/fibonacci_implementation.rs
-          rust/src/fibonacci_types.rs
           rust/src/implementation.rs
           rust/src/interface.rs
-          rust/src/types.rs
           rust/src/time_series_interface.rs
           rust/src/time_series_implementation.rs
-          rust/src/time_series_types.rs
           rust/src/processes_interface.rs
           rust/src/processes_implementation.rs
-          rust/src/processes_types.rs
   WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/rust"
 )
 add_custom_target(rust_target DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/rust/${RUST_TARGET_DIR}/librust.a")

demo/demo.qml

@@ -116,10 +116,8 @@ ApplicationWindow {
                     switch (processView.sortIndicatorColumn) {
                     case 0: model.sortRole = Qt.DisplayRole; break;
                     }
-                    console.log(model.sortRole);
                 }
                 onSortIndicatorOrderChanged: {
-console.log(model.sort);
                     model.sort(Qt.DisplayRole, processView.sortIndicatorOrderChanged);
                 }
                 Component.onCompleted: {
@@ -129,13 +127,10 @@ console.log(model.sort);
                     processView.expand(processView.rootIndex);
                     processView.expand(a);
                     processView.expand(b);
-console.log('ho', a.data, b.data);
                     processes.rowsInserted.connect(function (index) {
                         processView.expand(processView.rootIndex);
                         processView.expand(index);
-console.log('hi');
                     });
-console.log('ha');
                 }
             }
 /*

demo/rust/src/fibonacci_implementation.rs

@@ -1,7 +1,3 @@
-#![allow(unused_imports)]
-#![allow(unused_variables)]
-#![allow(dead_code)]
-use types::*;
 use std::thread;
 use fibonacci_interface::*;
 use std::sync::atomic::AtomicUsize;

demo/rust/src/fibonacci_interface.rs

@@ -1,14 +1,115 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
-#![allow(unused_imports)]
-use libc::{c_int, c_void};
-use types::*;
+use libc::{c_int, c_void, uint8_t, uint16_t};
+use std::slice;
+
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use fibonacci_implementation::*;
 
+
+#[repr(C)]
+pub struct COption<T> {
+    data: T,
+    some: bool,
+}
+
+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
+            }
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QString {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+#[repr(C)]
+pub struct QStringIn {
+    data: *const uint16_t,
+    len: c_int,
+}
+
+impl QStringIn {
+    fn convert(&self) -> String {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        String::from_utf16_lossy(data)
+    }
+}
+
+impl<'a> From<&'a String> for QString {
+    fn from(string: &'a String) -> QString {
+        QString {
+            len: string.len() as c_int,
+            data: string.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QByteArray {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+impl QByteArray {
+    fn convert(&self) -> Vec<u8> {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        Vec::from(data)
+    }
+}
+
+impl<'a> From<&'a Vec<u8>> for QByteArray {
+    fn from(value: &'a Vec<u8>) -> QByteArray {
+        QByteArray {
+            len: value.len() as c_int,
+            data: value.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QModelIndex {
+    row: c_int,
+    internal_id: usize,
+}
+
+impl QModelIndex {
+    fn invalid() -> QModelIndex {
+        QModelIndex {
+            row: -1,
+            internal_id: 0,
+        }
+    }
+    fn create(row: c_int, id: usize) -> QModelIndex {
+        QModelIndex {
+            row: row,
+            internal_id: id,
+        }
+    }
+}
+
+#[repr(C)]
+pub enum SortOrder {
+    Ascending = 0,
+    Descending = 1
+}
+
+
 pub struct FibonacciQObject {}
 
 #[derive (Clone)]

demo/rust/src/fibonacci_types.rs

@@ -1,104 +0,0 @@
-/* generated by rust_qt_binding_generator */
-#![allow(dead_code)]
-use std::slice;
-use libc::{c_int, uint8_t, uint16_t};
-
-#[repr(C)]
-pub struct COption<T> {
-    data: T,
-    some: bool,
-}
-
-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
-            }
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QString {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-#[repr(C)]
-pub struct QStringIn {
-    data: *const uint16_t,
-    len: c_int,
-}
-
-impl QStringIn {
-    pub fn convert(&self) -> String {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        String::from_utf16_lossy(data)
-    }
-}
-
-impl<'a> From<&'a String> for QString {
-    fn from(string: &'a String) -> QString {
-        QString {
-            len: string.len() as c_int,
-            data: string.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QByteArray {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-impl QByteArray {
-    pub fn convert(&self) -> Vec<u8> {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        Vec::from(data)
-    }
-}
-
-impl<'a> From<&'a Vec<u8>> for QByteArray {
-    fn from(value: &'a Vec<u8>) -> QByteArray {
-        QByteArray {
-            len: value.len() as c_int,
-            data: value.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QModelIndex {
-    row: c_int,
-    internal_id: usize,
-}
-
-impl QModelIndex {
-    pub fn invalid() -> QModelIndex {
-        QModelIndex {
-            row: -1,
-            internal_id: 0,
-        }
-    }
-    pub fn create(row: c_int, id: usize) -> QModelIndex {
-        QModelIndex {
-            row: row,
-            internal_id: id,
-        }
-    }
-}
-
-#[repr(C)]
-pub enum SortOrder {
-    Ascending = 0,
-    Descending = 1
-}
-

demo/rust/src/interface.rs

@@ -1,14 +1,115 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
-#![allow(unused_imports)]
-use libc::{c_int, c_void};
-use types::*;
+use libc::{c_int, c_void, uint8_t, uint16_t};
+use std::slice;
+
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use implementation::*;
 
+
+#[repr(C)]
+pub struct COption<T> {
+    data: T,
+    some: bool,
+}
+
+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
+            }
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QString {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+#[repr(C)]
+pub struct QStringIn {
+    data: *const uint16_t,
+    len: c_int,
+}
+
+impl QStringIn {
+    fn convert(&self) -> String {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        String::from_utf16_lossy(data)
+    }
+}
+
+impl<'a> From<&'a String> for QString {
+    fn from(string: &'a String) -> QString {
+        QString {
+            len: string.len() as c_int,
+            data: string.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QByteArray {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+impl QByteArray {
+    fn convert(&self) -> Vec<u8> {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        Vec::from(data)
+    }
+}
+
+impl<'a> From<&'a Vec<u8>> for QByteArray {
+    fn from(value: &'a Vec<u8>) -> QByteArray {
+        QByteArray {
+            len: value.len() as c_int,
+            data: value.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QModelIndex {
+    row: c_int,
+    internal_id: usize,
+}
+
+impl QModelIndex {
+    fn invalid() -> QModelIndex {
+        QModelIndex {
+            row: -1,
+            internal_id: 0,
+        }
+    }
+    fn create(row: c_int, id: usize) -> QModelIndex {
+        QModelIndex {
+            row: row,
+            internal_id: id,
+        }
+    }
+}
+
+#[repr(C)]
+pub enum SortOrder {
+    Ascending = 0,
+    Descending = 1
+}
+
+
 pub struct TreeQObject {}
 
 #[derive (Clone)]

demo/rust/src/lib.rs

@@ -1,18 +1,14 @@
 extern crate libc;
 extern crate sysinfo;
 
-mod fibonacci_types;
 mod fibonacci_implementation;
 pub mod fibonacci_interface;
 
-mod types;
 mod implementation;
 pub mod interface;
 
-mod time_series_types;
 mod time_series_implementation;
 pub mod time_series_interface;
 
-mod processes_types;
 mod processes_implementation;
 pub mod processes_interface;

demo/rust/src/processes_interface.rs

@@ -1,14 +1,115 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
-#![allow(unused_imports)]
-use libc::{c_int, c_void};
-use types::*;
+use libc::{c_int, c_void, uint8_t, uint16_t};
+use std::slice;
+
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use processes_implementation::*;
 
+
+#[repr(C)]
+pub struct COption<T> {
+    data: T,
+    some: bool,
+}
+
+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
+            }
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QString {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+#[repr(C)]
+pub struct QStringIn {
+    data: *const uint16_t,
+    len: c_int,
+}
+
+impl QStringIn {
+    fn convert(&self) -> String {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        String::from_utf16_lossy(data)
+    }
+}
+
+impl<'a> From<&'a String> for QString {
+    fn from(string: &'a String) -> QString {
+        QString {
+            len: string.len() as c_int,
+            data: string.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QByteArray {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+impl QByteArray {
+    fn convert(&self) -> Vec<u8> {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        Vec::from(data)
+    }
+}
+
+impl<'a> From<&'a Vec<u8>> for QByteArray {
+    fn from(value: &'a Vec<u8>) -> QByteArray {
+        QByteArray {
+            len: value.len() as c_int,
+            data: value.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QModelIndex {
+    row: c_int,
+    internal_id: usize,
+}
+
+impl QModelIndex {
+    fn invalid() -> QModelIndex {
+        QModelIndex {
+            row: -1,
+            internal_id: 0,
+        }
+    }
+    fn create(row: c_int, id: usize) -> QModelIndex {
+        QModelIndex {
+            row: row,
+            internal_id: id,
+        }
+    }
+}
+
+#[repr(C)]
+pub enum SortOrder {
+    Ascending = 0,
+    Descending = 1
+}
+
+
 pub struct ProcessesQObject {}
 
 #[derive (Clone)]

demo/rust/src/processes_types.rs

@@ -1,104 +0,0 @@
-/* generated by rust_qt_binding_generator */
-#![allow(dead_code)]
-use std::slice;
-use libc::{c_int, uint8_t, uint16_t};
-
-#[repr(C)]
-pub struct COption<T> {
-    data: T,
-    some: bool,
-}
-
-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
-            }
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QString {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-#[repr(C)]
-pub struct QStringIn {
-    data: *const uint16_t,
-    len: c_int,
-}
-
-impl QStringIn {
-    pub fn convert(&self) -> String {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        String::from_utf16_lossy(data)
-    }
-}
-
-impl<'a> From<&'a String> for QString {
-    fn from(string: &'a String) -> QString {
-        QString {
-            len: string.len() as c_int,
-            data: string.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QByteArray {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-impl QByteArray {
-    pub fn convert(&self) -> Vec<u8> {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        Vec::from(data)
-    }
-}
-
-impl<'a> From<&'a Vec<u8>> for QByteArray {
-    fn from(value: &'a Vec<u8>) -> QByteArray {
-        QByteArray {
-            len: value.len() as c_int,
-            data: value.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QModelIndex {
-    row: c_int,
-    internal_id: usize,
-}
-
-impl QModelIndex {
-    pub fn invalid() -> QModelIndex {
-        QModelIndex {
-            row: -1,
-            internal_id: 0,
-        }
-    }
-    pub fn create(row: c_int, id: usize) -> QModelIndex {
-        QModelIndex {
-            row: row,
-            internal_id: id,
-        }
-    }
-}
-
-#[repr(C)]
-pub enum SortOrder {
-    Ascending = 0,
-    Descending = 1
-}
-

demo/rust/src/time_series_interface.rs

@@ -1,14 +1,115 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
-#![allow(unused_imports)]
-use libc::{c_int, c_void};
-use types::*;
+use libc::{c_int, c_void, uint8_t, uint16_t};
+use std::slice;
+
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use time_series_implementation::*;
 
+
+#[repr(C)]
+pub struct COption<T> {
+    data: T,
+    some: bool,
+}
+
+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
+            }
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QString {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+#[repr(C)]
+pub struct QStringIn {
+    data: *const uint16_t,
+    len: c_int,
+}
+
+impl QStringIn {
+    fn convert(&self) -> String {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        String::from_utf16_lossy(data)
+    }
+}
+
+impl<'a> From<&'a String> for QString {
+    fn from(string: &'a String) -> QString {
+        QString {
+            len: string.len() as c_int,
+            data: string.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QByteArray {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+impl QByteArray {
+    fn convert(&self) -> Vec<u8> {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        Vec::from(data)
+    }
+}
+
+impl<'a> From<&'a Vec<u8>> for QByteArray {
+    fn from(value: &'a Vec<u8>) -> QByteArray {
+        QByteArray {
+            len: value.len() as c_int,
+            data: value.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QModelIndex {
+    row: c_int,
+    internal_id: usize,
+}
+
+impl QModelIndex {
+    fn invalid() -> QModelIndex {
+        QModelIndex {
+            row: -1,
+            internal_id: 0,
+        }
+    }
+    fn create(row: c_int, id: usize) -> QModelIndex {
+        QModelIndex {
+            row: row,
+            internal_id: id,
+        }
+    }
+}
+
+#[repr(C)]
+pub enum SortOrder {
+    Ascending = 0,
+    Descending = 1
+}
+
+
 pub struct TimeSeriesQObject {}
 
 #[derive (Clone)]

demo/rust/src/time_series_types.rs

@@ -1,104 +0,0 @@
-/* generated by rust_qt_binding_generator */
-#![allow(dead_code)]
-use std::slice;
-use libc::{c_int, uint8_t, uint16_t};
-
-#[repr(C)]
-pub struct COption<T> {
-    data: T,
-    some: bool,
-}
-
-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
-            }
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QString {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-#[repr(C)]
-pub struct QStringIn {
-    data: *const uint16_t,
-    len: c_int,
-}
-
-impl QStringIn {
-    pub fn convert(&self) -> String {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        String::from_utf16_lossy(data)
-    }
-}
-
-impl<'a> From<&'a String> for QString {
-    fn from(string: &'a String) -> QString {
-        QString {
-            len: string.len() as c_int,
-            data: string.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QByteArray {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-impl QByteArray {
-    pub fn convert(&self) -> Vec<u8> {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        Vec::from(data)
-    }
-}
-
-impl<'a> From<&'a Vec<u8>> for QByteArray {
-    fn from(value: &'a Vec<u8>) -> QByteArray {
-        QByteArray {
-            len: value.len() as c_int,
-            data: value.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QModelIndex {
-    row: c_int,
-    internal_id: usize,
-}
-
-impl QModelIndex {
-    pub fn invalid() -> QModelIndex {
-        QModelIndex {
-            row: -1,
-            internal_id: 0,
-        }
-    }
-    pub fn create(row: c_int, id: usize) -> QModelIndex {
-        QModelIndex {
-            row: row,
-            internal_id: id,
-        }
-    }
-}
-
-#[repr(C)]
-pub enum SortOrder {
-    Ascending = 0,
-    Descending = 1
-}
-

demo/rust/src/types.rs

@@ -1,104 +0,0 @@
-/* generated by rust_qt_binding_generator */
-#![allow(dead_code)]
-use std::slice;
-use libc::{c_int, uint8_t, uint16_t};
-
-#[repr(C)]
-pub struct COption<T> {
-    data: T,
-    some: bool,
-}
-
-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
-            }
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QString {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-#[repr(C)]
-pub struct QStringIn {
-    data: *const uint16_t,
-    len: c_int,
-}
-
-impl QStringIn {
-    pub fn convert(&self) -> String {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        String::from_utf16_lossy(data)
-    }
-}
-
-impl<'a> From<&'a String> for QString {
-    fn from(string: &'a String) -> QString {
-        QString {
-            len: string.len() as c_int,
-            data: string.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QByteArray {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-impl QByteArray {
-    pub fn convert(&self) -> Vec<u8> {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        Vec::from(data)
-    }
-}
-
-impl<'a> From<&'a Vec<u8>> for QByteArray {
-    fn from(value: &'a Vec<u8>) -> QByteArray {
-        QByteArray {
-            len: value.len() as c_int,
-            data: value.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QModelIndex {
-    row: c_int,
-    internal_id: usize,
-}
-
-impl QModelIndex {
-    pub fn invalid() -> QModelIndex {
-        QModelIndex {
-            row: -1,
-            internal_id: 0,
-        }
-    }
-    pub fn create(row: c_int, id: usize) -> QModelIndex {
-        QModelIndex {
-            row: row,
-            internal_id: id,
-        }
-    }
-}
-
-#[repr(C)]
-pub enum SortOrder {
-    Ascending = 0,
-    Descending = 1
-}
-

src/main.cpp

@@ -42,7 +42,6 @@ int main(int argc, char *argv[]) {
         writeCpp(configuration);
         writeRustInterface(configuration);
         writeRustImplementation(configuration);
-        writeRustTypes(configuration);
     }
 
     return 0;

src/parseJson.cpp

@@ -204,6 +204,5 @@ parseConfiguration(const QString& path) {
     c.rustdir = QDir(base.filePath(rust.value("dir").toString()));
     c.interfaceModule = rust.value("interfaceModule").toString();
     c.implementationModule = rust.value("implementationModule").toString();
-    c.typesModule = rust.value("typesModule").toString();
     return c;
 }

src/rust.cpp

@@ -446,21 +446,128 @@ QString rustFile(const QDir rustdir, const QString& module) {
     return path;
 }
 
+void writeRustTypes(QTextStream& r) {
+    r << QString(R"(
+
+#[repr(C)]
+pub struct COption<T> {
+    data: T,
+    some: bool,
+}
+
+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
+            }
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QString {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+#[repr(C)]
+pub struct QStringIn {
+    data: *const uint16_t,
+    len: c_int,
+}
+
+impl QStringIn {
+    fn convert(&self) -> String {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        String::from_utf16_lossy(data)
+    }
+}
+
+impl<'a> From<&'a String> for QString {
+    fn from(string: &'a String) -> QString {
+        QString {
+            len: string.len() as c_int,
+            data: string.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QByteArray {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+impl QByteArray {
+    fn convert(&self) -> Vec<u8> {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        Vec::from(data)
+    }
+}
+
+impl<'a> From<&'a Vec<u8>> for QByteArray {
+    fn from(value: &'a Vec<u8>) -> QByteArray {
+        QByteArray {
+            len: value.len() as c_int,
+            data: value.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QModelIndex {
+    row: c_int,
+    internal_id: usize,
+}
+
+impl QModelIndex {
+    fn invalid() -> QModelIndex {
+        QModelIndex {
+            row: -1,
+            internal_id: 0,
+        }
+    }
+    fn create(row: c_int, id: usize) -> QModelIndex {
+        QModelIndex {
+            row: row,
+            internal_id: id,
+        }
+    }
+}
+
+#[repr(C)]
+pub enum SortOrder {
+    Ascending = 0,
+    Descending = 1
+}
+
+)");
+}
+
 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)]
-#![allow(unused_imports)]
-use libc::{c_int, c_void};
-use types::*;
+use libc::{c_int, c_void, uint8_t, uint16_t};
+use std::slice;
+
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use %1::*;
 )").arg(conf.implementationModule);
 
+    writeRustTypes(r);
+
     for (auto object: conf.objects) {
         writeRustInterfaceObject(r, object);
     }
@@ -580,7 +687,6 @@ void writeRustImplementation(const Configuration& conf) {
     r << QString(R"(#![allow(unused_imports)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
-use types::*;
 use %1::*;
 
 )").arg(conf.interfaceModule);
@@ -589,113 +695,3 @@ use %1::*;
         writeRustImplementationObject(r, object);
     }
 }
-
-void writeRustTypes(const Configuration& conf) {
-    DifferentFileWriter w(rustFile(conf.rustdir, conf.typesModule));
-    QTextStream r(&w.buffer);
-    r << QString(R"(/* generated by rust_qt_binding_generator */
-#![allow(dead_code)]
-use std::slice;
-use libc::{c_int, uint8_t, uint16_t};
-
-#[repr(C)]
-pub struct COption<T> {
-    data: T,
-    some: bool,
-}
-
-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
-            }
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QString {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-#[repr(C)]
-pub struct QStringIn {
-    data: *const uint16_t,
-    len: c_int,
-}
-
-impl QStringIn {
-    pub fn convert(&self) -> String {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        String::from_utf16_lossy(data)
-    }
-}
-
-impl<'a> From<&'a String> for QString {
-    fn from(string: &'a String) -> QString {
-        QString {
-            len: string.len() as c_int,
-            data: string.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QByteArray {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-impl QByteArray {
-    pub fn convert(&self) -> Vec<u8> {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        Vec::from(data)
-    }
-}
-
-impl<'a> From<&'a Vec<u8>> for QByteArray {
-    fn from(value: &'a Vec<u8>) -> QByteArray {
-        QByteArray {
-            len: value.len() as c_int,
-            data: value.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QModelIndex {
-    row: c_int,
-    internal_id: usize,
-}
-
-impl QModelIndex {
-    pub fn invalid() -> QModelIndex {
-        QModelIndex {
-            row: -1,
-            internal_id: 0,
-        }
-    }
-    pub fn create(row: c_int, id: usize) -> QModelIndex {
-        QModelIndex {
-            row: row,
-            internal_id: id,
-        }
-    }
-}
-
-#[repr(C)]
-pub enum SortOrder {
-    Ascending = 0,
-    Descending = 1
-}
-
-)");
-}

src/rust.h

@@ -1,4 +1,3 @@
 class Configuration;
 void writeRustInterface(const Configuration& conf);
-void writeRustTypes(const Configuration& conf);
 void writeRustImplementation(const Configuration& conf);

src/structs.h

@@ -61,7 +61,6 @@ struct Configuration {
     QDir rustdir;
     QString interfaceModule;
     QString implementationModule;
-    QString typesModule;
     QList<Object> objects;
     bool overwriteImplementation;
 };

tests/CMakeLists.txt

@@ -11,7 +11,6 @@ function(rust_test NAME DIRECTORY)
     add_custom_command(
         OUTPUT "${DIR}/src/interface.rs"
                "${DIR}/src/implementation.rs"
-               "${DIR}/src/types.rs"
                "${SRC}/${NAME}_rust.h"
         # if the cpp file is marked GENERATED, CMake will not check it for moc
         #      "${SRC}/${NAME}_rust.cpp"
@@ -26,7 +25,6 @@ function(rust_test NAME DIRECTORY)
         DEPENDS "${DIR}/src/lib.rs"
                 "${DIR}/src/implementation.rs"
                 "${DIR}/src/interface.rs"
-                "${DIR}/src/types.rs"
         WORKING_DIRECTORY "${DIR}"
     )
     add_custom_target("test_${DIRECTORY}"

tests/rust_list/src/implementation.rs

@@ -1,7 +1,6 @@
 #![allow(unused_imports)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
-use types::*;
 use interface::*;
 
 #[derive (Default, Clone)]

tests/rust_list/src/interface.rs

@@ -1,14 +1,115 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
-#![allow(unused_imports)]
-use libc::{c_int, c_void};
-use types::*;
+use libc::{c_int, c_void, uint8_t, uint16_t};
+use std::slice;
+
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use implementation::*;
 
+
+#[repr(C)]
+pub struct COption<T> {
+    data: T,
+    some: bool,
+}
+
+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
+            }
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QString {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+#[repr(C)]
+pub struct QStringIn {
+    data: *const uint16_t,
+    len: c_int,
+}
+
+impl QStringIn {
+    fn convert(&self) -> String {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        String::from_utf16_lossy(data)
+    }
+}
+
+impl<'a> From<&'a String> for QString {
+    fn from(string: &'a String) -> QString {
+        QString {
+            len: string.len() as c_int,
+            data: string.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QByteArray {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+impl QByteArray {
+    fn convert(&self) -> Vec<u8> {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        Vec::from(data)
+    }
+}
+
+impl<'a> From<&'a Vec<u8>> for QByteArray {
+    fn from(value: &'a Vec<u8>) -> QByteArray {
+        QByteArray {
+            len: value.len() as c_int,
+            data: value.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QModelIndex {
+    row: c_int,
+    internal_id: usize,
+}
+
+impl QModelIndex {
+    fn invalid() -> QModelIndex {
+        QModelIndex {
+            row: -1,
+            internal_id: 0,
+        }
+    }
+    fn create(row: c_int, id: usize) -> QModelIndex {
+        QModelIndex {
+            row: row,
+            internal_id: id,
+        }
+    }
+}
+
+#[repr(C)]
+pub enum SortOrder {
+    Ascending = 0,
+    Descending = 1
+}
+
+
 pub struct PersonsQObject {}
 
 #[derive (Clone)]

tests/rust_list/src/lib.rs

@@ -1,5 +1,4 @@
 extern crate libc;
 
-mod types;
 pub mod interface;
 mod implementation;

tests/rust_list/src/types.rs

@@ -1,104 +0,0 @@
-/* generated by rust_qt_binding_generator */
-#![allow(dead_code)]
-use std::slice;
-use libc::{c_int, uint8_t, uint16_t};
-
-#[repr(C)]
-pub struct COption<T> {
-    data: T,
-    some: bool,
-}
-
-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
-            }
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QString {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-#[repr(C)]
-pub struct QStringIn {
-    data: *const uint16_t,
-    len: c_int,
-}
-
-impl QStringIn {
-    pub fn convert(&self) -> String {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        String::from_utf16_lossy(data)
-    }
-}
-
-impl<'a> From<&'a String> for QString {
-    fn from(string: &'a String) -> QString {
-        QString {
-            len: string.len() as c_int,
-            data: string.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QByteArray {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-impl QByteArray {
-    pub fn convert(&self) -> Vec<u8> {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        Vec::from(data)
-    }
-}
-
-impl<'a> From<&'a Vec<u8>> for QByteArray {
-    fn from(value: &'a Vec<u8>) -> QByteArray {
-        QByteArray {
-            len: value.len() as c_int,
-            data: value.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QModelIndex {
-    row: c_int,
-    internal_id: usize,
-}
-
-impl QModelIndex {
-    pub fn invalid() -> QModelIndex {
-        QModelIndex {
-            row: -1,
-            internal_id: 0,
-        }
-    }
-    pub fn create(row: c_int, id: usize) -> QModelIndex {
-        QModelIndex {
-            row: row,
-            internal_id: id,
-        }
-    }
-}
-
-#[repr(C)]
-pub enum SortOrder {
-    Ascending = 0,
-    Descending = 1
-}
-

tests/rust_object/src/implementation.rs

@@ -1,7 +1,6 @@
 #![allow(unused_imports)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
-use types::*;
 use interface::*;
 
 pub struct Person {

tests/rust_object/src/interface.rs

@@ -1,14 +1,115 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
-#![allow(unused_imports)]
-use libc::{c_int, c_void};
-use types::*;
+use libc::{c_int, c_void, uint8_t, uint16_t};
+use std::slice;
+
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use implementation::*;
 
+
+#[repr(C)]
+pub struct COption<T> {
+    data: T,
+    some: bool,
+}
+
+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
+            }
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QString {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+#[repr(C)]
+pub struct QStringIn {
+    data: *const uint16_t,
+    len: c_int,
+}
+
+impl QStringIn {
+    fn convert(&self) -> String {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        String::from_utf16_lossy(data)
+    }
+}
+
+impl<'a> From<&'a String> for QString {
+    fn from(string: &'a String) -> QString {
+        QString {
+            len: string.len() as c_int,
+            data: string.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QByteArray {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+impl QByteArray {
+    fn convert(&self) -> Vec<u8> {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        Vec::from(data)
+    }
+}
+
+impl<'a> From<&'a Vec<u8>> for QByteArray {
+    fn from(value: &'a Vec<u8>) -> QByteArray {
+        QByteArray {
+            len: value.len() as c_int,
+            data: value.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QModelIndex {
+    row: c_int,
+    internal_id: usize,
+}
+
+impl QModelIndex {
+    fn invalid() -> QModelIndex {
+        QModelIndex {
+            row: -1,
+            internal_id: 0,
+        }
+    }
+    fn create(row: c_int, id: usize) -> QModelIndex {
+        QModelIndex {
+            row: row,
+            internal_id: id,
+        }
+    }
+}
+
+#[repr(C)]
+pub enum SortOrder {
+    Ascending = 0,
+    Descending = 1
+}
+
+
 pub struct PersonQObject {}
 
 #[derive (Clone)]

tests/rust_object/src/lib.rs

@@ -1,5 +1,4 @@
 extern crate libc;
 
-mod types;
 pub mod interface;
 mod implementation;

tests/rust_object/src/types.rs

@@ -1,104 +0,0 @@
-/* generated by rust_qt_binding_generator */
-#![allow(dead_code)]
-use std::slice;
-use libc::{c_int, uint8_t, uint16_t};
-
-#[repr(C)]
-pub struct COption<T> {
-    data: T,
-    some: bool,
-}
-
-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
-            }
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QString {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-#[repr(C)]
-pub struct QStringIn {
-    data: *const uint16_t,
-    len: c_int,
-}
-
-impl QStringIn {
-    pub fn convert(&self) -> String {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        String::from_utf16_lossy(data)
-    }
-}
-
-impl<'a> From<&'a String> for QString {
-    fn from(string: &'a String) -> QString {
-        QString {
-            len: string.len() as c_int,
-            data: string.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QByteArray {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-impl QByteArray {
-    pub fn convert(&self) -> Vec<u8> {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        Vec::from(data)
-    }
-}
-
-impl<'a> From<&'a Vec<u8>> for QByteArray {
-    fn from(value: &'a Vec<u8>) -> QByteArray {
-        QByteArray {
-            len: value.len() as c_int,
-            data: value.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QModelIndex {
-    row: c_int,
-    internal_id: usize,
-}
-
-impl QModelIndex {
-    pub fn invalid() -> QModelIndex {
-        QModelIndex {
-            row: -1,
-            internal_id: 0,
-        }
-    }
-    pub fn create(row: c_int, id: usize) -> QModelIndex {
-        QModelIndex {
-            row: row,
-            internal_id: id,
-        }
-    }
-}
-
-#[repr(C)]
-pub enum SortOrder {
-    Ascending = 0,
-    Descending = 1
-}
-

tests/rust_object_types/src/implementation.rs

@@ -1,7 +1,6 @@
 #![allow(unused_imports)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
-use types::*;
 use interface::*;
 
 pub struct Object {

tests/rust_object_types/src/interface.rs

@@ -1,14 +1,115 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
-#![allow(unused_imports)]
-use libc::{c_int, c_void};
-use types::*;
+use libc::{c_int, c_void, uint8_t, uint16_t};
+use std::slice;
+
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use implementation::*;
 
+
+#[repr(C)]
+pub struct COption<T> {
+    data: T,
+    some: bool,
+}
+
+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
+            }
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QString {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+#[repr(C)]
+pub struct QStringIn {
+    data: *const uint16_t,
+    len: c_int,
+}
+
+impl QStringIn {
+    fn convert(&self) -> String {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        String::from_utf16_lossy(data)
+    }
+}
+
+impl<'a> From<&'a String> for QString {
+    fn from(string: &'a String) -> QString {
+        QString {
+            len: string.len() as c_int,
+            data: string.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QByteArray {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+impl QByteArray {
+    fn convert(&self) -> Vec<u8> {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        Vec::from(data)
+    }
+}
+
+impl<'a> From<&'a Vec<u8>> for QByteArray {
+    fn from(value: &'a Vec<u8>) -> QByteArray {
+        QByteArray {
+            len: value.len() as c_int,
+            data: value.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QModelIndex {
+    row: c_int,
+    internal_id: usize,
+}
+
+impl QModelIndex {
+    fn invalid() -> QModelIndex {
+        QModelIndex {
+            row: -1,
+            internal_id: 0,
+        }
+    }
+    fn create(row: c_int, id: usize) -> QModelIndex {
+        QModelIndex {
+            row: row,
+            internal_id: id,
+        }
+    }
+}
+
+#[repr(C)]
+pub enum SortOrder {
+    Ascending = 0,
+    Descending = 1
+}
+
+
 pub struct ObjectQObject {}
 
 #[derive (Clone)]

tests/rust_object_types/src/lib.rs

@@ -1,5 +1,4 @@
 extern crate libc;
 
-mod types;
 pub mod interface;
 mod implementation;

tests/rust_object_types/src/types.rs

@@ -1,104 +0,0 @@
-/* generated by rust_qt_binding_generator */
-#![allow(dead_code)]
-use std::slice;
-use libc::{c_int, uint8_t, uint16_t};
-
-#[repr(C)]
-pub struct COption<T> {
-    data: T,
-    some: bool,
-}
-
-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
-            }
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QString {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-#[repr(C)]
-pub struct QStringIn {
-    data: *const uint16_t,
-    len: c_int,
-}
-
-impl QStringIn {
-    pub fn convert(&self) -> String {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        String::from_utf16_lossy(data)
-    }
-}
-
-impl<'a> From<&'a String> for QString {
-    fn from(string: &'a String) -> QString {
-        QString {
-            len: string.len() as c_int,
-            data: string.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QByteArray {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-impl QByteArray {
-    pub fn convert(&self) -> Vec<u8> {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        Vec::from(data)
-    }
-}
-
-impl<'a> From<&'a Vec<u8>> for QByteArray {
-    fn from(value: &'a Vec<u8>) -> QByteArray {
-        QByteArray {
-            len: value.len() as c_int,
-            data: value.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QModelIndex {
-    row: c_int,
-    internal_id: usize,
-}
-
-impl QModelIndex {
-    pub fn invalid() -> QModelIndex {
-        QModelIndex {
-            row: -1,
-            internal_id: 0,
-        }
-    }
-    pub fn create(row: c_int, id: usize) -> QModelIndex {
-        QModelIndex {
-            row: row,
-            internal_id: id,
-        }
-    }
-}
-
-#[repr(C)]
-pub enum SortOrder {
-    Ascending = 0,
-    Descending = 1
-}
-

tests/rust_tree/src/implementation.rs

@@ -1,7 +1,6 @@
 #![allow(unused_imports)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
-use types::*;
 use interface::*;
 
 #[derive (Default, Clone)]

tests/rust_tree/src/interface.rs

@@ -1,14 +1,115 @@
 /* generated by rust_qt_binding_generator */
 #![allow(unknown_lints)]
 #![allow(mutex_atomic, needless_pass_by_value)]
-#![allow(unused_imports)]
-use libc::{c_int, c_void};
-use types::*;
+use libc::{c_int, c_void, uint8_t, uint16_t};
+use std::slice;
+
 use std::sync::{Arc, Mutex};
 use std::ptr::null;
 
 use implementation::*;
 
+
+#[repr(C)]
+pub struct COption<T> {
+    data: T,
+    some: bool,
+}
+
+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
+            }
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QString {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+#[repr(C)]
+pub struct QStringIn {
+    data: *const uint16_t,
+    len: c_int,
+}
+
+impl QStringIn {
+    fn convert(&self) -> String {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        String::from_utf16_lossy(data)
+    }
+}
+
+impl<'a> From<&'a String> for QString {
+    fn from(string: &'a String) -> QString {
+        QString {
+            len: string.len() as c_int,
+            data: string.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QByteArray {
+    data: *const uint8_t,
+    len: c_int,
+}
+
+impl QByteArray {
+    fn convert(&self) -> Vec<u8> {
+        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
+        Vec::from(data)
+    }
+}
+
+impl<'a> From<&'a Vec<u8>> for QByteArray {
+    fn from(value: &'a Vec<u8>) -> QByteArray {
+        QByteArray {
+            len: value.len() as c_int,
+            data: value.as_ptr(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct QModelIndex {
+    row: c_int,
+    internal_id: usize,
+}
+
+impl QModelIndex {
+    fn invalid() -> QModelIndex {
+        QModelIndex {
+            row: -1,
+            internal_id: 0,
+        }
+    }
+    fn create(row: c_int, id: usize) -> QModelIndex {
+        QModelIndex {
+            row: row,
+            internal_id: id,
+        }
+    }
+}
+
+#[repr(C)]
+pub enum SortOrder {
+    Ascending = 0,
+    Descending = 1
+}
+
+
 pub struct PersonsQObject {}
 
 #[derive (Clone)]

tests/rust_tree/src/lib.rs

@@ -1,5 +1,4 @@
 extern crate libc;
 
-mod types;
 pub mod interface;
 mod implementation;

tests/rust_tree/src/types.rs

@@ -1,104 +0,0 @@
-/* generated by rust_qt_binding_generator */
-#![allow(dead_code)]
-use std::slice;
-use libc::{c_int, uint8_t, uint16_t};
-
-#[repr(C)]
-pub struct COption<T> {
-    data: T,
-    some: bool,
-}
-
-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
-            }
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QString {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-#[repr(C)]
-pub struct QStringIn {
-    data: *const uint16_t,
-    len: c_int,
-}
-
-impl QStringIn {
-    pub fn convert(&self) -> String {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        String::from_utf16_lossy(data)
-    }
-}
-
-impl<'a> From<&'a String> for QString {
-    fn from(string: &'a String) -> QString {
-        QString {
-            len: string.len() as c_int,
-            data: string.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QByteArray {
-    data: *const uint8_t,
-    len: c_int,
-}
-
-impl QByteArray {
-    pub fn convert(&self) -> Vec<u8> {
-        let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
-        Vec::from(data)
-    }
-}
-
-impl<'a> From<&'a Vec<u8>> for QByteArray {
-    fn from(value: &'a Vec<u8>) -> QByteArray {
-        QByteArray {
-            len: value.len() as c_int,
-            data: value.as_ptr(),
-        }
-    }
-}
-
-#[repr(C)]
-pub struct QModelIndex {
-    row: c_int,
-    internal_id: usize,
-}
-
-impl QModelIndex {
-    pub fn invalid() -> QModelIndex {
-        QModelIndex {
-            row: -1,
-            internal_id: 0,
-        }
-    }
-    pub fn create(row: c_int, id: usize) -> QModelIndex {
-        QModelIndex {
-            row: row,
-            internal_id: id,
-        }
-    }
-}
-
-#[repr(C)]
-pub enum SortOrder {
-    Ascending = 0,
-    Descending = 1
-}
-