Rust functionalities added

Author: Nao-ris

src/collection.rs

@@ -0,0 +1,103 @@
+use crate::{
+    CblRef, Listener, ListenerToken, release, retain,
+    c_api::{
+        CBLCollection, CBLCollectionChange, CBLCollection_AddChangeListener, CBLCollection_Scope,
+        CBLCollection_Name, CBLCollection_Count,
+    },
+    scope::Scope,
+};
+
+pub static DEFAULT_NAME: &str = "_default";
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct Collection {
+    cbl_ref: *mut CBLCollection,
+}
+
+impl Collection {
+    pub(crate) fn retain(cbl_ref: *mut CBLCollection) -> Self {
+        Self {
+            cbl_ref: unsafe { retain(cbl_ref) },
+        }
+    }
+
+    /** Returns the scope of the collection. */
+    pub fn scope(&self) -> Scope {
+        unsafe { Scope::retain(CBLCollection_Scope(self.get_ref())) }
+    }
+
+    /** Returns the collection name. */
+    pub fn name(&self) -> String {
+        unsafe {
+            CBLCollection_Name(self.get_ref())
+                .to_string()
+                .unwrap_or_default()
+        }
+    }
+
+    /** Returns the number of documents in the collection. */
+    pub fn count(&self) -> u64 {
+        unsafe { CBLCollection_Count(self.get_ref()) }
+    }
+
+    /** Registers a collection change listener callback. It will be called after one or more documents are changed on disk. */
+    pub fn add_listener(
+        &mut self,
+        listener: CollectionChangeListener,
+    ) -> Listener<CollectionChangeListener> {
+        unsafe {
+            let listener = Box::new(listener);
+            let ptr = Box::into_raw(listener);
+
+            Listener::new(
+                ListenerToken {
+                    cbl_ref: CBLCollection_AddChangeListener(
+                        self.get_ref(),
+                        Some(c_collection_change_listener),
+                        ptr.cast(),
+                    ),
+                },
+                Box::from_raw(ptr),
+            )
+        }
+    }
+}
+
+impl CblRef for Collection {
+    type Output = *mut CBLCollection;
+    fn get_ref(&self) -> Self::Output {
+        self.cbl_ref
+    }
+}
+
+impl Drop for Collection {
+    fn drop(&mut self) {
+        unsafe { release(self.get_ref()) }
+    }
+}
+
+impl Clone for Collection {
+    fn clone(&self) -> Self {
+        Self::retain(self.get_ref())
+    }
+}
+
+/** A collection change listener callback, invoked after one or more documents are changed on disk. */
+type CollectionChangeListener = Box<dyn Fn(Collection, Vec<String>)>;
+
+#[no_mangle]
+unsafe extern "C" fn c_collection_change_listener(
+    context: *mut ::std::os::raw::c_void,
+    change: *const CBLCollectionChange,
+) {
+    let callback = context as *const CollectionChangeListener;
+    if let Some(change) = change.as_ref() {
+        let collection = Collection::retain(change.collection as *mut CBLCollection);
+        let doc_ids = std::slice::from_raw_parts(change.docIDs, change.numDocs as usize)
+            .iter()
+            .filter_map(|doc_id| doc_id.to_string())
+            .collect();
+
+        (*callback)(collection, doc_ids);
+    }
+}

src/database.rs

@@ -29,8 +29,14 @@ use crate::{
         CBL_DeleteDatabase, CBLEncryptionKey_FromPassword, FLString, kCBLMaintenanceTypeCompact,
         kCBLEncryptionNone, kCBLMaintenanceTypeFullOptimize, kCBLMaintenanceTypeIntegrityCheck,
         kCBLMaintenanceTypeOptimize, kCBLMaintenanceTypeReindex, CBL_CopyDatabase,
+        CBLDatabase_ScopeNames, CBLDatabase_CollectionNames, CBLDatabase_Scope,
+        CBLDatabase_Collection, CBLDatabase_CreateCollection, CBLDatabase_DeleteCollection,
+        CBLDatabase_DefaultScope, CBLDatabase_DefaultCollection,
     },
     Listener, check_error, Error, CouchbaseLiteError,
+    collection::Collection,
+    scope::Scope,
+    MutableArray,
 };
 use std::path::{Path, PathBuf};
 use std::ptr;
@@ -89,7 +95,8 @@ enum_from_primitive! {
 }
 
 /** A database change listener callback, invoked after one or more documents are changed on disk. */
