RSCBC-256: Add some idiomatic functionality to collections ds

Author: chvck

sdk/couchbase/src/collection_ds.rs

@@ -62,9 +62,9 @@ use tracing::Instrument;
 /// ```
 #[derive(Clone)]
 pub struct CouchbaseList<'a> {
-    pub collection: &'a Collection,
-    pub id: String,
-    pub options: CouchbaseListOptions,
+    collection: &'a Collection,
+    id: String,
+    options: CouchbaseListOptions,
 }
 
 impl Collection {
@@ -250,11 +250,11 @@ impl CouchbaseList<'_> {
         result
     }
 
-    /// Returns the index of the first occurrence of the given value, or `-1` if not found.
+    /// Returns the index of the first occurrence of the given value, or `None` if not found.
     pub async fn position<V: PartialEq + DeserializeOwned>(
         &self,
-        value: V,
-    ) -> crate::error::Result<isize> {
+        value: &V,
+    ) -> crate::error::Result<Option<usize>> {
         let ctx = self
             .collection
             .tracing_client
@@ -267,12 +267,7 @@ impl CouchbaseList<'_> {
         let result = async {
             let get_res = self.collection.get(&self.id, None).await?;
             let list_contents: Vec<V> = get_res.content_as()?;
-            for (i, item) in list_contents.iter().enumerate() {
-                if *item == value {
-                    return Ok(i as isize);
-                }
-            }
-            Ok(-1)
+            Ok(list_contents.iter().position(|item| item == value))
         }
         .instrument(ctx.span().clone())
         .await;
@@ -304,6 +299,11 @@ impl CouchbaseList<'_> {
         result
     }
 
+    /// Returns `true` if the list contains no elements.
+    pub async fn is_empty(&self) -> crate::error::Result<bool> {
+        Ok(self.len().await? == 0)
+    }
+
     /// Removes all elements from the list by deleting the backing document.
     pub async fn clear(&self) -> crate::error::Result<()> {
         let ctx = self
@@ -331,9 +331,9 @@ impl CouchbaseList<'_> {
 /// Supports get, insert, remove, keys, values, exists, size, clear, and iteration.
 #[derive(Clone)]
 pub struct CouchbaseMap<'a> {
-    pub collection: &'a Collection,
-    pub id: String,
-    pub options: CouchbaseMapOptions,
+    collection: &'a Collection,
+    id: String,
+    options: CouchbaseMapOptions,
 }
 
 impl CouchbaseMap<'_> {
@@ -487,6 +487,11 @@ impl CouchbaseMap<'_> {
         result
     }
 
+    /// Returns `true` if the map contains no entries.
+    pub async fn is_empty(&self) -> crate::error::Result<bool> {
+        Ok(self.len().await? == 0)
+    }
+
     /// Returns all keys in the map.
     pub async fn keys(&self) -> crate::error::Result<Vec<String>> {
         let ctx = self
@@ -559,9 +564,9 @@ impl CouchbaseMap<'_> {
 /// Duplicate values are silently ignored.
 #[derive(Clone)]
 pub struct CouchbaseSet<'a> {
-    pub collection: &'a Collection,
-    pub id: String,
-    pub options: CouchbaseSetOptions,
+    collection: &'a Collection,
+    id: String,
+    options: CouchbaseSetOptions,
 }
 
 impl CouchbaseSet<'_> {
@@ -709,7 +714,7 @@ impl CouchbaseSet<'_> {
     /// Returns `true` if the set contains the given value.
     pub async fn contains<T: PartialEq + DeserializeOwned>(
         &self,
-        value: T,
+        value: &T,
     ) -> crate::error::Result<bool> {
         let ctx = self
             .collection
@@ -723,12 +728,7 @@ impl CouchbaseSet<'_> {
         let result = async {
             let res = self.collection.get(&self.id, None).await?;
             let set_contents: Vec<T> = res.content_as()?;
-            for item in set_contents {
-                if item == value {
-                    return Ok(true);
-                }
-            }
-            Ok(false)
+            Ok(set_contents.iter().any(|item| item == value))
         }
         .instrument(ctx.span().clone())
         .await;
@@ -760,6 +760,11 @@ impl CouchbaseSet<'_> {
         result
     }
 
+    /// Returns `true` if the set contains no elements.
+    pub async fn is_empty(&self) -> crate::error::Result<bool> {
+        Ok(self.len().await? == 0)
+    }
+
     /// Removes all elements from the set by deleting the backing document.
     pub async fn clear(&self) -> crate::error::Result<()> {
         let ctx = self
@@ -787,9 +792,9 @@ impl CouchbaseSet<'_> {
 /// Supports push, pop, size, clear, and iteration.
 #[derive(Clone)]
 pub struct CouchbaseQueue<'a> {
-    pub collection: &'a Collection,
-    pub id: String,
-    pub options: CouchbaseQueueOptions,
+    collection: &'a Collection,
+    id: String,
+    options: CouchbaseQueueOptions,
 }
 
 impl CouchbaseQueue<'_> {
@@ -917,6 +922,11 @@ impl CouchbaseQueue<'_> {
         result
     }
 
