Struct MemoryStorage

Source

pub struct MemoryStorage { /* private fields */ }

Implementations§

Source §

impl MemoryStorage

Source

pub fn new() -> Self

Examples found in repository ?

examples/storage_types.rs (line 37)

12fn main() -> Result<(), Box<dyn std::error::Error>> {
13    println!("=== v-storage Storage Types Comparison ===\n");
14
15    // === 1. Dynamic storage (VStorage) ===
16    println!("🎭 1. Dynamic storage (VStorage)");
17    println!("   • Uses trait objects (Box<dyn Storage>)");
18    println!("   • Runtime flexibility, but has vtable lookup overhead");
19    
20    let storage_box = VStorage::builder().memory().build()?;
21    let mut dynamic_storage = VStorage::new(storage_box);
22    
23    // Demonstrate operations
24    let _ = dynamic_storage.put_value(StorageId::Individuals, "dynamic:key", "dynamic:value");
25    
26    if let StorageResult::Ok(value) = dynamic_storage.get_value(StorageId::Individuals, "dynamic:key") {
27        println!("   • Stored and read: {}", value);
28    }
29    
30    println!("   • Storage is empty: {}", dynamic_storage.is_empty());
31
32    // === 2. Generic storage (VStorageGeneric) ===
33    println!("\n🔧 2. Generic storage (VStorageGeneric)");
34    println!("   • Compile-time typing");
35    println!("   • No vtable overhead, but less flexible");
36    
37    let mut generic_storage = VMemoryStorage::new(memory_storage::MemoryStorage::new());
38    
39    let _ = generic_storage.put_value(StorageId::Individuals, "generic:key", "generic:value");
40    
41    if let StorageResult::Ok(value) = generic_storage.get_value(StorageId::Individuals, "generic:key") {
42        println!("   • Stored and read: {}", value);
43    }
44    
45    println!("   • Storage is empty: {}", generic_storage.is_empty());
46    
47    // Can extract inner storage
48    if let Some(inner_storage) = generic_storage.storage() {
49        println!("   • Access to inner storage: available");
50    }
51
52    // === 3. Enum storage (VStorageEnum) ===
53    println!("\n⚡ 3. Enum storage (VStorageEnum)");
54    println!("   • Static dispatch through enum");
55    println!("   • Static dispatch");
56    
57    let mut enum_storage = VStorageEnum::memory();
58    
59    let _ = enum_storage.put_value(StorageId::Individuals, "enum:key", "enum:value");
60    
61    if let StorageResult::Ok(value) = enum_storage.get_value(StorageId::Individuals, "enum:key") {
62        println!("   • Stored and read: {}", value);
63    }
64    
65    println!("   • Storage is empty: {}", enum_storage.is_empty());
66
67    // === 4. API consistency ===
68    println!("\n🔄 4. API consistency between types");
69    println!("   • All types have the same Storage interface");
70    
71    let test_data = vec![
72        ("test1", "value1"),
73        ("test2", "value2"),
74        ("test3", "value3"),
75    ];
76
77    // Store data in all storage types
78    for (key, value) in &test_data {
79        let _ = dynamic_storage.put_value(StorageId::Tickets, key, value);
80        let _ = generic_storage.put_value(StorageId::Tickets, key, value);
81        let _ = enum_storage.put_value(StorageId::Tickets, key, value);
82    }
83
84    // Check that all return the same results
85    println!("   • Consistency check:");
86    for (key, expected_value) in &test_data {
87        let dynamic_result = dynamic_storage.get_value(StorageId::Tickets, key);
88        let generic_result = generic_storage.get_value(StorageId::Tickets, key);
89        let enum_result = enum_storage.get_value(StorageId::Tickets, key);
90
91        match (dynamic_result, generic_result, enum_result) {
92            (StorageResult::Ok(v1), StorageResult::Ok(v2), StorageResult::Ok(v3)) => {
93                let consistent = v1 == *expected_value && v2 == *expected_value && v3 == *expected_value;
94                println!("     {} -> {}", key, if consistent { "✅ consistent" } else { "❌ inconsistent" });
95            }
96            _ => println!("     {} -> ❌ read error", key),
97        }
98    }
99
100    // === 5. Different constructor demonstrations ===
101    println!("\n🏗️  5. Different ways to create storages");
102    
103    // VStorageEnum - direct creation
104    let _enum_direct = VStorageEnum::memory();
105    println!("   • VStorageEnum::memory() - direct creation");
106    
107    // VStorageGeneric - through constructor
108    let _generic_direct = VMemoryStorage::new(memory_storage::MemoryStorage::new());
109    println!("   • VMemoryStorage::new() - through constructor");
110    
111    // VStorage - through builder
112    let _dynamic_builder = VStorage::builder().memory().build()?;
113    println!("   • VStorage::builder() - through builder pattern");
114
115    // === 6. Features of each type ===
116    println!("\n📋 6. Usage characteristics");
117    
118    println!("   VStorage (Dynamic):");
119    println!("     ✅ Maximum flexibility");
120    println!("     ✅ Can change storage type at runtime");
121    println!("     ❌ Vtable lookup overhead");
122    println!("     ❌ No access to inner type");
123    
124    println!("   VStorageGeneric<T> (Generic):");
125    println!("     ✅ Compile-time optimization");
126    println!("     ✅ Access to inner storage");
127    println!("     ✅ Type safety");
128    println!("     ❌ Less flexible at runtime");
129    
130    println!("   VStorageEnum (Enum):");
131    println!("     ✅ Static dispatch");
132    println!("     ✅ No heap allocation for storage");
133    println!("     ❌ Fixed set of types");
134
135    // === 7. Usage recommendations ===
136    println!("\n💡 7. Storage type selection recommendations");
137    
138    println!("   Use VStorage when:");
139    println!("     • Maximum flexibility is needed");
140    println!("     • Storage type is determined at runtime");
141    println!("     • Flexibility is more important than dispatch overhead");
142    
143    println!("   Use VStorageGeneric when:");
144    println!("     • Access to inner storage is needed");
145    println!("     • Type safety is important");
146    println!("     • Storage type is known at compile time");
147    
148    println!("   Use VStorageEnum when:");
149    println!("     • Static dispatch is preferred");
150    println!("     • Doing many operations (batch processing)");
151    println!("     • Fixed set of types is suitable");
152
153    println!("\n✨ Demonstration completed!");
154    Ok(())
155}

