Add a simple refcounted boxed type

This is basically an Arc<Option<String>>

Author: sdroege

Makefile

@@ -3,7 +3,8 @@ HEADERS = \
 	include/ex/foo.h \
 	include/ex/bar.h \
 	include/ex/nameable.h \
-	include/ex/rstring.h
+	include/ex/rstring.h \
+	include/ex/shared-rstring.h \
 
 RUST_SOURCES = \
 	src/lib.rs \
@@ -18,7 +19,10 @@ RUST_SOURCES = \
 	src/nameable/mod.rs \
 	src/rstring/ffi.rs \
 	src/rstring/imp.rs \
-	src/rstring/mod.rs
+	src/rstring/mod.rs \
+	src/shared_rstring/ffi.rs \
+	src/shared_rstring/imp.rs \
+	src/shared_rstring/mod.rs
 
 all: Ex-0.1.gir Ex-0.1.typelib
 

include/ex/ex.h

@@ -5,5 +5,6 @@
 #include "bar.h"
 #include "nameable.h"
 #include "rstring.h"
+#include "shared-rstring.h"
 
 #endif /* __EX_H__ */

include/ex/shared-rstring.h

@@ -0,0 +1,21 @@
+#ifndef __EX_SHARED_RSTRING_H__
+#define __EX_SHARED_RSTRING_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define EX_TYPE_SHARED_RSTRING           (ex_shared_rstring_get_type())
+
+typedef struct _ExSharedRString          ExSharedRString;
+
+GType             ex_shared_rstring_get_type    (void);
+
+ExSharedRString * ex_shared_rstring_new         (const gchar * s);
+ExSharedRString * ex_shared_rstring_ref         (ExSharedRString * shared_rstring);
+void              ex_shared_rstring_unref       (ExSharedRString * shared_rstring);
+gchar *           ex_shared_rstring_get         (ExSharedRString * shared_rstring);
+
+G_END_DECLS
+
+#endif /* __EX_SHARED_RSTRING_H__ */

src/lib.rs

@@ -16,3 +16,4 @@ pub mod foo;
 pub mod bar;
 pub mod nameable;
 pub mod rstring;
+pub mod shared_rstring;

src/rstring/imp.rs

