rust ffi dev

cpp/vector_engine_ffi.h

@@ -1,12 +1,27 @@
 #ifndef VECTOR_ENGINE_FFI_H
 #define VECTOR_ENGINE_FFI_H
 
+#include <stddef.h>
+
 struct NativeVectorEngine;
+struct NativeSearchResults;
 
 extern "C" {
 
-NativeVectorEngine* native_vector_engine_new();
-void native_vector_engine_free(NativeVectorEngine* engine);
+    // subject to change
+    NativeVectorEngine* native_vector_engine_new();
+    void native_vector_engine_free(NativeVectorEngine* engine);
+
+    // insert / delete / search
+    void native_vector_engine_insert( NativeVectorEngine* engine, const char* id, const float* vector, size_t len);
+    bool native_vector_engine_delete( NativeVectorEngine* engine, const char* id);
+    NativeSearchResults* native_vector_engine_search( const NativeVectorEngine* engine, const float* query,size_t len, size_t k);
+
+    // working with pointers to send info back to rust
+    size_t native_search_results_len(const NativeSearchResults* results);
+    const char* native_search_results_id_at(const NativeSearchResults* results, size_t index);
+    float native_search_results_score_at(const NativeSearchResults* results, size_t index);
+    void native_search_results_free(NativeSearchResults* results);
 
 }
 

crates/vdb-ffi/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "vdb-ffi"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+path = "src/lib.rs"

crates/vdb-ffi/src/bindings.rs

@@ -0,0 +1,24 @@
+#[repr(C)]
+pub struct NativeVectorEngine {
+    _private: [u8; 0], // rust short hand for declaring "opaque" struct
+}
+
+#[repr(C)]
+pub struct NativeSearchResults {
+    _private: [u8; 0],
+}
+
+unsafe extern "C" {
+    pub fn native_vector_engine_new() -> *mut NativeVectorEngine;
+    pub fn native_vector_engine_free(engine: *mut NativeVectorEngine);
+
+    pub fn native_vector_engine_insert( engine: *mut NativeVectorEngine, id: *const std::os::raw::c_char, vector: *const f32, len: usize, );
+
+    pub fn native_vector_engine_delete( engine: *mut NativeVectorEngine, id: *const std::os::raw::c_char, ) -> bool;
+    pub fn native_vector_engine_search( engine: *const NativeVectorEngine, query: *const f32, len: usize, k: usize, ) -> *mut NativeSearchResults;
+    pub fn native_search_results_len(results: *const NativeSearchResults) -> usize;
+
+    pub fn native_search_results_id_at( results: *const NativeSearchResults, index: usize, ) -> *const std::os::raw::c_char;
+    pub fn native_search_results_score_at( results: *const NativeSearchResults, index: usize, ) -> f32;
+    pub fn native_search_results_free(results: *mut NativeSearchResults);
+}

crates/vdb-ffi/src/engine.rs

@@ -0,0 +1,101 @@
+use crate::bindings::{
+    native_search_results_free,
+    native_search_results_id_at,
+    native_search_results_len,
+    native_search_results_score_at,
+    native_vector_engine_delete,
+    native_vector_engine_free,
+    native_vector_engine_insert,
+    native_vector_engine_new,
+    native_vector_engine_search,
+    NativeSearchResults,
+    NativeVectorEngine,
+};
+use std::ffi::{CStr, CString};
+
+pub struct FfiVectorEngine {
+    handle: *mut NativeVectorEngine,
+}
+
+pub struct FfiSearchResults {
+    handle: *mut NativeSearchResults,
+}
+
+impl FfiVectorEngine {
+    pub fn new() -> Self {
+        let handle = unsafe { native_vector_engine_new() };
+
+        assert!(
+            !handle.is_null(),
+            "native_vector_engine_new went wrong somewhere"
+        );
+
+        Self { 
+            handle 
+        }
+    }
+
+    pub fn insert(&mut self, id: &str, vector: &[f32]) {
+        let id = CString::new(id).expect("vector IDs must not contain null bytes");
+
+        unsafe {
+            native_vector_engine_insert( self.handle, id.as_ptr(), vector.as_ptr(), vector.len(),);
+        }
+    }
+
+    pub fn delete(&mut self, id: &str) -> bool {
+        let id = CString::new(id).expect("vector IDs must not contain null bytes");
+        unsafe { native_vector_engine_delete(self.handle, id.as_ptr()) }
+    }
+
+    pub fn search(&self, query: &[f32], k: usize) -> FfiSearchResults {
+        let handle = unsafe {
+            native_vector_engine_search(self.handle, query.as_ptr(), query.len(), k) };
+
+            assert!(
+                !handle.is_null(),
+                "native_vector_engine_search returned a null results handle"
+        );
+
+        FfiSearchResults { handle }
+    }
+}
+
+impl FfiSearchResults {
+    pub fn len(&self) -> usize {
+        unsafe { native_search_results_len(self.handle) }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn id_at(&self, index: usize) -> String {
+        let id_ptr = unsafe { native_search_results_id_at(self.handle, index) };
+
+        unsafe { CStr::from_ptr(id_ptr) }
+            .to_str()
+            .expect("native search result ID must be valid")
+            .to_string()
+    }
+
+    pub fn score_at(&self, index: usize) -> f32 {
+        unsafe { native_search_results_score_at(self.handle, index) }
+    }
+}
+
+impl Drop for FfiVectorEngine {
+    fn drop(&mut self) {
+        unsafe {
+            native_vector_engine_free(self.handle);
+        }
+    }
+}
+
+impl Drop for FfiSearchResults {
+    fn drop(&mut self) {
+        unsafe {
+            native_search_results_free(self.handle);
+        }
+    }
+}

crates/vdb-ffi/src/lib.rs

@@ -0,0 +1,4 @@
+mod bindings;
+mod engine;
+
+pub use engine::{FfiSearchResults, FfiVectorEngine};