pub struct StorageBuilder { /* private fields */ }Expand description
Билдер для создания хранилищ через фабрику
Implementations§
Source§impl StorageBuilder
impl StorageBuilder
Sourcepub fn new() -> Self
pub fn new() -> Self
Examples found in repository?
examples/factory_patterns.rs (line 20)
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}Sourcepub fn memory(self) -> Self
pub fn memory(self) -> Self
Examples found in repository?
examples/basic_usage.rs (line 17)
12fn main() -> Result<(), Box<dyn std::error::Error>> {
13 println!("=== Basic v-storage Usage Example ===\n");
14
15 // Create memory storage using Builder pattern
16 let storage = VStorage::builder()
17 .memory()
18 .build()?;
19 let mut storage = VStorage::new(storage);
20
21 println!("✅ Storage created successfully");
22
23 // === Basic data operations ===
24
25 // 1. Storing data
26 println!("\n📝 Storing data:");
27
28 let _ = storage.put_value(StorageId::Individuals, "user:1", r#"{
29 "@": "user:1",
30 "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
31 "rdfs:label": [{"type": "String", "data": "Ivan Petrov"}],
32 "foaf:name": [{"type": "String", "data": "Ivan"}],
33 "foaf:familyName": [{"type": "String", "data": "Petrov"}],
34 "foaf:age": [{"type": "Integer", "data": 30}],
35 "foaf:mbox": [{"type": "String", "data": "ivan.petrov@example.com"}],
36 "veda:created": [{"type": "Datetime", "data": "2024-01-15T10:30:00Z"}]
37 }"#);
38 let _ = storage.put_value(StorageId::Tickets, "ticket:123", r#"{
39 "@": "ticket:123",
40 "rdf:type": [{"type": "Uri", "data": "veda:Ticket"}],
41 "rdfs:label": [{"type": "String", "data": "Support Request"}],
42 "dcterms:title": [{"type": "String", "data": "Email server issue"}],
43 "veda:status": [{"type": "String", "data": "pending"}],
44 "veda:priority": [{"type": "String", "data": "medium"}],
45 "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T09:15:00Z"}]
46 }"#);
47 let _ = storage.put_value(StorageId::Az, "permission:read", r#"{
48 "@": "permission:read",
49 "rdf:type": [{"type": "Uri", "data": "veda:Permission"}],
50 "rdfs:label": [{"type": "String", "data": "Read Access"}],
51 "veda:permissionSubject": [{"type": "Uri", "data": "user:1"}],
52 "veda:permissionObject": [{"type": "Uri", "data": "resource:documents"}],
53 "veda:canRead": [{"type": "Boolean", "data": true}],
54 "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T08:00:00Z"}]
55 }"#);
56
57 println!(" • Stored user: user:1");
58 println!(" • Stored ticket: ticket:123");
59 println!(" • Stored permission: permission:read");
60
61 // 2. Reading data
62 println!("\n📖 Reading data:");
63
64 if let StorageResult::Ok(user_data) = storage.get_value(StorageId::Individuals, "user:1") {
65 println!(" • User Individual ({}): Ivan Petrov", user_data.len());
66 }
67
68 if let StorageResult::Ok(ticket_data) = storage.get_value(StorageId::Tickets, "ticket:123") {
69 println!(" • Ticket Individual ({}): Support Request", ticket_data.len());
70 }
71
72 if let StorageResult::Ok(permission_data) = storage.get_value(StorageId::Az, "permission:read") {
73 println!(" • Permission Individual ({}): Read Access", permission_data.len());
74 }
75
76 // 3. Working with binary data
77 println!("\n🔢 Working with binary data:");
78
79 let binary_data = vec![0xFF, 0xFE, 0xFD, 0x00, 0x01, 0x02];
80 let _ = storage.put_raw_value(StorageId::Individuals, "binary:data", binary_data.clone());
81
82 if let StorageResult::Ok(retrieved_binary) = storage.get_raw_value(StorageId::Individuals, "binary:data") {
83 println!(" • Stored {} bytes of binary data", retrieved_binary.len());
84 println!(" • Data matches: {}", retrieved_binary == binary_data);
85 }
86
87 // 4. Counting records
88 println!("\n📊 Statistics:");
89
90 if let StorageResult::Ok(individuals_count) = storage.count(StorageId::Individuals) {
91 println!(" • Individuals count: {}", individuals_count);
92 }
93
94 if let StorageResult::Ok(tickets_count) = storage.count(StorageId::Tickets) {
95 println!(" • Tickets count: {}", tickets_count);
96 }
97
98 if let StorageResult::Ok(az_count) = storage.count(StorageId::Az) {
99 println!(" • Permissions count: {}", az_count);
100 }
101
102 // 5. Removing data
103 println!("\n🗑️ Removing data:");
104
105 let _ = storage.remove_value(StorageId::Tickets, "ticket:123");
106 println!(" • Ticket ticket:123 removed");
107
108 // Check that data is actually removed
109 match storage.get_value(StorageId::Tickets, "ticket:123") {
110 StorageResult::NotFound => println!(" • Confirmed: ticket not found"),
111 _ => println!(" • Error: ticket still exists"),
112 }
113
114 // 6. Error handling
115 println!("\n⚠️ Error handling:");
116
117 match storage.get_value(StorageId::Individuals, "nonexistent") {
118 StorageResult::NotFound => println!(" • Correctly handled missing key case"),
119 StorageResult::Ok(_) => println!(" • Unexpected: found data"),
120 StorageResult::Error(e) => println!(" • Error: {}", e),
121 _ => println!(" • Other result"),
122 }
123
124 // === Backward compatibility demonstration ===
125 println!("\n🔄 Backward compatibility:");
126
127 #[allow(deprecated)]
128 {
129 // Using old methods
130 let success = storage.put_kv(StorageId::Individuals, "old:key", "old:value");
131 println!(" • Old put_kv: {}", if success { "success" } else { "error" });
132
133 if let Some(value) = storage.get_v(StorageId::Individuals, "old:key") {
134 println!(" • Old get_v: {}", value);
135 }
136 }
137
138 println!("\n✨ Example completed successfully!");
139 Ok(())
140}More examples
examples/storage_types.rs (line 20)
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}examples/factory_patterns.rs (line 21)
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}Sourcepub fn lmdb(
self,
path: &str,
mode: StorageMode,
max_read_counter_reopen: Option<u64>,
) -> Self
pub fn lmdb( self, path: &str, mode: StorageMode, max_read_counter_reopen: Option<u64>, ) -> Self
Examples found in repository?
examples/factory_patterns.rs (line 27)
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}Sourcepub fn remote(self, address: &str) -> Self
pub fn remote(self, address: &str) -> Self
Examples found in repository?
examples/factory_patterns.rs (line 37)
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}Sourcepub fn build(self) -> Result<Box<dyn Storage>, StorageError>
pub fn build(self) -> Result<Box<dyn Storage>, StorageError>
Examples found in repository?
examples/basic_usage.rs (line 18)
12fn main() -> Result<(), Box<dyn std::error::Error>> {
13 println!("=== Basic v-storage Usage Example ===\n");
14
15 // Create memory storage using Builder pattern
16 let storage = VStorage::builder()
17 .memory()
18 .build()?;
19 let mut storage = VStorage::new(storage);
20
21 println!("✅ Storage created successfully");
22
23 // === Basic data operations ===
24
25 // 1. Storing data
26 println!("\n📝 Storing data:");
27
28 let _ = storage.put_value(StorageId::Individuals, "user:1", r#"{
29 "@": "user:1",
30 "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
31 "rdfs:label": [{"type": "String", "data": "Ivan Petrov"}],
32 "foaf:name": [{"type": "String", "data": "Ivan"}],
33 "foaf:familyName": [{"type": "String", "data": "Petrov"}],
34 "foaf:age": [{"type": "Integer", "data": 30}],
35 "foaf:mbox": [{"type": "String", "data": "ivan.petrov@example.com"}],
36 "veda:created": [{"type": "Datetime", "data": "2024-01-15T10:30:00Z"}]
37 }"#);
38 let _ = storage.put_value(StorageId::Tickets, "ticket:123", r#"{
39 "@": "ticket:123",
40 "rdf:type": [{"type": "Uri", "data": "veda:Ticket"}],
41 "rdfs:label": [{"type": "String", "data": "Support Request"}],
42 "dcterms:title": [{"type": "String", "data": "Email server issue"}],
43 "veda:status": [{"type": "String", "data": "pending"}],
44 "veda:priority": [{"type": "String", "data": "medium"}],
45 "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T09:15:00Z"}]
46 }"#);
47 let _ = storage.put_value(StorageId::Az, "permission:read", r#"{
48 "@": "permission:read",
49 "rdf:type": [{"type": "Uri", "data": "veda:Permission"}],
50 "rdfs:label": [{"type": "String", "data": "Read Access"}],
51 "veda:permissionSubject": [{"type": "Uri", "data": "user:1"}],
52 "veda:permissionObject": [{"type": "Uri", "data": "resource:documents"}],
53 "veda:canRead": [{"type": "Boolean", "data": true}],
54 "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T08:00:00Z"}]
55 }"#);
56
57 println!(" • Stored user: user:1");
58 println!(" • Stored ticket: ticket:123");
59 println!(" • Stored permission: permission:read");
60
61 // 2. Reading data
62 println!("\n📖 Reading data:");
63
64 if let StorageResult::Ok(user_data) = storage.get_value(StorageId::Individuals, "user:1") {
65 println!(" • User Individual ({}): Ivan Petrov", user_data.len());
66 }
67
68 if let StorageResult::Ok(ticket_data) = storage.get_value(StorageId::Tickets, "ticket:123") {
69 println!(" • Ticket Individual ({}): Support Request", ticket_data.len());
70 }
71
72 if let StorageResult::Ok(permission_data) = storage.get_value(StorageId::Az, "permission:read") {
73 println!(" • Permission Individual ({}): Read Access", permission_data.len());
74 }
75
76 // 3. Working with binary data
77 println!("\n🔢 Working with binary data:");
78
79 let binary_data = vec![0xFF, 0xFE, 0xFD, 0x00, 0x01, 0x02];
80 let _ = storage.put_raw_value(StorageId::Individuals, "binary:data", binary_data.clone());
81
82 if let StorageResult::Ok(retrieved_binary) = storage.get_raw_value(StorageId::Individuals, "binary:data") {
83 println!(" • Stored {} bytes of binary data", retrieved_binary.len());
84 println!(" • Data matches: {}", retrieved_binary == binary_data);
85 }
86
87 // 4. Counting records
88 println!("\n📊 Statistics:");
89
90 if let StorageResult::Ok(individuals_count) = storage.count(StorageId::Individuals) {
91 println!(" • Individuals count: {}", individuals_count);
92 }
93
94 if let StorageResult::Ok(tickets_count) = storage.count(StorageId::Tickets) {
95 println!(" • Tickets count: {}", tickets_count);
96 }
97
98 if let StorageResult::Ok(az_count) = storage.count(StorageId::Az) {
99 println!(" • Permissions count: {}", az_count);
100 }
101
102 // 5. Removing data
103 println!("\n🗑️ Removing data:");
104
105 let _ = storage.remove_value(StorageId::Tickets, "ticket:123");
106 println!(" • Ticket ticket:123 removed");
107
108 // Check that data is actually removed
109 match storage.get_value(StorageId::Tickets, "ticket:123") {
110 StorageResult::NotFound => println!(" • Confirmed: ticket not found"),
111 _ => println!(" • Error: ticket still exists"),
112 }
113
114 // 6. Error handling
115 println!("\n⚠️ Error handling:");
116
117 match storage.get_value(StorageId::Individuals, "nonexistent") {
118 StorageResult::NotFound => println!(" • Correctly handled missing key case"),
119 StorageResult::Ok(_) => println!(" • Unexpected: found data"),
120 StorageResult::Error(e) => println!(" • Error: {}", e),
121 _ => println!(" • Other result"),
122 }
123
124 // === Backward compatibility demonstration ===
125 println!("\n🔄 Backward compatibility:");
126
127 #[allow(deprecated)]
128 {
129 // Using old methods
130 let success = storage.put_kv(StorageId::Individuals, "old:key", "old:value");
131 println!(" • Old put_kv: {}", if success { "success" } else { "error" });
132
133 if let Some(value) = storage.get_v(StorageId::Individuals, "old:key") {
134 println!(" • Old get_v: {}", value);
135 }
136 }
137
138 println!("\n✨ Example completed successfully!");
139 Ok(())
140}More examples
examples/storage_types.rs (line 20)
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}examples/factory_patterns.rs (line 22)
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}Sourcepub fn build_memory_generic(self) -> Result<VMemoryStorage, StorageError>
pub fn build_memory_generic(self) -> Result<VMemoryStorage, StorageError>
Создает generic память хранилище
Examples found in repository?
examples/factory_patterns.rs (line 126)
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}Sourcepub fn build_lmdb_generic(self) -> Result<VLMDBStorage, StorageError>
pub fn build_lmdb_generic(self) -> Result<VLMDBStorage, StorageError>
Создает generic LMDB хранилище
Examples found in repository?
examples/factory_patterns.rs (line 132)
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}Sourcepub fn build_remote_generic(self) -> Result<VRemoteStorage, StorageError>
pub fn build_remote_generic(self) -> Result<VRemoteStorage, StorageError>
Создает generic удаленное хранилище
Examples found in repository?
examples/factory_patterns.rs (line 142)
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}Trait Implementations§
Auto Trait Implementations§
impl Freeze for StorageBuilder
impl RefUnwindSafe for StorageBuilder
impl Send for StorageBuilder
impl Sync for StorageBuilder
impl Unpin for StorageBuilder
impl UnwindSafe for StorageBuilder
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more