More examples

Hide additional examples

examples/individual_operations.rs (line 20)

16fn main() {
17    println!("=== Демонстрация работы с Individual в v-storage ===\n");
18
19    // Создаем хранилище в памяти
20    let mut storage = VStorage::new(Box::new(MemoryStorage::new()));
21    
22    // Создаем Individual
23    let mut individual = Individual::default();
24    
25    println!("1. Загрузка несуществующего Individual:");
26    match storage.get_individual("test:nonexistent", &mut individual) {
27        StorageResult::Ok(_) => {
28            println!("   ✓ Individual найден!");
29            println!("   • ID: {}", individual.get_id());
30        },
31        StorageResult::UnprocessableEntity => {
32            println!("   ✗ Individual найден, но не может быть обработан");
33            println!("   • Возможно, данные повреждены или имеют неверный формат");
34        },
35        StorageResult::NotFound => {
36            println!("   ✗ Individual не найден");
37            println!("   • Ключ 'test:nonexistent' не существует в хранилище");
38        },
39        StorageResult::NotReady => {
40            println!("   ✗ Хранилище не готово");
41        },
42        StorageResult::Error(msg) => {
43            println!("   ✗ Ошибка: {}", msg);
44        }
45    }
46    
47    println!("\n2. Сохранение Individual данных:");
48    
49    // Сохраняем корректные данные Individual
50    let individual_data = r#"{"@":"individual","@id":"test:person","rdfs:label":[{"data":"Тестовый пользователь","lang":"ru","type":"_string"}]}"#;
51    
52    match storage.put_value(StorageId::Individuals, "test:person", individual_data) {
53        StorageResult::Ok(_) => {
54            println!("   ✓ Individual успешно сохранен");
55        },
56        StorageResult::Error(msg) => {
57            println!("   ✗ Ошибка при сохранении: {}", msg);
58        },
59        _ => {
60            println!("   ✗ Неожиданная ошибка при сохранении");
61        }
62    }
63    
64    println!("\n3. Загрузка существующего Individual:");
65    match storage.get_individual("test:person", &mut individual) {
66        StorageResult::Ok(_) => {
67            println!("   ✓ Individual успешно загружен!");
68            println!("   • ID: {}", individual.get_id());
69            println!("   • Сырые данные: {} байт", individual.get_raw_len());
70        },
71        StorageResult::UnprocessableEntity => {
72            println!("   ✗ Individual найден, но не может быть обработан");
73            println!("   • Проверьте формат данных");
74        },
75        StorageResult::NotFound => {
76            println!("   ✗ Individual не найден");
77        },
78        StorageResult::NotReady => {
79            println!("   ✗ Хранилище не готово");
80        },
81        StorageResult::Error(msg) => {
82            println!("   ✗ Ошибка: {}", msg);
83        }
84    }
85    
86    println!("\n4. Тестирование с невалидными данными:");
87    
88    // Сохраняем невалидные данные
89    let invalid_data = "это не JSON и не Individual";
90    match storage.put_value(StorageId::Individuals, "test:invalid", invalid_data) {
91        StorageResult::Ok(_) => {
92            println!("   ✓ Невалидные данные сохранены (для тестирования)");
93        },
94        StorageResult::Error(msg) => {
95            println!("   ✗ Ошибка при сохранении: {}", msg);
96        },
97        _ => {
98            println!("   ✗ Неожиданная ошибка при сохранении");
99        }
100    }
101    
102    // Пытаемся загрузить невалидные данные
103    match storage.get_individual("test:invalid", &mut individual) {
104        StorageResult::Ok(_) => {
105            println!("   ✓ Данные загружены (неожиданно)");
106        },
107        StorageResult::UnprocessableEntity => {
108            println!("   ✓ Корректно обработаны невалидные данные");
109            println!("   • Система правильно определила, что данные не являются Individual");
110        },
111        StorageResult::NotFound => {
112            println!("   ✗ Данные не найдены (неожиданно)");
113        },
114        StorageResult::NotReady => {
115            println!("   ✗ Хранилище не готово");
116        },
117        StorageResult::Error(msg) => {
118            println!("   ✗ Ошибка: {}", msg);
119        }
120    }
121    
122    println!("\n5. Работа с различными типами хранилищ:");
123    
124    // Демонстрация работы с разными типами хранилищ
125    let mut memory_storage = VStorageEnum::memory();
126    
127    println!("   • Память: сохранение данных...");
128    match memory_storage.put_value(StorageId::Individuals, "test:memory", individual_data) {
129        StorageResult::Ok(_) => {
130            println!("     ✓ Данные сохранены в памяти");
131            
132            // Проверяем загрузку
133                         match memory_storage.get_individual(StorageId::Individuals, "test:memory", &mut individual) {
134                StorageResult::Ok(_) => {
135                    println!("     ✓ Данные успешно загружены из памяти");
136                    println!("     • ID: {}", individual.get_id());
137                },
138                result => {
139                    println!("     ✗ Не удалось загрузить данные: {:?}", result);
140                }
141            }
142        },
143        StorageResult::Error(msg) => {
144            println!("     ✗ Ошибка при сохранении: {}", msg);
145        },
146        _ => {
147            println!("     ✗ Неожиданная ошибка при сохранении");
148        }
149    }
150    
151    println!("\n6. Подсчет количества Individual:");
152    match storage.count(StorageId::Individuals) {
153        StorageResult::Ok(count) => {
154            println!("   ✓ В хранилище {} Individual(s)", count);
155        },
156        StorageResult::Error(msg) => {
157            println!("   ✗ Ошибка при подсчете: {}", msg);
158        },
159        _ => {
160            println!("   ✗ Подсчет недоступен");
161        }
162    }
163    
164    println!("\n7. Лучшие практики:");
165    println!("   • Всегда проверяйте StorageResult при загрузке Individual");
166    println!("   • StorageResult::UnprocessableEntity означает, что данные есть, но не валидны");
167    println!("   • StorageResult::NotFound означает, что данных нет");
168    println!("   • StorageResult::NotReady означает, что хранилище не готово к работе");
169    println!("   • Используйте соответствующие методы для разных типов данных");
170    
171    println!("\n=== Демонстрация завершена ===");
172}