-type ChangeListener = Box<dyn Fn(&Database, Vec<String>)>;
+#[deprecated(note = "please use `CollectionChangeListener` on default collection instead")]
+type DatabaseChangeListener = Box<dyn Fn(&Database, Vec<String>)>;
 
 #[no_mangle]
 unsafe extern "C" fn c_database_change_listener(
@@ -98,7 +105,7 @@ unsafe extern "C" fn c_database_change_listener(
     num_docs: ::std::os::raw::c_uint,
     c_doc_ids: *mut FLString,
 ) {
-    let callback = context as *const ChangeListener;
+    let callback = context as *const DatabaseChangeListener;
     let database = Database::retain(db as *mut CBLDatabase);
 
     let doc_ids = std::slice::from_raw_parts(c_doc_ids, num_docs as usize)
@@ -324,10 +331,157 @@ impl Database {
     }
 
     /** Returns the number of documents in the database. */
+    #[deprecated(note = "please use `count` on the default collection instead")]
     pub fn count(&self) -> u64 {
         unsafe { CBLDatabase_Count(self.get_ref()) }
     }
 
+    /** Returns the names of all existing scopes in the database.
+    The scope exists when there is at least one collection created under the scope.
+    The default scope is exceptional in that it will always exists even there are no collections under it. */
+    pub fn scope_names(&self) -> Result<Vec<String>> {
+        let mut error = CBLError::default();
+        let array = unsafe { CBLDatabase_ScopeNames(self.get_ref(), &mut error) };
+
+        check_error(&error).map(|()| unsafe {
+            MutableArray::adopt(array)
+                .iter()
+                .map(|v| v.as_string().unwrap_or("").to_string())
+                .collect()
+        })
+    }
+
+    /** Returns the names of all collections in the scope. */
+    pub fn collection_names(&self, scope_name: String) -> Result<Vec<String>> {
+        let scope_name = from_str(&scope_name);
+        let mut error = CBLError::default();
+        let array = unsafe {
+            CBLDatabase_CollectionNames(self.get_ref(), scope_name.get_ref(), &mut error)
+        };
+
+        check_error(&error).map(|()| unsafe {
+            MutableArray::adopt(array)
+                .iter()
+                .map(|v| v.as_string().unwrap_or("").to_string())
+                .collect()
+        })
+    }
+
+    /** Returns an existing scope with the given name.
+    The scope exists when there is at least one collection created under the scope.
+    The default scope is exception in that it will always exists even there are no collections under it. */
+    pub fn scope(&self, scope_name: String) -> Result<Option<Scope>> {
+        let scope_name = from_str(&scope_name);
+        let mut error = CBLError::default();
+        let scope = unsafe { CBLDatabase_Scope(self.get_ref(), scope_name.get_ref(), &mut error) };
+
+        check_error(&error).map(|()| {
+            if scope.is_null() {
+                None
+            } else {
+                Some(Scope::retain(scope))
+            }
+        })
+    }
+
+    /** Returns the existing collection with the given name and scope. */
+    pub fn collection(
+        &self,
+        collection_name: String,
+        scope_name: String,
+    ) -> Result<Option<Collection>> {
+        let collection_name = from_str(&collection_name);
+        let scope_name = from_str(&scope_name);
+        let mut error = CBLError::default();
+        let collection = unsafe {
+            CBLDatabase_Collection(
+                self.get_ref(),
+                collection_name.get_ref(),
+                scope_name.get_ref(),
+                &mut error,
+            )
+        };
+
+        check_error(&error).map(|()| {
+            if collection.is_null() {
+                None
+            } else {
+                Some(Collection::retain(collection))
+            }
+        })
+    }
+
+    /** Create a new collection.
+    The naming rules of the collections and scopes are as follows:
+        - Must be between 1 and 251 characters in length.
+        - Can only contain the characters A-Z, a-z, 0-9, and the symbols _, -, and %.
+        - Cannot start with _ or %.
+        - Both scope and collection names are case sensitive.
+    If the collection already exists, the existing collection will be returned. */
+    pub fn create_collection(
+        &self,
+        collection_name: String,
+        scope_name: String,
+    ) -> Result<Collection> {
+        let collection_name = from_str(&collection_name);
+        let scope_name = from_str(&scope_name);
+        let mut error = CBLError::default();
+        let collection = unsafe {
+            CBLDatabase_CreateCollection(
+                self.get_ref(),
+                collection_name.get_ref(),
+                scope_name.get_ref(),
+                &mut error,
+            )
+        };
+
+        check_error(&error).map(|()| Collection::retain(collection))
+    }
+
+    /** Delete an existing collection.
+    @note  The default collection cannot be deleted.
+    @param db  The database.
+    @param collectionName  The name of the collection.
+    @param scopeName  The name of the scope.
+    @param outError  On failure, the error will be written here.
+    @return  True if success, or False if an error occurred. */
+    pub fn delete_collection(&self, collection_name: String, scope_name: String) -> Result<()> {
+        let collection_name = from_str(&collection_name);
+        let scope_name = from_str(&scope_name);
+        unsafe {
+            check_bool(|error| {
+                CBLDatabase_DeleteCollection(
+                    self.get_ref(),
+                    collection_name.get_ref(),
+                    scope_name.get_ref(),
+                    error,
+                )
+            })
+        }
+    }
+
+    /** Returns the default scope. */
+    pub fn default_scope(&self) -> Result<Scope> {
+        let mut error = CBLError::default();
+        let scope = unsafe { CBLDatabase_DefaultScope(self.get_ref(), &mut error) };
+
+        check_error(&error).map(|()| Scope::retain(scope))
+    }
+
+    /** Returns the default collection. */
+    pub fn default_collection(&self) -> Result<Option<Collection>> {
+        let mut error = CBLError::default();
+        let collection = unsafe { CBLDatabase_DefaultCollection(self.get_ref(), &mut error) };
+
+        check_error(&error).map(|()| {
+            if collection.is_null() {
+                None
+            } else {
+                Some(Collection::retain(collection))
+            }
+        })
+    }
+
     //////// NOTIFICATIONS:
 
     /** Registers a database change listener function. It will be called after one or more
@@ -340,7 +494,11 @@ impl Database {
         You must keep the `Listener` object as long as you need it.
     */
     #[must_use]
-    pub fn add_listener(&mut self, listener: ChangeListener) -> Listener<ChangeListener> {
+    #[deprecated(note = "please use `add_listener` on default collection instead")]
+    pub fn add_listener(
+        &mut self,
+        listener: DatabaseChangeListener,
+    ) -> Listener<DatabaseChangeListener> {
         unsafe {
             let listener = Box::new(listener);
             let ptr = Box::into_raw(listener);