VStorageGeneric

v_storage::vstorage

Struct VStorageGeneric 

Source 
pub struct VStorageGeneric<S: Storage> { /* private fields */ }
Expand description

Generic версия VStorage с статической диспетчеризацией

Преимущества:

  • Нет накладных расходов на динамическую диспетчеризацию
  • Нет heap allocations для storage
  • Лучшая производительность
  • Больше возможностей для оптимизации компилятором

Implementations§

Source§

impl<S: Storage> VStorageGeneric<S>

Source

pub fn new(storage: S) -> Self

Создает новое generic хранилище с конкретным типом

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}
Source

pub fn none() -> Self

Создает пустое хранилище

Source

pub fn is_empty(&self) -> bool

Проверяет, пусто ли хранилище

Examples found in repository?
examples/storage_types.rs (line 45)
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}
Source

pub fn take_storage(self) -> Option<S>

Берет хранилище из структуры, оставляя None

Source

pub fn storage(&self) -> Option<&S>

Возвращает ссылку на хранилище

Examples found in repository?
examples/storage_types.rs (line 48)
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}
Source

pub fn storage_mut(&mut self) -> Option<&mut S>

Возвращает мутабельную ссылку на хранилище

Source

pub fn get_individual( &mut self, id: &str, iraw: &mut Individual, ) -> StorageResult<()>

Source

pub fn get_individual_from_storage( &mut self, storage: StorageId, id: &str, iraw: &mut Individual, ) -> StorageResult<()>

Source

pub fn get_value( &mut self, storage: StorageId, id: &str, ) -> StorageResult<String>