+    /// Returns `true` if the queue contains no elements.
+    pub async fn is_empty(&self) -> crate::error::Result<bool> {
+        Ok(self.len().await? == 0)
+    }
+
     /// Removes all elements from the queue by deleting the backing document.
     pub async fn clear(&self) -> crate::error::Result<()> {
         let ctx = self

sdk/couchbase/tests/data_structures.rs

@@ -34,8 +34,8 @@ fn test_list() {
         list.append("test2").await.unwrap();
         list.prepend("test1").await.unwrap();
 
-        let index = list.position("test2".to_string()).await.unwrap();
-        assert_eq!(index, 1);
+        let index = list.position(&"test2".to_string()).await.unwrap();
+        assert_eq!(index, Some(1));
 
         let size = list.len().await.unwrap();
         assert_eq!(size, 2);
@@ -57,6 +57,49 @@ fn test_list() {
     })
 }
 
+#[test]
+fn test_list_is_empty() {
+    run_test(async |cluster, bucket| {
+        let collection = bucket
+            .scope(cluster.default_scope())
+            .collection(cluster.default_collection());
+        let key = new_key();
+
+        let list = collection.list(&key, None);
+
+        list.append("item").await.unwrap();
+
+        let res = list.is_empty().await.unwrap();
+        assert!(!res);
+
+        list.remove(0).await.unwrap();
+
+        let res = list.is_empty().await.unwrap();
+        assert!(res);
+
+        list.clear().await.unwrap();
+    })
+}
+
+#[test]
+fn test_list_position_not_found() {
+    run_test(async |cluster, bucket| {
+        let collection = bucket
+            .scope(cluster.default_scope())
+            .collection(cluster.default_collection());
+        let key = new_key();
+
+        let list = collection.list(&key, None);
+
+        list.append("a").await.unwrap();
+
+        let res = list.position(&"z".to_string()).await.unwrap();
+        assert_eq!(res, None);
+
+        list.clear().await.unwrap();
+    })
+}
+
 #[test]
 fn test_map() {
     run_test(async |cluster, bucket| {
@@ -111,6 +154,30 @@ fn test_map() {
     })
 }
 
+#[test]
+fn test_map_is_empty() {
+    run_test(async |cluster, bucket| {
+        let collection = bucket
+            .scope(cluster.default_scope())
+            .collection(cluster.default_collection());
+        let key = new_key();
+
+        let map = collection.map(&key, None);
+
+        map.insert("k", "v").await.unwrap();
+
+        let res = map.is_empty().await.unwrap();
+        assert!(!res);
+
+        map.remove("k").await.unwrap();
+
+        let res = map.is_empty().await.unwrap();
+        assert!(res);
+
+        map.clear().await.unwrap();
+    })
+}
+
 #[test]
 fn test_set() {
     run_test(async |cluster, bucket| {
@@ -131,7 +198,7 @@ fn test_set() {
         let res: Vec<String> = set.values().await.unwrap();
         assert_eq!(res, vec!["test1", "test2"]);
 
-        let res = set.contains("test1".to_string()).await.unwrap();
+        let res = set.contains(&"test1".to_string()).await.unwrap();
         assert!(res);
 
         let mut iter = set.iter::<String>().await.unwrap();
@@ -141,7 +208,7 @@ fn test_set() {
 
         set.remove("test1".to_string()).await.unwrap();
 
-        let res = set.contains("test1".to_string()).await.unwrap();
+        let res = set.contains(&"test1".to_string()).await.unwrap();
         assert!(!res);
 
         set.clear().await.unwrap();
@@ -151,6 +218,30 @@ fn test_set() {
     })
 }
 
+#[test]
+fn test_set_is_empty() {
+    run_test(async |cluster, bucket| {
+        let collection = bucket
+            .scope(cluster.default_scope())
+            .collection(cluster.default_collection());
+        let key = new_key();
+
+        let set = collection.set(&key, None);
+
+        set.insert("only").await.unwrap();
+
+        let res = set.is_empty().await.unwrap();
+        assert!(!res);
+
+        set.remove("only".to_string()).await.unwrap();
+
+        let res = set.is_empty().await.unwrap();
+        assert!(res);
+
+        set.clear().await.unwrap();
+    })
+}
+
 #[test]
 fn test_queue() {
     run_test(async |cluster, bucket| {
@@ -181,3 +272,27 @@ fn test_queue() {
         assert!(!res.exists());
     })
 }
+
+#[test]
+fn test_queue_is_empty() {
+    run_test(async |cluster, bucket| {
+        let collection = bucket
+            .scope(cluster.default_scope())
+            .collection(cluster.default_collection());
+        let key = new_key();
+
+        let queue = collection.queue(&key, None);
+
+        queue.push("item").await.unwrap();
+
+        let res = queue.is_empty().await.unwrap();
+        assert!(!res);
+
+        let _: String = queue.pop().await.unwrap();
+
+        let res = queue.is_empty().await.unwrap();
+        assert!(res);
+
+        queue.clear().await.unwrap();
+    })
+}