refactor(deep_causality): updated TagIndex to use a HashSet to prevent duplicate tags.

Signed-off-by: Marvin Hansen <[email protected]>

Author: marvin-hansen

deep_causality/src/types/telos_types/tag_index/index.rs

@@ -4,11 +4,13 @@
  */
 
 use crate::{TagIndex, TeloidID, TeloidTag};
+use std::collections::HashSet;
 
 impl TagIndex {
     /// Adds a `TeloidID` to the index for a given `TeloidTag`.
     ///
     /// If the tag does not exist in the index, it will be added.
+    /// If the ID already exists for the given tag, it will not be added again.
     ///
     /// # Arguments
     ///
@@ -24,36 +26,42 @@ impl TagIndex {
     /// let tag = "test_tag";
     /// let id = 1;
     /// tag_index.add(tag, id);
+    /// tag_index.add(tag, id); // Duplicates are ignored
+    /// assert_eq!(tag_index.get(tag).unwrap().len(), 1);
     /// ```
     pub fn add(&mut self, tag: TeloidTag, id: TeloidID) {
-        self.index.entry(tag).or_default().push(id);
+        self.index.entry(tag).or_default().insert(id);
     }
 
-    /// Retrieves a vector of `TeloidID`s associated with a given `TeloidTag`.
+    /// Retrieves a reference to the set of `TeloidID`s associated with a given `TeloidTag`.
     ///
     /// # Arguments
     ///
     /// * `tag` - The `TeloidTag` to look up.
     ///
     /// # Returns
     ///
-    /// An `Option` containing a reference to the vector of `TeloidID`s if the tag exists,
+    /// An `Option` containing a reference to the `HashSet` of `TeloidID`s if the tag exists,
     /// otherwise `None`.
     ///
     /// # Examples
     ///
     /// ```
     /// use deep_causality::{TagIndex, TeloidTag, TeloidID};
+    /// use std::collections::HashSet;
     ///
     /// let mut tag_index = TagIndex::new();
     /// let tag = "test_tag";
     /// let id = 1;
-    /// tag_index.add(tag.clone(), id);
+    /// tag_index.add(tag, id);
+    ///
+    /// let mut expected = HashSet::new();
+    /// expected.insert(1);
     ///
     /// let ids = tag_index.get(tag);
-    /// assert_eq!(ids, Some(&vec![1]));
+    /// assert_eq!(ids, Some(&expected));
     /// ```
-    pub fn get(&self, tag: &str) -> Option<&Vec<TeloidID>> {
+    pub fn get(&self, tag: &str) -> Option<&HashSet<TeloidID>> {
         self.index.get(tag)
     }
 
@@ -74,12 +82,16 @@ impl TagIndex {
     /// let mut tag_index = TagIndex::new();
     /// let tag = "test_tag";
     /// let id = 1;
-    /// tag_index.add(tag.clone(), id);
+    /// tag_index.add(tag, id);
     /// tag_index.remove(tag, id);
+    /// assert!(tag_index.get(tag).is_none() || tag_index.get(tag).unwrap().is_empty());
     /// ```
     pub fn remove(&mut self, tag: &str, id: TeloidID) {
-        if let Some(v) = self.index.get_mut(tag) {
-            v.retain(|x| *x != id);
+        if let Some(set) = self.index.get_mut(tag) {
+            set.remove(&id);
+            if set.is_empty() {
+                self.index.remove(tag);
+            }
         }
     }
 
@@ -101,12 +113,13 @@ impl TagIndex {
     /// let tag = "test_tag";
     /// let id1 = 1;
     /// let id2 = 2;
-    /// tag_index.add(tag.clone(), id1);
+    /// tag_index.add(tag, id1);
     /// tag_index.update(tag, id2);
+    /// assert_eq!(tag_index.get(tag).unwrap().len(), 2);
     /// ```
     pub fn update(&mut self, tag: &str, id: TeloidID) {
         if let Some(v) = self.index.get_mut(tag) {
-            v.push(id);
+            v.insert(id);
         }
     }
 
@@ -127,7 +140,7 @@ impl TagIndex {
     ///
     /// let mut tag_index = TagIndex::new();
     /// let tag = "test_tag";
-    /// tag_index.add(tag.clone(), 1);
+    /// tag_index.add(tag, 1);
     ///
     /// assert!(tag_index.contains_key(tag));
     /// ```

deep_causality/src/types/telos_types/tag_index/mod.rs

@@ -4,14 +4,14 @@
  */
 
 use crate::{TeloidID, TeloidTag};
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 mod display;
 mod index;
 
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct TagIndex {
-    index: HashMap<TeloidTag, Vec<TeloidID>>,
+    index: HashMap<TeloidTag, HashSet<TeloidID>>,
 }
 
 impl TagIndex {

deep_causality/tests/types/telos_types/tag_index/tag_index_tests.rs

@@ -5,22 +5,23 @@
 
 use deep_causality::types::telos_types::tag_index::*;
 use deep_causality::{TeloidID, TeloidTag};
+use std::collections::HashSet;
 
 #[test]
 fn test_new_and_default() {
     let tag_index_new = TagIndex::new();
-    assert_eq!(tag_index_new.len(), 0);
+    assert!(tag_index_new.is_empty());
     assert!(tag_index_new.get("1").is_none());
 
     let tag_index_default = TagIndex::default();
-    assert_eq!(tag_index_default.len(), 0);
+    assert!(tag_index_default.is_empty());
     assert_eq!(tag_index_new, tag_index_default);
 }
 
 #[test]
 fn test_with_capacity() {
     let tag_index = TagIndex::with_capacity(10);
-    assert_eq!(tag_index.len(), 0);
+    assert!(tag_index.is_empty());
 }
 
 #[test]
@@ -32,28 +33,28 @@ fn test_add_and_get() {
     // 1. Add a single item
     tag_index.add(tag1, id1);
     assert_eq!(tag_index.len(), 1);
-    assert_eq!(tag_index.get(tag1), Some(&vec![id1]));
+    assert_eq!(tag_index.get(tag1), Some(&HashSet::from([id1])));
 
     // 2. Add another item to the same tag
     let id2: TeloidID = 102;
     tag_index.add(tag1, id2);
     assert_eq!(tag_index.len(), 1);
-    assert_eq!(tag_index.get(tag1), Some(&vec![id1, id2]));
+    assert_eq!(tag_index.get(tag1), Some(&HashSet::from([id1, id2])));
 
     // 3. Add a new tag
     let tag2: TeloidTag = "tag2";
     let id3: TeloidID = 103;
     tag_index.add(tag2, id3);
     assert_eq!(tag_index.len(), 2);
-    assert_eq!(tag_index.get(tag2), Some(&vec![id3]));
+    assert_eq!(tag_index.get(tag2), Some(&HashSet::from([id3])));
 
     // 4. Get a non-existent tag (corner case)
     let tag_non_existent: TeloidTag = "tag99";
     assert!(tag_index.get(tag_non_existent).is_none());
 }
 
 #[test]
-fn test_add_duplicate_id_edge_case() {
+fn test_add_duplicate_id_is_ignored() {
     let mut tag_index = TagIndex::new();
     let tag: TeloidTag = "tag1";
     let id: TeloidID = 101;
@@ -62,7 +63,12 @@ fn test_add_duplicate_id_edge_case() {
     tag_index.add(tag, id); // Add the exact same ID again
 
     assert_eq!(tag_index.len(), 1);
-    assert_eq!(tag_index.get(tag), Some(&vec![id, id]));
+    assert_eq!(tag_index.get(tag), Some(&HashSet::from([id])));
+    assert_eq!(
+        tag_index.get(tag).unwrap().len(),
+        1,
+        "HashSet should contain only one unique ID"
+    );
 }
 
 #[test]
@@ -76,22 +82,21 @@ fn test_remove() {
 
     // 1. Remove an existing ID
     tag_index.remove(tag1, id1);
-    assert_eq!(tag_index.get(tag1), Some(&vec![id2]));
+    assert_eq!(tag_index.get(tag1), Some(&HashSet::from([id2])));
 
     // 2. Remove a non-existent ID from an existing tag (corner case)
     tag_index.remove(tag1, 999);
-    assert_eq!(tag_index.get(tag1), Some(&vec![id2]));
+    assert_eq!(tag_index.get(tag1), Some(&HashSet::from([id2])));
 
-    // 3. Remove the last ID for a tag
+    // 3. Remove the last ID for a tag, which should remove the tag itself
     tag_index.remove(tag1, id2);
-    // The key should still exist with an empty vec, as per implementation
-    assert!(tag_index.contains_key(tag1));
-    assert_eq!(tag_index.get(tag1), Some(&vec![]));
+    assert!(!tag_index.contains_key(tag1));
+    assert!(tag_index.get(tag1).is_none());
 
     // 4. Remove an ID from a non-existent tag (corner case)
     let tag_non_existent: TeloidTag = "tag99";
     tag_index.remove(tag_non_existent, 999);
-    assert_eq!(tag_index.len(), 1); // Length should be unchanged
+    assert!(tag_index.is_empty()); // Length should be 0
 }
 
 #[test]
@@ -103,20 +108,20 @@ fn test_update() {
     // 1. Try to update a non-existent tag (edge case)
     tag_index.update(tag1, id1);
     assert!(!tag_index.contains_key(tag1));
-    assert_eq!(tag_index.len(), 0);
+    assert!(tag_index.is_empty());
 
     // 2. Add the tag first, then update
     tag_index.add(tag1, id1);
-    assert_eq!(tag_index.get(tag1), Some(&vec![id1]));
+    assert_eq!(tag_index.get(tag1), Some(&HashSet::from([id1])));
 
     let id2: TeloidID = 102;
     tag_index.update(tag1, id2);
     assert_eq!(tag_index.len(), 1);
-    assert_eq!(tag_index.get(tag1), Some(&vec![id1, id2]));
+    assert_eq!(tag_index.get(tag1), Some(&HashSet::from([id1, id2])));
 }
 
 #[test]
-fn test_check() {
+fn test_contains_key() {
     let mut tag_index = TagIndex::new();
     let tag1: TeloidTag = "tag1";
     let id1: TeloidID = 101;
@@ -128,9 +133,9 @@ fn test_check() {
     tag_index.add(tag1, id1);
     assert!(tag_index.contains_key(tag1));
 
-    // 3. Check after removing the only ID (key should still exist)
+    // 3. Check after removing the only ID (key should be removed)
     tag_index.remove(tag1, id1);
-    assert!(tag_index.contains_key(tag1));
+    assert!(!tag_index.contains_key(tag1));
 }
 
 #[test]
@@ -143,12 +148,12 @@ fn test_clear() {
 
     // 1. Clear the index
     tag_index.clear();
-    assert_eq!(tag_index.len(), 0);
+    assert!(tag_index.is_empty());
     assert!(!tag_index.contains_key("tag1"));
 
     // 2. Clear an already empty index (corner case)
     tag_index.clear();
-    assert_eq!(tag_index.len(), 0);
+    assert!(tag_index.is_empty());
 }
 
 #[test]
@@ -166,10 +171,14 @@ fn test_len() {
     tag_index.add("tag1", 102);
     assert_eq!(tag_index.len(), 2);
 
-    // Removing an ID doesn't change len
+    // Removing an ID from a tag with multiple IDs doesn't change len
     tag_index.remove("tag1", 101);
     assert_eq!(tag_index.len(), 2);
 
+    // Removing the last ID from a tag *does* change len
+    tag_index.remove("tag1", 102);
+    assert_eq!(tag_index.len(), 1);
+
     // Clearing changes len to 0
     tag_index.clear();
     assert_eq!(tag_index.len(), 0);