Examples found in repository?
examples/storage_types.rs (line 41)
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/factory_patterns.rs (line 173)
12fn main() -> Result<(), Box<dyn std::error::Error>> {
13    println!("=== v-storage Factory Patterns Demonstration ===\n");
14
15    // === 1. Builder Pattern ===
16    println!("🏗️  1. Builder Pattern - step-by-step creation");
17    println!("   • Flexible and readable way to configure storage");
18    
19    // Create memory storage through builder
20    let memory_storage = StorageBuilder::new()
21        .memory()
22        .build()?;
23    println!("   • Created memory storage through builder");
24    
25    // Create LMDB storage through builder
26    let lmdb_storage = StorageBuilder::new()
27        .lmdb("/tmp/example_lmdb", StorageMode::ReadWrite, Some(1000))
28        .build();
29    
30    match lmdb_storage {
31        Ok(_) => println!("   • Created LMDB storage through builder"),
32        Err(e) => println!("   • LMDB unavailable: {}", e),
33    }
34    
35    // Create remote storage through builder
36    let remote_storage = StorageBuilder::new()
37        .remote("127.0.0.1:8080")
38        .build();
39    
40    match remote_storage {
41        Ok(_) => println!("   • Created remote storage through builder"),
42        Err(e) => println!("   • Remote unavailable: {}", e),
43    }
44
45    // === 2. Provider Pattern ===
46    println!("\n🏭 2. Provider Pattern - ready factory methods");
47    println!("   • Quick creation of standard configurations");
48    
49    // Direct creation of storages through Provider
50    let _provider_memory = StorageProvider::memory();
51    println!("   • StorageProvider::memory() - created");
52    
53    let _provider_lmdb = StorageProvider::lmdb("/tmp/provider_lmdb", StorageMode::ReadOnly, None);
54    println!("   • StorageProvider::lmdb() - created");
55    
56    let _provider_remote = StorageProvider::remote("127.0.0.1:8080");
57    println!("   • StorageProvider::remote() - created");
58    
59    // Create VStorage through Provider
60    let mut vstorage_memory = StorageProvider::vstorage_memory();
61    println!("   • StorageProvider::vstorage_memory() - created VStorage");
62    
63    // Demonstrate functionality with semantic Individual
64    let provider_individual = r#"{
65        "@": "provider:test",
66        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
67        "rdfs:label": [{"type": "String", "data": "Provider Test User"}],
68        "foaf:name": [{"type": "String", "data": "Test"}],
69        "veda:createdBy": [{"type": "Uri", "data": "provider:factory"}],
70        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T17:00:00Z"}]
71    }"#;
72    
73    let _ = vstorage_memory.put_value(StorageId::Individuals, "provider:test", provider_individual);
74    if let StorageResult::Ok(value) = vstorage_memory.get_value(StorageId::Individuals, "provider:test") {
75        println!("     Test: stored Individual ({} bytes) through Provider", value.len());
76    }
77
78    // === 3. Config Pattern ===
79    println!("\n⚙️  3. Config Pattern - creation from configuration");
80    println!("   • Creating storages from configuration structures");
81    
82    // Create from different configurations
83    let configs = vec![
84        ("Memory", StorageConfig::Memory),
85        ("LMDB", StorageConfig::Lmdb { 
86            path: "/tmp/config_lmdb".to_string(), 
87            mode: StorageMode::ReadWrite, 
88            max_read_counter_reopen: Some(500) 
89        }),
90        ("Remote", StorageConfig::Remote { 
91            address: "127.0.0.1:8080".to_string() 
92        }),
93    ];
94    
95    for (name, config) in configs {
96        match VStorage::from_config(config) {
97            Ok(mut storage) => {
98                println!("   • {} configuration: created successfully", name);
99                
100                // Test the created storage with semantic Individual
101                let test_key = format!("config:{}:key", name.to_lowercase());
102                let test_value = format!(r#"{{
103                    "@": "{}",
104                    "rdf:type": [{{"type": "Uri", "data": "veda:ConfigTest"}}],
105                    "rdfs:label": [{{"type": "String", "data": "Config Test for {}"}}],
106                    "veda:configType": [{{"type": "String", "data": "{}"}}],
107                    "dcterms:created": [{{"type": "Datetime", "data": "2024-01-15T17:30:00Z"}}]
108                }}"#, test_key, name, name);
109                
110                let _ = storage.put_value(StorageId::Individuals, &test_key, &test_value);
111                if let StorageResult::Ok(retrieved) = storage.get_value(StorageId::Individuals, &test_key) {
112                    println!("     Test: {} Individual ({} bytes)", name, retrieved.len());
113                }
114            },
115            Err(e) => println!("   • {} configuration: error - {}", name, e),
116        }
117    }
118
119    // === 4. Generic Builders ===
120    println!("\n🔧 4. Generic Builders - compile-time optimization");
121    println!("   • Typed builders without runtime overhead");
122    
123    // Generic memory builder
124    let generic_memory = StorageBuilder::new()
125        .memory()
126        .build_memory_generic()?;
127    println!("   • build_memory_generic() - created VMemoryStorage");
128    
129    // Generic LMDB builder
130    let generic_lmdb = StorageBuilder::new()
131        .lmdb("/tmp/generic_lmdb", StorageMode::ReadWrite, None)
132        .build_lmdb_generic();
133    
134    match generic_lmdb {
135        Ok(_storage) => println!("   • build_lmdb_generic() - created VLMDBStorage"),
136        Err(e) => println!("   • build_lmdb_generic() - error: {}", e),
137    }
138    
139    // Generic remote builder
140    let generic_remote = StorageBuilder::new()
141        .remote("127.0.0.1:8080")
142        .build_remote_generic();
143    
144    match generic_remote {
145        Ok(_storage) => println!("   • build_remote_generic() - created VRemoteStorage"),
146        Err(e) => println!("   • build_remote_generic() - error: {}", e),
147    }
148
149    // === 5. Provider Generic Methods ===
150    println!("\n🎯 5. Provider Generic Methods - static types");
151    println!("   • Direct creation of typed storages");
152    
153    let mut provider_generic_memory = StorageProvider::memory_generic();
154    println!("   • StorageProvider::memory_generic() - VMemoryStorage");
155    
156    let provider_generic_lmdb = StorageProvider::lmdb_generic("/tmp/generic_provider", StorageMode::ReadOnly, None);
157    println!("   • StorageProvider::lmdb_generic() - VLMDBStorage");
158    
159    let provider_generic_remote = StorageProvider::remote_generic("127.0.0.1:8080");
160    println!("   • StorageProvider::remote_generic() - VRemoteStorage");
161    
162    // Demonstrate work with typed storage using semantic Individual
163    let generic_individual = r#"{
164        "@": "generic:test",
165        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
166        "rdfs:label": [{"type": "String", "data": "Generic Test User"}],
167        "foaf:name": [{"type": "String", "data": "Generic"}],
168        "veda:storageType": [{"type": "String", "data": "memory_generic"}],
169        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T18:00:00Z"}]
170    }"#;
171    
172    let _ = provider_generic_memory.put_value(StorageId::Individuals, "generic:test", generic_individual);
173    if let StorageResult::Ok(value) = provider_generic_memory.get_value(StorageId::Individuals, "generic:test") {
174        println!("     Generic test: Individual ({} bytes)", value.len());
175    }
176
177    // === 6. Approach comparison ===
178    println!("\n📊 6. Storage creation approach comparison");
179    
180    println!("   Builder Pattern:");
181    println!("     ✅ Readable and flexible API");
182    println!("     ✅ Validation at build() stage");
183    println!("     ✅ Can create both dynamic and generic types");
184    println!("     ❌ More code for simple cases");
185    
186    println!("   Provider Pattern:");
187    println!("     ✅ Concise code for standard cases");
188    println!("     ✅ Ready optimal configurations");
189    println!("     ❌ Less flexible for customization");
190    
191    println!("   Config Pattern:");
192    println!("     ✅ Excellent for loading from files/ENV");
193    println!("     ✅ Unified interface for all types");
194    println!("     ❌ Only dynamic dispatch");
195    
196    println!("   Generic Methods:");
197    println!("     ✅ Static dispatch");
198    println!("     ✅ Compile-time typing");
199    println!("     ❌ Less flexible at runtime");
200
201    // === 7. Usage recommendations ===
202    println!("\n💡 7. Pattern selection recommendations");
203    
204    println!("   Use Builder when:");
205    println!("     • Parameter customization is needed");
206    println!("     • Complex creation logic");
207    println!("     • Code readability is needed");
208    
209    println!("   Use Provider when:");
210    println!("     • Need to quickly create standard storage");
211    println!("     • Default parameters are suitable");
212    println!("     • Minimal boilerplate code");
213    
214    println!("   Use Config when:");
215    println!("     • Configuration is loaded from external sources");
216    println!("     • Storage type is determined at runtime");
217    println!("     • Uniform handling of different types is needed");
218    
219    println!("   Use Generic methods when:");
220    println!("     • Static dispatch is preferred");
221    println!("     • Storage type is known at compile time");
222    println!("     • Access to type-specific methods is needed");
223
224    println!("\n✨ Factory patterns demonstration completed!");
225    Ok(())
226}
Source

