Allow &str for contents of a Variant

common-rust/src/implementation.rs

@@ -51,7 +51,7 @@ impl RItemModelTrait for RItemModel {
     fn parent(&self, index: QModelIndex) -> QModelIndex {
         QModelIndex::invalid()
     }
-    fn data(&self, index: QModelIndex, role: c_int) -> Variant {
-        Variant::String(String::from("hello"))
+    fn data<'a>(&'a self, index: QModelIndex, role: c_int) -> Variant<'a> {
+        Variant::from("hello")
     }
 }

common-rust/src/interface.rs

@@ -50,9 +50,7 @@ pub extern fn hello_set(ptr: *mut Hello, s: *const uint16_t, len: size_t) {
 
 #[no_mangle]
 pub extern fn hello_get(ptr: *mut Hello) -> QString {
-    let hello = unsafe {
-        &mut *ptr
-    };
+    let hello = unsafe { &mut *ptr };
     QString::from(hello.get_hello())
 }
 
@@ -71,7 +69,7 @@ pub trait RItemModelTrait {
     fn row_count(&self, parent: QModelIndex) -> c_int;
     fn index(&self, row: c_int, column: c_int, parent: QModelIndex) -> QModelIndex;
     fn parent(&self, index: QModelIndex) -> QModelIndex;
-    fn data(&self, index: QModelIndex, role: c_int) -> Variant;
+    fn data<'a>(&'a self, index: QModelIndex, role: c_int) -> Variant<'a>;
 }
 
 #[no_mangle]
@@ -91,41 +89,31 @@ pub extern fn ritemmodel_free(ptr: *mut RItemModel) {
 
 #[no_mangle]
 pub extern fn ritemmodel_column_count(ptr: *const RItemModel, parent: QModelIndex) -> i32 {
-    let ritemmodel = unsafe {
-        &*ptr
-    };
+    let ritemmodel = unsafe { &*ptr };
     ritemmodel.column_count(parent)
 }
 
 #[no_mangle]
 pub extern fn ritemmodel_row_count(ptr: *const RItemModel, parent: QModelIndex) -> i32 {
-    let ritemmodel = unsafe {
-        &*ptr
-    };
+    let ritemmodel = unsafe { &*ptr };
     ritemmodel.row_count(parent)
 }
 
 #[no_mangle]
 pub extern fn ritemmodel_index(ptr: *const RItemModel, row: i32, column: i32, parent: QModelIndex) -> QModelIndex {
-    let ritemmodel = unsafe {
-        &*ptr
-    };
+    let ritemmodel = unsafe { &*ptr };
     ritemmodel.index(row, column, parent)
 }
 
 #[no_mangle]
 pub extern fn ritemmodel_parent(ptr: *const RItemModel, index: QModelIndex) -> QModelIndex {
-    let ritemmodel = unsafe {
-        &*ptr
-    };
+    let ritemmodel = unsafe { &*ptr };
     ritemmodel.parent(index)
 }
 
 #[no_mangle]
 pub extern fn ritemmodel_data(ptr: *const RItemModel, index: QModelIndex, role: c_int, d: *mut c_void, set: fn (*mut c_void, &QVariant)) {
-    let ritemmodel = unsafe {
-        &*ptr
-    };
+    let ritemmodel = unsafe { &*ptr };
     let data = ritemmodel.data(index, role);
     set(d, &QVariant::from(&data));
 }

common-rust/src/types.rs

@@ -17,10 +17,29 @@ impl<'a> From<&'a String> for QString {
     }
 }
 
-pub enum Variant {
+pub enum Variant<'a> {
     None,
     Bool(bool),
-    String(String)
+    String(String),
+    str(&'a str)
+}
+
+impl<'a> From<bool> for Variant<'a> {
+    fn from(value: bool) -> Variant<'a> {
+        Variant::Bool(value)
+    }
+}
+
+impl<'a> From<String> for Variant<'a> {
+    fn from(value: String) -> Variant<'a> {
+        Variant::String(value)
+    }
+}
+
+impl<'a> From<&'a str> for Variant<'a> {
+    fn from(value: &'a str) -> Variant {
+        Variant::str(value)
+    }
 }
 
 /* values from qvariant.h and qmetatype.h */
@@ -47,8 +66,8 @@ impl<'a> QVariant<'a> {
     }
 }
 
-impl<'a> From<&'a Variant> for QVariant<'a> {
-    fn from(variant: &'a Variant) -> QVariant {
+impl<'a> From<&'a Variant<'a>> for QVariant<'a> {
+    fn from(variant: &'a Variant<'a>) -> QVariant {
         match variant {
             &Variant::None => QVariant {
                 data: null(),
@@ -67,6 +86,12 @@ impl<'a> From<&'a Variant> for QVariant<'a> {
                 len: v.len() as c_int,
                 type_: VariantType::String as c_uint,
                 phantom: PhantomData
+            },
+            &Variant::str(ref v) => QVariant {
+                data: v.as_ptr(),
+                len: v.len() as c_int,
+                type_: VariantType::String as c_uint,
+                phantom: PhantomData
             }
         }
     }