@@ -20,7 +20,7 @@ impl RString {
     }
 
     fn get(&self) -> Option<String> {
-        self.0.as_ref().map(|s| s.clone())
+        self.0.clone()
     }
 
     fn set(&mut self, s: Option<String>) {

src/shared_rstring/ffi.rs

@@ -0,0 +1,17 @@
+use glib_ffi;
+use gobject_ffi;
+use libc::{c_char, c_void};
+
+// Opaque struct
+#[repr(C)]
+pub struct SharedRString(c_void);
+
+extern "C" {
+    pub fn ex_shared_rstring_get_type() -> glib_ffi::GType;
+
+    pub fn ex_shared_rstring_new(s: *const c_char) -> *const SharedRString;
+    pub fn ex_shared_rstring_ref(shared_rstring: *mut SharedRString) -> *mut RString;
+    pub fn ex_shared_rstring_unref(shared_rstring: *mut SharedRString);
+
+    pub fn ex_shared_rstring_get(shared_rstring: *mut SharedRString) -> *mut c_char;
+}

src/shared_rstring/imp.rs

@@ -0,0 +1,90 @@
+use glib_ffi;
+use gobject_ffi;
+
+use std::ffi::CString;
+use std::sync::{Once, ONCE_INIT};
+use std::mem;
+use std::sync::Arc;
+
+use glib::translate::{from_glib_none, ToGlibPtr};
+
+use libc::{c_char, c_void};
+
+// No #[repr(C)] here as we export it as an opaque struct
+// If it was not opaque, it must be #[repr(C)]
+pub struct SharedRString(Option<String>);
+
+impl SharedRString {
+    fn new(s: Option<String>) -> Arc<SharedRString> {
+        Arc::new(SharedRString(s))
+    }
+
+    // FIXME: This could borrow the &str in theory!
+    fn get(&self) -> Option<String> {
+        self.0.clone()
+    }
+}
+
+//
+// Public C functions below
+//
+#[no_mangle]
+pub unsafe extern "C" fn ex_shared_rstring_new(s: *const c_char) -> *mut SharedRString {
+    callback_guard!();
+
+    let s = SharedRString::new(from_glib_none(s));
+    Arc::into_raw(s) as *mut _
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn ex_shared_rstring_ref(
+    shared_rstring: *mut SharedRString,
+) -> *mut SharedRString {
+    callback_guard!();
+
+    let shared_rstring = Arc::from_raw(shared_rstring);
+    let s = shared_rstring.clone();
+
+    // Forget it and keep it alive, we will still need it later
+    let _ = Arc::into_raw(shared_rstring);
+
+    Arc::into_raw(s) as *mut _
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn ex_shared_rstring_unref(shared_rstring: *mut SharedRString) {
+    callback_guard!();
+
+    let _ = Arc::from_raw(shared_rstring);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn ex_shared_rstring_get(shared_rstring: *mut SharedRString) -> *mut c_char {
+    callback_guard!();
+
+    let shared_rstring = &*shared_rstring;
+    // FIXME: This could borrow the &str in theory!
+    shared_rstring.get().to_glib_full()
+}
+
+// GObject glue
+#[no_mangle]
+pub unsafe extern "C" fn ex_shared_rstring_get_type() -> glib_ffi::GType {
+    callback_guard!();
+
+    static mut TYPE: glib_ffi::GType = gobject_ffi::G_TYPE_INVALID;
+    static ONCE: Once = ONCE_INIT;
+
+    ONCE.call_once(|| {
+        let type_name = CString::new("ExSharedRString").unwrap();
+
+        TYPE = gobject_ffi::g_boxed_type_register_static(
+            type_name.as_ptr(),
+            Some(mem::transmute(ex_shared_rstring_ref as *const c_void)),
+            Some(mem::transmute(ex_shared_rstring_ref as *const c_void)),
+        );
+
+    });
+
+    TYPE
+}

src/shared_rstring/mod.rs

@@ -0,0 +1,52 @@
+#[cfg(not(feature = "bindings"))]
+pub mod imp;
+
+#[cfg(feature = "bindings")]
+mod ffi;
+#[cfg(feature = "bindings")]
+pub mod imp {
+    pub use foo::ffi::*;
+}
+
+use glib_ffi;
+use gobject_ffi;
+
+use glib::translate::*;
+
+use std::ptr;
+use std::mem;
+
+glib_wrapper! {
+    pub struct SharedRString(Shared<imp::SharedRString>);
+
+    match fn {
+        ref => |ptr| imp::ex_shared_rstring_ref(ptr),
+        unref => |ptr| imp::ex_shared_rstring_unref(ptr),
+        get_type => || imp::ex_shared_rstring_get_type(),
+    }
+}
+
+impl SharedRString {
+    pub fn new(s: Option<&str>) -> SharedRString {
+        unsafe { from_glib_full(imp::ex_shared_rstring_new(s.to_glib_none().0)) }
+    }
+
+    // FIXME: This could borrow the &str in theory!
+    pub fn get(&self) -> Option<String> {
+        unsafe { from_glib_full(imp::ex_shared_rstring_get(self.to_glib_none().0)) }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_new() {
+        let s = SharedRString::new(Some("bla"));
+        assert_eq!(s.get(), Some("bla".into()));
+
+        let mut s2 = s.clone();
+        assert_eq!(s.get(), Some("bla".into()));
+    }
+}

test.js

@@ -37,3 +37,10 @@ print("rstring: " + s.get());
 let s2 = s.copy();
 s2.set("something else");
 print("rstring2: " + s2.get());
+
+let s = new Ex.SharedRString("something");
+print("shared rstring: " + s.get());
+let s2 = s.ref();
+print("shared rstring2: " + s2.get());
+
+

test.py

@@ -37,3 +37,8 @@ def on_incremented(obj, val, inc):
 s2 = s.copy()
 s2.set("something else")
 print("rstring 2: " + str(s2.get()))
+
+s = Ex.SharedRString.new("something")
+print("shared rstring: " + str(s.get()))
+s2 = s.ref()
+print("shared rstring 2: " + str(s2.get()))