add WorkerOperations and InstanceViewOperations for name conflicts

usamoi · usamoi · commit 1f876080d197 · 2024-02-19T17:20:52.000+08:00
Signed-off-by: usamoi &lt;usamoi@outlook.com&gt;
diff --git a/crates/service/src/instance/mod.rs b/crates/service/src/instance/mod.rs
@@ -10,6 +10,22 @@ use crate::prelude::*;
 use std::path::PathBuf;
 use std::sync::Arc;
 
+pub trait InstanceViewOperations {
+    fn basic<'a, F: Fn(Pointer) -> bool + Clone + 'a>(
+        &'a self,
+        vector: &'a DynamicVector,
+        opts: &'a SearchOptions,
+        filter: F,
+    ) -> Result<Box<dyn Iterator<Item = Pointer> + 'a>, BasicError>;
+    fn vbase<'a, F: FnMut(Pointer) -> bool + Clone + 'a>(
+        &'a self,
+        vector: &'a DynamicVector,
+        opts: &'a SearchOptions,
+        filter: F,
+    ) -> Result<Box<dyn Iterator<Item = Pointer> + 'a>, VbaseError>;
+    fn list(&self) -> Result<Box<dyn Iterator<Item = Pointer> + '_>, ListError>;
+}
+
 #[derive(Clone)]
 pub enum Instance {
     F32Cos(Arc<Index<F32Cos>>),
@@ -149,8 +165,8 @@ pub enum InstanceView {
     SparseF32L2(Arc<IndexView<SparseF32L2>>),
 }
 
-impl InstanceView {
-    pub fn _basic<'a, F: Fn(Pointer) -> bool + Clone + 'a>(
+impl InstanceViewOperations for InstanceView {
+    fn basic<'a, F: Fn(Pointer) -> bool + Clone + 'a>(
         &'a self,
         vector: &'a DynamicVector,
         opts: &'a SearchOptions,
@@ -187,7 +203,7 @@ impl InstanceView {
             _ => Err(BasicError::InvalidVector),
         }
     }
-    pub fn _vbase<'a, F: FnMut(Pointer) -> bool + Clone + 'a>(
+    fn vbase<'a, F: FnMut(Pointer) -> bool + Clone + 'a>(
         &'a self,
         vector: &'a DynamicVector,
         opts: &'a SearchOptions,
@@ -224,7 +240,7 @@ impl InstanceView {
             _ => Err(VbaseError::InvalidVector),
         }
     }
-    pub fn _list(&self) -> Result<Box<dyn Iterator<Item = Pointer> + '_>, ListError> {
+    fn list(&self) -> Result<Box<dyn Iterator<Item = Pointer> + '_>, ListError> {
         match self {
             InstanceView::F32Cos(x) => Ok(Box::new(x.list()?) as Box<dyn Iterator<Item = Pointer>>),
             InstanceView::F32Dot(x) => Ok(Box::new(x.list()?)),
@@ -237,6 +253,9 @@ impl InstanceView {
             InstanceView::SparseF32L2(x) => Ok(Box::new(x.list()?)),
         }
     }
+}
+
+impl InstanceView {
     pub fn insert(
         &self,
         vector: DynamicVector,
diff --git a/crates/service/src/worker/mod.rs b/crates/service/src/worker/mod.rs
@@ -1,7 +1,7 @@
 pub mod metadata;
 
 use crate::index::{IndexOptions, IndexStat};
-use crate::instance::{Instance, InstanceView};
+use crate::instance::{Instance, InstanceView, InstanceViewOperations};
 use crate::prelude::*;
 use crate::utils::clean::clean;
 use crate::utils::dir_ops::sync_dir;
@@ -13,6 +13,25 @@ use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
 use std::sync::Arc;
 
+pub trait WorkerOperations {
+    type InstanceView: InstanceViewOperations;
+
+    fn create(&self, handle: Handle, options: IndexOptions) -> Result<(), CreateError>;
+    fn drop(&self, handle: Handle) -> Result<(), DropError>;
+    fn flush(&self, handle: Handle) -> Result<(), FlushError>;
+    fn insert(
+        &self,
+        handle: Handle,
+        vector: DynamicVector,
+        pointer: Pointer,
+    ) -> Result<(), InsertError>;
+    fn delete(&self, handle: Handle, pointer: Pointer) -> Result<(), DeleteError>;
+    fn basic_view(&self, handle: Handle) -> Result<Self::InstanceView, BasicError>;
+    fn vbase_view(&self, handle: Handle) -> Result<Self::InstanceView, VbaseError>;
+    fn list_view(&self, handle: Handle) -> Result<Self::InstanceView, ListError>;
+    fn stat(&self, handle: Handle) -> Result<IndexStat, StatError>;
+}
+
 pub struct Worker {
     path: PathBuf,
     protect: Mutex<WorkerProtect>,
@@ -65,7 +84,12 @@ impl Worker {
     pub fn view(&self) -> Arc<WorkerView> {
         self.view.load_full()
     }
-    pub fn _create(&self, handle: Handle, options: IndexOptions) -> Result<(), CreateError> {
+}
+
+impl WorkerOperations for Worker {
+    type InstanceView = InstanceView;
+
+    fn create(&self, handle: Handle, options: IndexOptions) -> Result<(), CreateError> {
         use std::collections::hash_map::Entry;
         let mut protect = self.protect.lock();
         match protect.indexes.entry(handle) {
@@ -79,7 +103,7 @@ impl Worker {
             Entry::Occupied(_) => Err(CreateError::Exist),
         }
     }
-    pub fn _drop(&self, handle: Handle) -> Result<(), DropError> {
+    fn drop(&self, handle: Handle) -> Result<(), DropError> {
         let mut protect = self.protect.lock();
         if protect.indexes.remove(&handle).is_some() {
             protect.maintain(&self.view);
@@ -88,14 +112,14 @@ impl Worker {
             Err(DropError::NotExist)
         }
     }
-    pub fn _flush(&self, handle: Handle) -> Result<(), FlushError> {
+    fn flush(&self, handle: Handle) -> Result<(), FlushError> {
         let view = self.view();
         let instance = view.get(handle).ok_or(FlushError::NotExist)?;
         let view = instance.view().ok_or(FlushError::Upgrade)?;
         view.flush()?;
         Ok(())
     }
-    pub fn _insert(
+    fn insert(
         &self,
         handle: Handle,
         vector: DynamicVector,
@@ -112,29 +136,29 @@ impl Worker {
         }
         Ok(())
     }
-    pub fn _delete(&self, handle: Handle, pointer: Pointer) -> Result<(), DeleteError> {
+    fn delete(&self, handle: Handle, pointer: Pointer) -> Result<(), DeleteError> {
         let view = self.view();
         let instance = view.get(handle).ok_or(DeleteError::NotExist)?;
         let view = instance.view().ok_or(DeleteError::Upgrade)?;
         view.delete(pointer)?;
         Ok(())
     }
-    pub fn _basic_view(&self, handle: Handle) -> Result<InstanceView, BasicError> {
+    fn basic_view(&self, handle: Handle) -> Result<InstanceView, BasicError> {
         let view = self.view();
         let instance = view.get(handle).ok_or(BasicError::NotExist)?;
         instance.view().ok_or(BasicError::Upgrade)
     }
-    pub fn _vbase_view(&self, handle: Handle) -> Result<InstanceView, VbaseError> {
+    fn vbase_view(&self, handle: Handle) -> Result<InstanceView, VbaseError> {
         let view = self.view();
         let instance = view.get(handle).ok_or(VbaseError::NotExist)?;
         instance.view().ok_or(VbaseError::Upgrade)
     }
-    pub fn _list_view(&self, handle: Handle) -> Result<InstanceView, ListError> {
+    fn list_view(&self, handle: Handle) -> Result<InstanceView, ListError> {
         let view = self.view();
         let instance = view.get(handle).ok_or(ListError::NotExist)?;
         instance.view().ok_or(ListError::Upgrade)
     }
-    pub fn _stat(&self, handle: Handle) -> Result<IndexStat, StatError> {
+    fn stat(&self, handle: Handle) -> Result<IndexStat, StatError> {
         let view = self.view();
         let instance = view.get(handle).ok_or(StatError::NotExist)?;
         let stat = instance.stat().ok_or(StatError::Upgrade)?;
diff --git a/src/bgworker/normal.rs b/src/bgworker/normal.rs
@@ -59,48 +59,50 @@ pub fn normal(worker: Arc<Worker>) {
 
 fn session(worker: Arc<Worker>, handler: ServerRpcHandler) -> Result<!, ConnectionError> {
     use crate::ipc::ServerRpcHandle;
+    use service::instance::InstanceViewOperations;
+    use service::worker::WorkerOperations;
     let mut handler = handler;
     loop {
         match handler.handle()? {
             // control plane
             ServerRpcHandle::Create { handle, options, x } => {
-                handler = x.leave(worker._create(handle, options))?;
+                handler = x.leave(WorkerOperations::create(worker.as_ref(), handle, options))?;
             }
             ServerRpcHandle::Drop { handle, x } => {
-                handler = x.leave(worker._drop(handle))?;
+                handler = x.leave(WorkerOperations::drop(worker.as_ref(), handle))?;
             }
             // data plane
             ServerRpcHandle::Flush { handle, x } => {
-                handler = x.leave(worker._flush(handle))?;
+                handler = x.leave(worker.flush(handle))?;
             }
             ServerRpcHandle::Insert {
                 handle,
                 vector,
                 pointer,
                 x,
             } => {
-                handler = x.leave(worker._insert(handle, vector, pointer))?;
+                handler = x.leave(worker.insert(handle, vector, pointer))?;
             }
             ServerRpcHandle::Delete { handle, pointer, x } => {
-                handler = x.leave(worker._delete(handle, pointer))?;
+                handler = x.leave(worker.delete(handle, pointer))?;
             }
             ServerRpcHandle::Stat { handle, x } => {
-                handler = x.leave(worker._stat(handle))?;
+                handler = x.leave(worker.stat(handle))?;
             }
             ServerRpcHandle::Basic {
                 handle,
                 vector,
                 opts,
                 x,
             } => {
-                let v = match worker._basic_view(handle) {
+                let v = match worker.basic_view(handle) {
                     Ok(x) => x,
                     Err(e) => {
                         handler = x.error_err(e)?;
                         continue;
                     }
                 };
-                match v._basic(&vector, &opts, |_| true) {
+                match v.basic(&vector, &opts, |_| true) {
                     Ok(mut iter) => {
                         use crate::ipc::ServerBasicHandle;
                         let mut x = x.error_ok()?;
@@ -125,14 +127,14 @@ fn session(worker: Arc<Worker>, handler: ServerRpcHandler) -> Result<!, Connecti
                 opts,
                 x,
             } => {
-                let v = match worker._vbase_view(handle) {
+                let v = match worker.vbase_view(handle) {
                     Ok(x) => x,
                     Err(e) => {
                         handler = x.error_err(e)?;
                         continue;
                     }
                 };
-                match v._vbase(&vector, &opts, |_| true) {
+                match v.vbase(&vector, &opts, |_| true) {
                     Ok(mut iter) => {
                         use crate::ipc::ServerVbaseHandle;
                         let mut x = x.error_ok()?;
@@ -152,14 +154,14 @@ fn session(worker: Arc<Worker>, handler: ServerRpcHandler) -> Result<!, Connecti
                 };
             }
             ServerRpcHandle::List { handle, x } => {
-                let v = match worker._list_view(handle) {
+                let v = match worker.list_view(handle) {
                     Ok(x) => x,
                     Err(e) => {
                         handler = x.error_err(e)?;
                         continue;
                     }
                 };
-                match v._list() {
+                match v.list() {
                     Ok(mut iter) => {
                         use crate::ipc::ServerListHandle;
                         let mut x = x.error_ok()?;
