Add support for working with binary indexes.

faiss-sys/build.rs

@@ -11,11 +11,10 @@ fn static_link_faiss() {
     cfg.define("FAISS_ENABLE_C_API", "ON")
         .define("BUILD_SHARED_LIBS", "OFF")
         .define("CMAKE_BUILD_TYPE", "Release")
-        .define("FAISS_ENABLE_GPU", if cfg!(feature = "gpu") {
-            "ON"
-        } else {
-            "OFF"
-        })
+        .define(
+            "FAISS_ENABLE_GPU",
+            if cfg!(feature = "gpu") { "ON" } else { "OFF" },
+        )
         .define("FAISS_ENABLE_PYTHON", "OFF")
         .define("BUILD_TESTING", "OFF")
         .very_verbose(true);

faiss-sys/src/lib.rs

@@ -31,6 +31,20 @@ mod tests {
             assert!(!last_error.is_null());
         }
     }
+    #[test]
+    fn flat_index_binary() {
+        const D: usize = 8;
+        unsafe {
+            let description = CString::new::<&str>("BFlat".as_ref()).unwrap();
+            let mut index_ptr = ::std::ptr::null_mut();
+            let code = faiss_index_binary_factory(
+                &mut index_ptr,
+                (D & 0x7FFF_FFFF) as i32,
+                description.as_ptr(),
+            );
+            assert_eq!(code, 0);
+        }
+    }
 
     #[test]
     fn flat_index() {

src/index/io.rs

@@ -2,7 +2,10 @@
 
 use crate::error::{Error, Result};
 use crate::faiss_try;
-use crate::index::{CpuIndex, FromInnerPtr, IndexImpl, NativeIndex};
+use crate::index::{
+    BinaryIndexImpl, CpuIndex, CpuIndexBinary, FromInnerPtr, FromInnerPtrBinary, IndexImpl,
+    NativeIndex, NativeIndexBinary,
+};
 use faiss_sys::*;
 use std::ffi::CString;
 use std::os::raw::c_int;
@@ -31,6 +34,30 @@ where
     }
 }
 
+/// Write a binary index to a file.
+///
+/// # Error
+///
+/// This function returns an error if the description contains any byte with the value `\0` (since
+/// it cannot be converted to a C string), or if the internal index writing operation fails.
+pub fn write_index_binary<I, P>(index: &I, file_name: P) -> Result<()>
+where
+    I: NativeIndexBinary,
+    I: CpuIndexBinary,
+    P: AsRef<str>,
+{
+    unsafe {
+        let f = file_name.as_ref();
+        let f = CString::new(f).map_err(|_| Error::BadFilePath)?;
+
+        faiss_try(faiss_write_index_binary_fname(
+            index.inner_ptr(),
+            f.as_ptr(),
+        ))?;
+        Ok(())
+    }
+}
+
 /// Read an index from a file.
 ///
 /// # Error
@@ -54,6 +81,29 @@ where
     }
 }
 
+/// Read a binary index from a file.
+///
+/// # Error
+///
+/// This function returns an error if the description contains any byte with the value `\0` (since
+/// it cannot be converted to a C string), or if the internal index reading operation fails.
+pub fn read_index_binary<P>(file_name: P) -> Result<BinaryIndexImpl>
+where
+    P: AsRef<str>,
+{
+    unsafe {
+        let f = file_name.as_ref();
+        let f = CString::new(f).map_err(|_| Error::BadFilePath)?;
+        let mut inner = ptr::null_mut();
+        faiss_try(faiss_read_index_binary_fname(
+            f.as_ptr(),
+            IoFlags::MEM_RESIDENT.into(),
+            &mut inner,
+        ))?;
+        Ok(BinaryIndexImpl::from_inner_ptr(inner))
+    }
+}
+
 /// Read an index from a file with I/O flags.
 ///
 /// You can memory map some index types with this.
@@ -79,6 +129,31 @@ where
     }
 }
 
+/// Read a binary index from a file with I/O flags.
+///
+/// You can memory map some index types with this.
+///
+/// # Error
+///
+/// This function returns an error if the description contains any byte with the value `\0` (since
+/// it cannot be converted to a C string), or if the internal index reading operation fails.
+pub fn read_index_binary_with_flags<P>(file_name: P, io_flags: IoFlags) -> Result<BinaryIndexImpl>
+where
+    P: AsRef<str>,
+{
+    unsafe {
+        let f = file_name.as_ref();
+        let f = CString::new(f).map_err(|_| Error::BadFilePath)?;
+        let mut inner = ptr::null_mut();
+        faiss_try(faiss_read_index_binary_fname(
+            f.as_ptr(),
+            io_flags.0 as c_int,
+            &mut inner,
+        ))?;
+        Ok(BinaryIndexImpl::from_inner_ptr(inner))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;