selfware 0.2.2

Your personal AI workshop — software you own, software that lasts
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::entry::Entry;
use std::collections::HashMap;

/// A key-value store with support for tags and metadata
#[derive(Debug, Clone)]
pub struct KvStore {
    entries: HashMap<String, Entry>,
}

impl KvStore {
    /// Creates a new empty store
    pub fn new() -> Self {
        Self {
            entries: HashMap::new(),
        }
    }

    /// Creates a store from an existing HashMap
    pub fn from_map(entries: HashMap<String, Entry>) -> Self {
        Self { entries }
    }

    /// Inserts a new entry into the store
    pub fn insert(&mut self, entry: Entry) -> Option<Entry> {
        let key = entry.key.clone();
        self.entries.insert(key, entry)
    }

    /// Retrieves an entry by key
    pub fn get(&self, key: &str) -> Option<&Entry> {
        self.entries.get(key)
    }

    /// Removes an entry by key and returns it
    pub fn remove(&mut self, key: &str) -> Option<Entry> {
        self.entries.remove(key)
    }

    /// Checks if an entry with the given key exists
    pub fn contains_key(&self, key: &str) -> bool {
        self.entries.contains_key(key)
    }

    /// Returns the number of entries in the store
    pub fn len(&self) -> usize {
        self.entries.len()
    }

    /// Returns true if the store is empty
    pub fn is_empty(&self) -> bool {
        self.entries.is_empty()
    }

    /// Returns an iterator over all entries
    pub fn iter(&self) -> impl Iterator<Item = &Entry> {
        self.entries.values()
    }

    /// Returns an iterator over all keys
    pub fn keys(&self) -> impl Iterator<Item = &String> {
        self.entries.keys()
    }

    /// Clears all entries from the store
    pub fn clear(&mut self) {
        self.entries.clear();
    }
}

impl Default for KvStore {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::entry::Entry;

    #[test]
    fn test_store_creation() {
        let store = KvStore::new();
        assert!(store.is_empty());
        assert_eq!(store.len(), 0);
    }

    #[test]
    fn test_insert_and_get() {
        let mut store = KvStore::new();
        let entry = Entry::new("key1", "value1");
        
        store.insert(entry.clone());
        assert_eq!(store.len(), 1);
        assert!(store.contains_key("key1"));
        
        let retrieved = store.get("key1");
        assert!(retrieved.is_some());
        assert_eq!(retrieved.unwrap().value, "value1");
    }

    #[test]
    fn test_remove() {
        let mut store = KvStore::new();
        let entry = Entry::new("key1", "value1");
        
        store.insert(entry);
        assert!(store.contains_key("key1"));
        
        let removed = store.remove("key1");
        assert!(removed.is_some());
        assert!(!store.contains_key("key1"));
        assert!(store.is_empty());
    }

    #[test]
    fn test_iter() {
        let mut store = KvStore::new();
        store.insert(Entry::new("key1", "value1"));
        store.insert(Entry::new("key2", "value2"));
        store.insert(Entry::new("key3", "value3"));
        
        let count = store.iter().count();
        assert_eq!(count, 3);
    }

    #[test]
    fn test_clear() {
        let mut store = KvStore::new();
        store.insert(Entry::new("key1", "value1"));
        store.insert(Entry::new("key2", "value2"));
        
        assert!(!store.is_empty());
        
        store.clear();
        assert!(store.is_empty());
    }

    #[test]
    fn test_from_map() {
        let mut map = HashMap::new();
        map.insert("key1".to_string(), Entry::new("key1", "value1"));
        
        let store = KvStore::from_map(map);
        assert_eq!(store.len(), 1);
        assert!(store.contains_key("key1"));
    }
}