c ffi

Cargo.toml

@@ -14,6 +14,7 @@ keywords = ["trie", "patricia", "collection", "generic", "prefix"]
 categories = ["data-structures", "text-processing"]
 
 [dependencies]
+libc = "0.2"
 nibble_vec = "~0.0.3"
 "endian-type" = "0.1.2"
 serde = { version = "1.0", optional = true }
@@ -23,5 +24,8 @@ quickcheck = "0.4"
 rand = "0.3"
 serde_test = "1.0"
 
+[lib]
+crate-type = ["lib", "cdylib"]
+
 [badges]
 travis-ci = { repository = "michaelsproul/rust_radix_trie" }

src/c_ffi.rs

@@ -0,0 +1,34 @@
+use libc::{c_char,size_t};
+use std::ffi::CStr;
+use std::vec;
+
+use super::Trie;
+use super::trie_common::TrieCommon;
+
+ffi_fn! {
+    fn radix_trie_create()-> *const Trie<Vec<u8>, usize>{
+        let trie = Trie::<Vec<u8>, usize>::new();
+        return Box::into_raw(Box::new(trie));
+    }
+}
+
+ffi_fn! {
+    fn radix_trie_free(trie_ptr: *const Trie<Vec<u8>, usize>){
+        unsafe { Box::from_raw(trie_ptr as *mut Trie<Vec<u8>, usize>); }
+    }
+}
+
+ffi_fn! {
+    fn radix_trie_insert(trie_ptr:*const Trie<Vec<u8>, usize>, key_ptr:*const c_char, value:usize){
+        let mut trie = unsafe { &mut *(trie_ptr as *mut Trie<Vec<u8>, usize>) };
+        let key =  unsafe { CStr::from_ptr(key_ptr) }.to_bytes().to_vec();
+        trie.insert(key, value);
+    }
+}
+
+ffi_fn! {
+    fn radix_trie_len(trie_ptr:*const Trie<Vec<u8>, usize>)->usize{
+        let trie = unsafe { &*trie_ptr };
+        return trie.len();
+    }
+}

src/lib.rs

@@ -11,6 +11,8 @@ extern crate quickcheck;
 #[cfg(test)]
 extern crate rand;
 
+extern crate libc;
+
 pub use nibble_vec::NibbleVec;
 pub use keys::TrieKey;
 pub use trie_common::TrieCommon;
@@ -33,6 +35,9 @@ mod test;
 #[cfg(test)]
 mod qc_test;
 
+mod c_ffi;
+pub use c_ffi::*;
+
 const BRANCH_FACTOR: usize = 16;
 
 /// Data-structure for storing and querying string-like keys and associated values.

src/macros.rs

@@ -2,3 +2,41 @@
 macro_rules! id {
     ($e:item) => { $e }
 }
+
+// from https://github.com/rust-lang/regex/blob/master/regex-capi/src/macros.rs
+macro_rules! ffi_fn {
+    (fn $name:ident($($arg:ident: $arg_ty:ty),*,) -> $ret:ty $body:block) => {
+        ffi_fn!(fn $name($($arg: $arg_ty),*) -> $ret $body);
+    };
+    (fn $name:ident($($arg:ident: $arg_ty:ty),*) -> $ret:ty $body:block) => {
+        #[no_mangle]
+        pub extern fn $name($($arg: $arg_ty),*) -> $ret {
+            use ::std::io::{self, Write};
+            use ::std::panic::{self, AssertUnwindSafe};
+            use ::libc::abort;
+            match panic::catch_unwind(AssertUnwindSafe(move || $body)) {
+                Ok(v) => v,
+                Err(err) => {
+                    let msg = if let Some(&s) = err.downcast_ref::<&str>() {
+                        s.to_owned()
+                    } else if let Some(s) = err.downcast_ref::<String>() {
+                        s.to_owned()
+                    } else {
+                        "UNABLE TO SHOW RESULT OF PANIC.".to_owned()
+                    };
+                    let _ = writeln!(
+                        &mut io::stderr(),
+                        "panic unwind caught, aborting: {:?}",
+                        msg);
+                    unsafe { abort() }
+                }
+            }
+        }
+    };
+    (fn $name:ident($($arg:ident: $arg_ty:ty),*,) $body:block) => {
+        ffi_fn!(fn $name($($arg: $arg_ty),*) -> () $body);
+    };
+    (fn $name:ident($($arg:ident: $arg_ty:ty),*) $body:block) => {
+        ffi_fn!(fn $name($($arg: $arg_ty),*) -> () $body);
+    };
+}

src/test.rs

@@ -2,6 +2,8 @@ use std::collections::HashSet;
 use std::iter::FromIterator;
 use {Trie, TrieCommon};
 use keys::TrieKey;
+use c_ffi::*;
+use std::ffi::{CStr,CString};
 
 const TEST_DATA: [(&'static str, u32); 7] = [("abcdefgh", 19),
                                              ("abcdef", 18),
@@ -440,3 +442,16 @@ fn test_prefix() {
     assert_eq!(second.prefix(), [0x1].as_ref());
     assert_eq!(third.prefix(), [0x2].as_ref());
 }
+
+#[test]
+fn test_c_ffi_e2e(){
+    let t = radix_trie_create();
+    //let key = CString::new("key1").unwrap().as_ptr();
+    radix_trie_insert(t,  CString::new("key1").unwrap().as_ptr(), 1);
+    radix_trie_insert(t, CString::new("key2").unwrap().as_ptr(), 2);
+
+    let len = radix_trie_len(t);
+    assert_eq!(len, 2);
+
+    radix_trie_free(t);
+}