Improve RefineFlatIndex

src/index/flat.rs

@@ -147,7 +147,14 @@ impl TryFromInnerPtr for FlatIndexImpl {
 
 impl_native_index!(FlatIndex);
 
-impl TryClone for FlatIndexImpl {}
+impl TryClone for FlatIndexImpl {
+    fn try_clone(&self) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        try_clone_from_inner_ptr(self)
+    }
+}
 
 impl_concurrent_index!(FlatIndexImpl);
 

src/index/ivf_flat.rs

@@ -5,7 +5,7 @@ use super::*;
 use crate::error::Result;
 use crate::faiss_try;
 use std::mem;
-use std::os::raw::{c_int, c_char};
+use std::os::raw::{c_char, c_int};
 use std::ptr;
 
 /// Alias for the native implementation of a flat index.
@@ -142,7 +142,14 @@ impl FromInnerPtr for IVFFlatIndexImpl {
 
 impl_native_index!(IVFFlatIndex);
 
-impl TryClone for IVFFlatIndexImpl {}
+impl TryClone for IVFFlatIndexImpl {
+    fn try_clone(&self) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        try_clone_from_inner_ptr(self)
+    }
+}
 
 impl_concurrent_index!(IVFFlatIndexImpl);
 

src/index/lsh.rs

@@ -1,8 +1,8 @@
 //! Interface and implementation to Locality-Sensitive Hashing (LSH) index type.
 
 use super::{
-    AssignSearchResult, CpuIndex, FromInnerPtr, Idx, Index, IndexImpl, NativeIndex,
-    RangeSearchResult, SearchResult, TryClone, TryFromInnerPtr,
+    try_clone_from_inner_ptr, AssignSearchResult, CpuIndex, FromInnerPtr, Idx, Index, IndexImpl,
+    NativeIndex, RangeSearchResult, SearchResult, TryClone, TryFromInnerPtr,
 };
 use crate::error::{Error, Result};
 use crate::faiss_try;