pub fn get_raw_value( &mut self, storage: StorageId, id: &str, ) -> StorageResult<Vec<u8>>

Source

pub fn put_value( &mut self, storage: StorageId, key: &str, val: &str, ) -> StorageResult<()>

Examples found in repository?
examples/storage_types.rs (line 39)
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/factory_patterns.rs (line 172)
12fn main() -> Result<(), Box<dyn std::error::Error>> {
13    println!("=== v-storage Factory Patterns Demonstration ===\n");
14
15    // === 1. Builder Pattern ===
16    println!("🏗️  1. Builder Pattern - step-by-step creation");
17    println!("   • Flexible and readable way to configure storage");
18    
19    // Create memory storage through builder
20    let memory_storage = StorageBuilder::new()
21        .memory()
22        .build()?;
23    println!("   • Created memory storage through builder");
24    
25    // Create LMDB storage through builder
26    let lmdb_storage = StorageBuilder::new()
27        .lmdb("/tmp/example_lmdb", StorageMode::ReadWrite, Some(1000))
28        .build();
29    
30    match lmdb_storage {
31        Ok(_) => println!("   • Created LMDB storage through builder"),
32        Err(e) => println!("   • LMDB unavailable: {}", e),
33    }
34    
35    // Create remote storage through builder
36    let remote_storage = StorageBuilder::new()
37        .remote("127.0.0.1:8080")
38        .build();
39    
40    match remote_storage {
41        Ok(_) => println!("   • Created remote storage through builder"),
42        Err(e) => println!("   • Remote unavailable: {}", e),
43    }
44
45    // === 2. Provider Pattern ===
46    println!("\n🏭 2. Provider Pattern - ready factory methods");
47    println!("   • Quick creation of standard configurations");
48    
49    // Direct creation of storages through Provider
50    let _provider_memory = StorageProvider::memory();
51    println!("   • StorageProvider::memory() - created");
52    
53    let _provider_lmdb = StorageProvider::lmdb("/tmp/provider_lmdb", StorageMode::ReadOnly, None);
54    println!("   • StorageProvider::lmdb() - created");
55    
56    let _provider_remote = StorageProvider::remote("127.0.0.1:8080");
57    println!("   • StorageProvider::remote() - created");
58    
59    // Create VStorage through Provider
60    let mut vstorage_memory = StorageProvider::vstorage_memory();
61    println!("   • StorageProvider::vstorage_memory() - created VStorage");
62    
63    // Demonstrate functionality with semantic Individual
64    let provider_individual = r#"{
65        "@": "provider:test",
66        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
67        "rdfs:label": [{"type": "String", "data": "Provider Test User"}],
68        "foaf:name": [{"type": "String", "data": "Test"}],
69        "veda:createdBy": [{"type": "Uri", "data": "provider:factory"}],
70        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T17:00:00Z"}]
71    }"#;
72    
73    let _ = vstorage_memory.put_value(StorageId::Individuals, "provider:test", provider_individual);
74    if let StorageResult::Ok(value) = vstorage_memory.get_value(StorageId::Individuals, "provider:test") {
75        println!("     Test: stored Individual ({} bytes) through Provider", value.len());
76    }
77
78    // === 3. Config Pattern ===
79    println!("\n⚙️  3. Config Pattern - creation from configuration");
80    println!("   • Creating storages from configuration structures");
81    
82    // Create from different configurations
83    let configs = vec![
84        ("Memory", StorageConfig::Memory),
85        ("LMDB", StorageConfig::Lmdb { 
86            path: "/tmp/config_lmdb".to_string(), 
87            mode: StorageMode::ReadWrite, 
88            max_read_counter_reopen: Some(500) 
89        }),
90        ("Remote", StorageConfig::Remote { 
91            address: "127.0.0.1:8080".to_string() 
92        }),
93    ];
94    
95    for (name, config) in configs {
96        match VStorage::from_config(config) {
97            Ok(mut storage) => {
98                println!("   • {} configuration: created successfully", name);
99                
100                // Test the created storage with semantic Individual
101                let test_key = format!("config:{}:key", name.to_lowercase());
102                let test_value = format!(r#"{{
103                    "@": "{}",
104                    "rdf:type": [{{"type": "Uri", "data": "veda:ConfigTest"}}],
105                    "rdfs:label": [{{"type": "String", "data": "Config Test for {}"}}],
106                    "veda:configType": [{{"type": "String", "data": "{}"}}],
107                    "dcterms:created": [{{"type": "Datetime", "data": "2024-01-15T17:30:00Z"}}]
108                }}"#, test_key, name, name);
109                
110                let _ = storage.put_value(StorageId::Individuals, &test_key, &test_value);
111                if let StorageResult::Ok(retrieved) = storage.get_value(StorageId::Individuals, &test_key) {
112                    println!("     Test: {} Individual ({} bytes)", name, retrieved.len());
113                }
114            },
115            Err(e) => println!("   • {} configuration: error - {}", name, e),
116        }
117    }
118
119    // === 4. Generic Builders ===
120    println!("\n🔧 4. Generic Builders - compile-time optimization");
121    println!("   • Typed builders without runtime overhead");
122    
123    // Generic memory builder
124    let generic_memory = StorageBuilder::new()
125        .memory()
126        .build_memory_generic()?;
127    println!("   • build_memory_generic() - created VMemoryStorage");
128    
129    // Generic LMDB builder
130    let generic_lmdb = StorageBuilder::new()
131        .lmdb("/tmp/generic_lmdb", StorageMode::ReadWrite, None)
132        .build_lmdb_generic();
133    
134    match generic_lmdb {
135        Ok(_storage) => println!("   • build_lmdb_generic() - created VLMDBStorage"),
136        Err(e) => println!("   • build_lmdb_generic() - error: {}", e),
137    }
138    
139    // Generic remote builder
140    let generic_remote = StorageBuilder::new()
141        .remote("127.0.0.1:8080")
142        .build_remote_generic();
143    
144    match generic_remote {
145        Ok(_storage) => println!("   • build_remote_generic() - created VRemoteStorage"),
146        Err(e) => println!("   • build_remote_generic() - error: {}", e),
147    }
148
149    // === 5. Provider Generic Methods ===
150    println!("\n🎯 5. Provider Generic Methods - static types");
151    println!("   • Direct creation of typed storages");
152    
153    let mut provider_generic_memory = StorageProvider::memory_generic();
154    println!("   • StorageProvider::memory_generic() - VMemoryStorage");
155    
156    let provider_generic_lmdb = StorageProvider::lmdb_generic("/tmp/generic_provider", StorageMode::ReadOnly, None);
157    println!("   • StorageProvider::lmdb_generic() - VLMDBStorage");
158    
159    let provider_generic_remote = StorageProvider::remote_generic("127.0.0.1:8080");
160    println!("   • StorageProvider::remote_generic() - VRemoteStorage");
161    
162    // Demonstrate work with typed storage using semantic Individual
163    let generic_individual = r#"{
164        "@": "generic:test",
165        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
166        "rdfs:label": [{"type": "String", "data": "Generic Test User"}],
167        "foaf:name": [{"type": "String", "data": "Generic"}],
168        "veda:storageType": [{"type": "String", "data": "memory_generic"}],
169        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T18:00:00Z"}]
170    }"#;
171    
172    let _ = provider_generic_memory.put_value(StorageId::Individuals, "generic:test", generic_individual);
173    if let StorageResult::Ok(value) = provider_generic_memory.get_value(StorageId::Individuals, "generic:test") {
174        println!("     Generic test: Individual ({} bytes)", value.len());
175    }
176
177    // === 6. Approach comparison ===
178    println!("\n📊 6. Storage creation approach comparison");
179    
180    println!("   Builder Pattern:");
181    println!("     ✅ Readable and flexible API");
182    println!("     ✅ Validation at build() stage");
183    println!("     ✅ Can create both dynamic and generic types");
184    println!("     ❌ More code for simple cases");
185    
186    println!("   Provider Pattern:");
187    println!("     ✅ Concise code for standard cases");
188    println!("     ✅ Ready optimal configurations");
189    println!("     ❌ Less flexible for customization");
190    
191    println!("   Config Pattern:");
192    println!("     ✅ Excellent for loading from files/ENV");
193    println!("     ✅ Unified interface for all types");
194    println!("     ❌ Only dynamic dispatch");
195    
196    println!("   Generic Methods:");
197    println!("     ✅ Static dispatch");
198    println!("     ✅ Compile-time typing");
199    println!("     ❌ Less flexible at runtime");
200
201    // === 7. Usage recommendations ===
202    println!("\n💡 7. Pattern selection recommendations");
203    
204    println!("   Use Builder when:");
205    println!("     • Parameter customization is needed");
206    println!("     • Complex creation logic");
207    println!("     • Code readability is needed");
208    
209    println!("   Use Provider when:");
210    println!("     • Need to quickly create standard storage");
211    println!("     • Default parameters are suitable");
212    println!("     • Minimal boilerplate code");
213    
214    println!("   Use Config when:");
215    println!("     • Configuration is loaded from external sources");
216    println!("     • Storage type is determined at runtime");
217    println!("     • Uniform handling of different types is needed");
218    
219    println!("   Use Generic methods when:");
220    println!("     • Static dispatch is preferred");
221    println!("     • Storage type is known at compile time");
222    println!("     • Access to type-specific methods is needed");
223
224    println!("\n✨ Factory patterns demonstration completed!");
225    Ok(())
226}
Source