@@ -113,7 +113,14 @@ impl LshIndex {
 
 impl_native_index!(LshIndex);
 
-impl TryClone for LshIndex {}
+impl TryClone for LshIndex {
+    fn try_clone(&self) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        try_clone_from_inner_ptr(self)
+    }
+}
 
 impl IndexImpl {
     /// Attempt a dynamic cast of an index to the LSH index type.

src/index/mod.rs

@@ -336,7 +336,7 @@ pub trait TryFromInnerPtr: NativeIndex {
 }
 
 /// A trait which provides a Clone implementation to native index types.
-pub trait TryClone: FromInnerPtr {
+pub trait TryClone {
     /// Create an independent clone of this index.
     ///
     /// # Errors
@@ -345,13 +345,17 @@ pub trait TryClone: FromInnerPtr {
     /// supported for the internal type of index.
     fn try_clone(&self) -> Result<Self>
     where
-        Self: Sized,
-    {
-        unsafe {
-            let mut new_index_ptr = ::std::ptr::null_mut();
-            faiss_try(faiss_clone_index(self.inner_ptr(), &mut new_index_ptr))?;
-            Ok(crate::index::FromInnerPtr::from_inner_ptr(new_index_ptr))
-        }
+        Self: Sized;
+}
+
+pub fn try_clone_from_inner_ptr<T>(val: &T) -> Result<T>
+where
+    T: FromInnerPtr,
+{
+    unsafe {
+        let mut new_index_ptr = ::std::ptr::null_mut();
+        faiss_try(faiss_clone_index(val.inner_ptr(), &mut new_index_ptr))?;
+        Ok(crate::index::FromInnerPtr::from_inner_ptr(new_index_ptr))
     }
 }
 
@@ -532,7 +536,14 @@ impl<NI: NativeIndex> UpcastIndex for NI {
 
 impl_native_index!(IndexImpl);
 
-impl TryClone for IndexImpl {}
+impl TryClone for IndexImpl {
+    fn try_clone(&self) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        try_clone_from_inner_ptr(self)
+    }
+}
 
 /// Use the index factory to create a native instance of a Faiss index, for `d`-dimensional
 /// vectors. `description` should follow the exact guidelines as the native Faiss interface

src/index/pretransform.rs

@@ -89,7 +89,7 @@ impl<I> NativeIndex for PreTransformIndexImpl<I> {
     }
 }
 
-impl<I> FromInnerPtr for PreTransformIndexImpl<I> {
+impl FromInnerPtr for PreTransformIndexImpl<IndexImpl> {
     unsafe fn from_inner_ptr(inner_ptr: *mut FaissIndex) -> Self {
         PreTransformIndexImpl {
             inner: inner_ptr as *mut FaissIndexPreTransform,
@@ -218,7 +218,21 @@ impl<I> Index for PreTransformIndexImpl<I> {
     }
 }
 
-impl<I: TryClone> TryClone for PreTransformIndexImpl<I> {}
+impl<I> TryClone for PreTransformIndexImpl<I> {
+    fn try_clone(&self) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        unsafe {
+            let mut new_index_ptr = ::std::ptr::null_mut();
+            faiss_try(faiss_clone_index(self.inner_ptr(), &mut new_index_ptr))?;
+            Ok(PreTransformIndexImpl {
+                inner: new_index_ptr as *mut FaissIndexPreTransform,
+                sub_index: PhantomData,
+            })
+        }
+    }
+}
 
 impl<I> ConcurrentIndex for PreTransformIndexImpl<I>
 where

src/index/refine_flat.rs

@@ -71,7 +71,7 @@ impl<BI> NativeIndex for RefineFlatIndexImpl<BI> {
     }
 }
 
-impl<BI> FromInnerPtr for RefineFlatIndexImpl<BI> {
+impl FromInnerPtr for RefineFlatIndexImpl<IndexImpl> {
     unsafe fn from_inner_ptr(inner_ptr: *mut FaissIndex) -> Self {
         RefineFlatIndexImpl {
             inner: inner_ptr as *mut FaissIndexFlat,
@@ -80,6 +80,28 @@ impl<BI> FromInnerPtr for RefineFlatIndexImpl<BI> {
     }
 }
 
+impl TryFromInnerPtr for RefineFlatIndexImpl<IndexImpl> {
+    unsafe fn try_from_inner_ptr(inner_ptr: *mut FaissIndex) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        // safety: `inner_ptr` is documented to be a valid pointer to an index,
+        // so the dynamic cast should be safe.
+        #[allow(unused_unsafe)]
+        unsafe {
+            let new_inner = faiss_IndexRefineFlat_cast(inner_ptr);
+            if new_inner.is_null() {
+                Err(Error::BadCast)
+            } else {
+                Ok(RefineFlatIndexImpl {
+                    inner: new_inner,
+                    base_index: PhantomData,
+                })
+            }
+        }
+    }
+}
+
 impl<BI> Index for RefineFlatIndexImpl<BI> {
     fn is_trained(&self) -> bool {
         unsafe { faiss_Index_is_trained(self.inner_ptr()) != 0 }
@@ -200,7 +222,21 @@ impl<BI> Index for RefineFlatIndexImpl<BI> {
     }
 }
 
-impl<BI: TryClone> TryClone for RefineFlatIndexImpl<BI> {}
+impl<I> TryClone for RefineFlatIndexImpl<I> {
+    fn try_clone(&self) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        unsafe {
+            let mut new_index_ptr = ::std::ptr::null_mut();
+            faiss_try(faiss_clone_index(self.inner_ptr(), &mut new_index_ptr))?;
+            Ok(RefineFlatIndexImpl {
+                inner: new_index_ptr as *mut FaissIndexFlat,
+                base_index: PhantomData,
+            })
+        }
+    }
+}
 
 impl<BI> ConcurrentIndex for RefineFlatIndexImpl<BI>
 where

src/index/scalar_quantizer.rs

@@ -105,7 +105,14 @@ impl FromInnerPtr for ScalarQuantizerIndexImpl {
 
 impl_native_index!(ScalarQuantizerIndexImpl);
 
-impl TryClone for ScalarQuantizerIndexImpl {}
+impl TryClone for ScalarQuantizerIndexImpl {
+    fn try_clone(&self) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        try_clone_from_inner_ptr(self)
+    }
+}
 
 impl IndexImpl {
     /// Attempt a dynamic cast of an index to the Scalar Quantizer index type.
@@ -274,7 +281,7 @@ impl<Q> NativeIndex for IVFScalarQuantizerIndexImpl<Q> {
     }
 }
 
-impl<Q> FromInnerPtr for IVFScalarQuantizerIndexImpl<Q> {
+impl FromInnerPtr for IVFScalarQuantizerIndexImpl<IndexImpl> {
     unsafe fn from_inner_ptr(inner_ptr: *mut FaissIndex) -> Self {
         IVFScalarQuantizerIndexImpl {
             inner: inner_ptr as *mut FaissIndexIVFScalarQuantizer,
@@ -403,7 +410,21 @@ impl<Q> Index for IVFScalarQuantizerIndexImpl<Q> {
     }
 }
 
-impl<Q: TryClone> TryClone for IVFScalarQuantizerIndexImpl<Q> {}
+impl<Q> TryClone for IVFScalarQuantizerIndexImpl<Q> {
+    fn try_clone(&self) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        unsafe {
+            let mut new_index_ptr = ::std::ptr::null_mut();
+            faiss_try(faiss_clone_index(self.inner_ptr(), &mut new_index_ptr))?;
+            Ok(IVFScalarQuantizerIndexImpl {
+                inner: new_index_ptr as *mut FaissIndexIVFScalarQuantizer,
+                quantizer: PhantomData,
+            })
+        }
+    }
+}
 
 impl<Q> ConcurrentIndex for IVFScalarQuantizerIndexImpl<Q>
 where