pub fn put_raw_value( &mut self, storage: StorageId, key: &str, val: Vec<u8>, ) -> StorageResult<()>

Source

pub fn remove_value( &mut self, storage: StorageId, key: &str, ) -> StorageResult<()>

Source

pub fn count(&mut self, storage: StorageId) -> StorageResult<usize>

Trait Implementations§

Source§

impl<S: Storage + Clone> Clone for VStorageGeneric<S>

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl<S: Storage + Debug> Debug for VStorageGeneric<S>

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl<S: Storage + Default> Default for VStorageGeneric<S>

Source§

fn default() -> Self

Returns the “default value” for a type. Read more
Source§

impl<S: Storage> StorageDispatcher for VStorageGeneric<S>

Source§

type Storage = S

Source§

fn with_storage<T, F>(&mut self, default_value: T, operation: F) -> T
where F: FnOnce(&mut Self::Storage) -> T,

Source§

fn with_storage_result<F>(&mut self, operation: F) -> StorageResult<()>
where F: FnOnce(&mut Self::Storage) -> StorageResult<()>,

Source§

fn with_storage_value<T, F>(&mut self, operation: F) -> StorageResult<T>
where F: FnOnce(&mut Self::Storage) -> StorageResult<T>, T: Default,

Auto Trait Implementations§

§

impl<S> Freeze for VStorageGeneric<S>
where S: Freeze,

§

impl<S> RefUnwindSafe for VStorageGeneric<S>
where S: RefUnwindSafe,

§

impl<S> Send for VStorageGeneric<S>
where S: Send,

§

impl<S> Sync for VStorageGeneric<S>
where S: Sync,

§

impl<S> Unpin for VStorageGeneric<S>
where S: Unpin,

§

impl<S> UnwindSafe for VStorageGeneric<S>
where S: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.