Struct VStorage 

pub struct VStorage { /* private fields */ }

Контейнер для хранилища с динамической диспетчеризацией

Ответственности:

• Хранение экземпляра Storage
• Диспетчеризация вызовов к хранилищу
• Обработка состояния “не инициализировано”

Implementations

impl VStorage

pub fn none() -> VStorage

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

pub fn is_empty(&self) -> bool

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

Examples found in repository

examples/storage_types.rs (line 30)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== v-storage Storage Types Comparison ===\n");

    // === 1. Dynamic storage (VStorage) ===
    println!("🎭 1. Dynamic storage (VStorage)");
    println!("   • Uses trait objects (Box<dyn Storage>)");
    println!("   • Runtime flexibility, but has vtable lookup overhead");
    
    let storage_box = VStorage::builder().memory().build()?;
    let mut dynamic_storage = VStorage::new(storage_box);
    
    // Demonstrate operations
    let _ = dynamic_storage.put_value(StorageId::Individuals, "dynamic:key", "dynamic:value");
    
    if let StorageResult::Ok(value) = dynamic_storage.get_value(StorageId::Individuals, "dynamic:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", dynamic_storage.is_empty());

    // === 2. Generic storage (VStorageGeneric) ===
    println!("\n🔧 2. Generic storage (VStorageGeneric)");
    println!("   • Compile-time typing");
    println!("   • No vtable overhead, but less flexible");
    
    let mut generic_storage = VMemoryStorage::new(memory_storage::MemoryStorage::new());
    
    let _ = generic_storage.put_value(StorageId::Individuals, "generic:key", "generic:value");
    
    if let StorageResult::Ok(value) = generic_storage.get_value(StorageId::Individuals, "generic:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", generic_storage.is_empty());
    
    // Can extract inner storage
    if let Some(inner_storage) = generic_storage.storage() {
        println!("   • Access to inner storage: available");
    }

    // === 3. Enum storage (VStorageEnum) ===
    println!("\n⚡ 3. Enum storage (VStorageEnum)");
    println!("   • Static dispatch through enum");
    println!("   • Static dispatch");
    
    let mut enum_storage = VStorageEnum::memory();
    
    let _ = enum_storage.put_value(StorageId::Individuals, "enum:key", "enum:value");
    
    if let StorageResult::Ok(value) = enum_storage.get_value(StorageId::Individuals, "enum:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", enum_storage.is_empty());

    // === 4. API consistency ===
    println!("\n🔄 4. API consistency between types");
    println!("   • All types have the same Storage interface");
    
    let test_data = vec![
        ("test1", "value1"),
        ("test2", "value2"),
        ("test3", "value3"),
    ];

    // Store data in all storage types
    for (key, value) in &test_data {
        let _ = dynamic_storage.put_value(StorageId::Tickets, key, value);
        let _ = generic_storage.put_value(StorageId::Tickets, key, value);
        let _ = enum_storage.put_value(StorageId::Tickets, key, value);
    }

    // Check that all return the same results
    println!("   • Consistency check:");
    for (key, expected_value) in &test_data {
        let dynamic_result = dynamic_storage.get_value(StorageId::Tickets, key);
        let generic_result = generic_storage.get_value(StorageId::Tickets, key);
        let enum_result = enum_storage.get_value(StorageId::Tickets, key);

        match (dynamic_result, generic_result, enum_result) {
            (StorageResult::Ok(v1), StorageResult::Ok(v2), StorageResult::Ok(v3)) => {
                let consistent = v1 == *expected_value && v2 == *expected_value && v3 == *expected_value;
                println!("     {} -> {}", key, if consistent { "✅ consistent" } else { "❌ inconsistent" });
            }
            _ => println!("     {} -> ❌ read error", key),
        }
    }

    // === 5. Different constructor demonstrations ===
    println!("\n🏗️  5. Different ways to create storages");
    
    // VStorageEnum - direct creation
    let _enum_direct = VStorageEnum::memory();
    println!("   • VStorageEnum::memory() - direct creation");
    
    // VStorageGeneric - through constructor
    let _generic_direct = VMemoryStorage::new(memory_storage::MemoryStorage::new());
    println!("   • VMemoryStorage::new() - through constructor");
    
    // VStorage - through builder
    let _dynamic_builder = VStorage::builder().memory().build()?;
    println!("   • VStorage::builder() - through builder pattern");

    // === 6. Features of each type ===
    println!("\n📋 6. Usage characteristics");
    
    println!("   VStorage (Dynamic):");
    println!("     ✅ Maximum flexibility");
    println!("     ✅ Can change storage type at runtime");
    println!("     ❌ Vtable lookup overhead");
    println!("     ❌ No access to inner type");
    
    println!("   VStorageGeneric<T> (Generic):");
    println!("     ✅ Compile-time optimization");
    println!("     ✅ Access to inner storage");
    println!("     ✅ Type safety");
    println!("     ❌ Less flexible at runtime");
    
    println!("   VStorageEnum (Enum):");
    println!("     ✅ Static dispatch");
    println!("     ✅ No heap allocation for storage");
    println!("     ❌ Fixed set of types");

    // === 7. Usage recommendations ===
    println!("\n💡 7. Storage type selection recommendations");
    
    println!("   Use VStorage when:");
    println!("     • Maximum flexibility is needed");
    println!("     • Storage type is determined at runtime");
    println!("     • Flexibility is more important than dispatch overhead");
    
    println!("   Use VStorageGeneric when:");
    println!("     • Access to inner storage is needed");
    println!("     • Type safety is important");
    println!("     • Storage type is known at compile time");
    
    println!("   Use VStorageEnum when:");
    println!("     • Static dispatch is preferred");
    println!("     • Doing many operations (batch processing)");
    println!("     • Fixed set of types is suitable");

    println!("\n✨ Demonstration completed!");
    Ok(())
}

pub fn new(storage: Box<dyn Storage>) -> VStorage

Основной конструктор принимающий готовое хранилище

Examples found in repository

examples/basic_usage.rs (line 19)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Basic v-storage Usage Example ===\n");

    // Create memory storage using Builder pattern
    let storage = VStorage::builder()
        .memory()
        .build()?;
    let mut storage = VStorage::new(storage);

    println!("✅ Storage created successfully");

    // === Basic data operations ===
    
    // 1. Storing data
    println!("\n📝 Storing data:");
    
    let _ = storage.put_value(StorageId::Individuals, "user:1", r#"{
        "@": "user:1", 
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Ivan Petrov"}],
        "foaf:name": [{"type": "String", "data": "Ivan"}],
        "foaf:familyName": [{"type": "String", "data": "Petrov"}], 
        "foaf:age": [{"type": "Integer", "data": 30}],
        "foaf:mbox": [{"type": "String", "data": "ivan.petrov@example.com"}],
        "veda:created": [{"type": "Datetime", "data": "2024-01-15T10:30:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Tickets, "ticket:123", r#"{
        "@": "ticket:123",
        "rdf:type": [{"type": "Uri", "data": "veda:Ticket"}],
        "rdfs:label": [{"type": "String", "data": "Support Request"}],
        "dcterms:title": [{"type": "String", "data": "Email server issue"}],
        "veda:status": [{"type": "String", "data": "pending"}],
        "veda:priority": [{"type": "String", "data": "medium"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T09:15:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Az, "permission:read", r#"{
        "@": "permission:read",
        "rdf:type": [{"type": "Uri", "data": "veda:Permission"}],
        "rdfs:label": [{"type": "String", "data": "Read Access"}],
        "veda:permissionSubject": [{"type": "Uri", "data": "user:1"}],
        "veda:permissionObject": [{"type": "Uri", "data": "resource:documents"}],
        "veda:canRead": [{"type": "Boolean", "data": true}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T08:00:00Z"}]
    }"#);

    println!("   • Stored user: user:1");
    println!("   • Stored ticket: ticket:123");
    println!("   • Stored permission: permission:read");

    // 2. Reading data
    println!("\n📖 Reading data:");
    
    if let StorageResult::Ok(user_data) = storage.get_value(StorageId::Individuals, "user:1") {
        println!("   • User Individual ({}): Ivan Petrov", user_data.len());
    }
    
    if let StorageResult::Ok(ticket_data) = storage.get_value(StorageId::Tickets, "ticket:123") {
        println!("   • Ticket Individual ({}): Support Request", ticket_data.len());
    }
    
    if let StorageResult::Ok(permission_data) = storage.get_value(StorageId::Az, "permission:read") {
        println!("   • Permission Individual ({}): Read Access", permission_data.len());
    }

    // 3. Working with binary data
    println!("\n🔢 Working with binary data:");
    
    let binary_data = vec![0xFF, 0xFE, 0xFD, 0x00, 0x01, 0x02];
    let _ = storage.put_raw_value(StorageId::Individuals, "binary:data", binary_data.clone());
    
    if let StorageResult::Ok(retrieved_binary) = storage.get_raw_value(StorageId::Individuals, "binary:data") {
        println!("   • Stored {} bytes of binary data", retrieved_binary.len());
        println!("   • Data matches: {}", retrieved_binary == binary_data);
    }

    // 4. Counting records
    println!("\n📊 Statistics:");
    
    if let StorageResult::Ok(individuals_count) = storage.count(StorageId::Individuals) {
        println!("   • Individuals count: {}", individuals_count);
    }
    
    if let StorageResult::Ok(tickets_count) = storage.count(StorageId::Tickets) {
        println!("   • Tickets count: {}", tickets_count);
    }
    
    if let StorageResult::Ok(az_count) = storage.count(StorageId::Az) {
        println!("   • Permissions count: {}", az_count);
    }

    // 5. Removing data
    println!("\n🗑️  Removing data:");
    
    let _ = storage.remove_value(StorageId::Tickets, "ticket:123");
    println!("   • Ticket ticket:123 removed");
    
    // Check that data is actually removed
    match storage.get_value(StorageId::Tickets, "ticket:123") {
        StorageResult::NotFound => println!("   • Confirmed: ticket not found"),
        _ => println!("   • Error: ticket still exists"),
    }

    // 6. Error handling
    println!("\n⚠️  Error handling:");
    
    match storage.get_value(StorageId::Individuals, "nonexistent") {
        StorageResult::NotFound => println!("   • Correctly handled missing key case"),
        StorageResult::Ok(_) => println!("   • Unexpected: found data"),
        StorageResult::Error(e) => println!("   • Error: {}", e),
        _ => println!("   • Other result"),
    }

    // === Backward compatibility demonstration ===
    println!("\n🔄 Backward compatibility:");
    
    #[allow(deprecated)]
    {
        // Using old methods
        let success = storage.put_kv(StorageId::Individuals, "old:key", "old:value");
        println!("   • Old put_kv: {}", if success { "success" } else { "error" });
        
        if let Some(value) = storage.get_v(StorageId::Individuals, "old:key") {
            println!("   • Old get_v: {}", value);
        }
    }

    println!("\n✨ Example completed successfully!");
    Ok(())
}

examples/storage_types.rs (line 21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== v-storage Storage Types Comparison ===\n");

    // === 1. Dynamic storage (VStorage) ===
    println!("🎭 1. Dynamic storage (VStorage)");
    println!("   • Uses trait objects (Box<dyn Storage>)");
    println!("   • Runtime flexibility, but has vtable lookup overhead");
    
    let storage_box = VStorage::builder().memory().build()?;
    let mut dynamic_storage = VStorage::new(storage_box);
    
    // Demonstrate operations
    let _ = dynamic_storage.put_value(StorageId::Individuals, "dynamic:key", "dynamic:value");
    
    if let StorageResult::Ok(value) = dynamic_storage.get_value(StorageId::Individuals, "dynamic:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", dynamic_storage.is_empty());

    // === 2. Generic storage (VStorageGeneric) ===
    println!("\n🔧 2. Generic storage (VStorageGeneric)");
    println!("   • Compile-time typing");
    println!("   • No vtable overhead, but less flexible");
    
    let mut generic_storage = VMemoryStorage::new(memory_storage::MemoryStorage::new());
    
    let _ = generic_storage.put_value(StorageId::Individuals, "generic:key", "generic:value");
    
    if let StorageResult::Ok(value) = generic_storage.get_value(StorageId::Individuals, "generic:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", generic_storage.is_empty());
    
    // Can extract inner storage
    if let Some(inner_storage) = generic_storage.storage() {
        println!("   • Access to inner storage: available");
    }

    // === 3. Enum storage (VStorageEnum) ===
    println!("\n⚡ 3. Enum storage (VStorageEnum)");
    println!("   • Static dispatch through enum");
    println!("   • Static dispatch");
    
    let mut enum_storage = VStorageEnum::memory();
    
    let _ = enum_storage.put_value(StorageId::Individuals, "enum:key", "enum:value");
    
    if let StorageResult::Ok(value) = enum_storage.get_value(StorageId::Individuals, "enum:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", enum_storage.is_empty());

    // === 4. API consistency ===
    println!("\n🔄 4. API consistency between types");
    println!("   • All types have the same Storage interface");
    
    let test_data = vec![
        ("test1", "value1"),
        ("test2", "value2"),
        ("test3", "value3"),
    ];

    // Store data in all storage types
    for (key, value) in &test_data {
        let _ = dynamic_storage.put_value(StorageId::Tickets, key, value);
        let _ = generic_storage.put_value(StorageId::Tickets, key, value);
        let _ = enum_storage.put_value(StorageId::Tickets, key, value);
    }

    // Check that all return the same results
    println!("   • Consistency check:");
    for (key, expected_value) in &test_data {
        let dynamic_result = dynamic_storage.get_value(StorageId::Tickets, key);
        let generic_result = generic_storage.get_value(StorageId::Tickets, key);
        let enum_result = enum_storage.get_value(StorageId::Tickets, key);

        match (dynamic_result, generic_result, enum_result) {
            (StorageResult::Ok(v1), StorageResult::Ok(v2), StorageResult::Ok(v3)) => {
                let consistent = v1 == *expected_value && v2 == *expected_value && v3 == *expected_value;
                println!("     {} -> {}", key, if consistent { "✅ consistent" } else { "❌ inconsistent" });
            }
            _ => println!("     {} -> ❌ read error", key),
        }
    }

    // === 5. Different constructor demonstrations ===
    println!("\n🏗️  5. Different ways to create storages");
    
    // VStorageEnum - direct creation
    let _enum_direct = VStorageEnum::memory();
    println!("   • VStorageEnum::memory() - direct creation");
    
    // VStorageGeneric - through constructor
    let _generic_direct = VMemoryStorage::new(memory_storage::MemoryStorage::new());
    println!("   • VMemoryStorage::new() - through constructor");
    
    // VStorage - through builder
    let _dynamic_builder = VStorage::builder().memory().build()?;
    println!("   • VStorage::builder() - through builder pattern");

    // === 6. Features of each type ===
    println!("\n📋 6. Usage characteristics");
    
    println!("   VStorage (Dynamic):");
    println!("     ✅ Maximum flexibility");
    println!("     ✅ Can change storage type at runtime");
    println!("     ❌ Vtable lookup overhead");
    println!("     ❌ No access to inner type");
    
    println!("   VStorageGeneric<T> (Generic):");
    println!("     ✅ Compile-time optimization");
    println!("     ✅ Access to inner storage");
    println!("     ✅ Type safety");
    println!("     ❌ Less flexible at runtime");
    
    println!("   VStorageEnum (Enum):");
    println!("     ✅ Static dispatch");
    println!("     ✅ No heap allocation for storage");
    println!("     ❌ Fixed set of types");

    // === 7. Usage recommendations ===
    println!("\n💡 7. Storage type selection recommendations");
    
    println!("   Use VStorage when:");
    println!("     • Maximum flexibility is needed");
    println!("     • Storage type is determined at runtime");
    println!("     • Flexibility is more important than dispatch overhead");
    
    println!("   Use VStorageGeneric when:");
    println!("     • Access to inner storage is needed");
    println!("     • Type safety is important");
    println!("     • Storage type is known at compile time");
    
    println!("   Use VStorageEnum when:");
    println!("     • Static dispatch is preferred");
    println!("     • Doing many operations (batch processing)");
    println!("     • Fixed set of types is suitable");

    println!("\n✨ Demonstration completed!");
    Ok(())
}

examples/individual_operations.rs (line 20)

fn main() {
    println!("=== Демонстрация работы с Individual в v-storage ===\n");

    // Создаем хранилище в памяти
    let mut storage = VStorage::new(Box::new(MemoryStorage::new()));
    
    // Создаем Individual
    let mut individual = Individual::default();
    
    println!("1. Загрузка несуществующего Individual:");
    match storage.get_individual("test:nonexistent", &mut individual) {
        StorageResult::Ok(_) => {
            println!("   ✓ Individual найден!");
            println!("   • ID: {}", individual.get_id());
        },
        StorageResult::UnprocessableEntity => {
            println!("   ✗ Individual найден, но не может быть обработан");
            println!("   • Возможно, данные повреждены или имеют неверный формат");
        },
        StorageResult::NotFound => {
            println!("   ✗ Individual не найден");
            println!("   • Ключ 'test:nonexistent' не существует в хранилище");
        },
        StorageResult::NotReady => {
            println!("   ✗ Хранилище не готово");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка: {}", msg);
        }
    }
    
    println!("\n2. Сохранение Individual данных:");
    
    // Сохраняем корректные данные Individual
    let individual_data = r#"{"@":"individual","@id":"test:person","rdfs:label":[{"data":"Тестовый пользователь","lang":"ru","type":"_string"}]}"#;
    
    match storage.put_value(StorageId::Individuals, "test:person", individual_data) {
        StorageResult::Ok(_) => {
            println!("   ✓ Individual успешно сохранен");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка при сохранении: {}", msg);
        },
        _ => {
            println!("   ✗ Неожиданная ошибка при сохранении");
        }
    }
    
    println!("\n3. Загрузка существующего Individual:");
    match storage.get_individual("test:person", &mut individual) {
        StorageResult::Ok(_) => {
            println!("   ✓ Individual успешно загружен!");
            println!("   • ID: {}", individual.get_id());
            println!("   • Сырые данные: {} байт", individual.get_raw_len());
        },
        StorageResult::UnprocessableEntity => {
            println!("   ✗ Individual найден, но не может быть обработан");
            println!("   • Проверьте формат данных");
        },
        StorageResult::NotFound => {
            println!("   ✗ Individual не найден");
        },
        StorageResult::NotReady => {
            println!("   ✗ Хранилище не готово");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка: {}", msg);
        }
    }
    
    println!("\n4. Тестирование с невалидными данными:");
    
    // Сохраняем невалидные данные
    let invalid_data = "это не JSON и не Individual";
    match storage.put_value(StorageId::Individuals, "test:invalid", invalid_data) {
        StorageResult::Ok(_) => {
            println!("   ✓ Невалидные данные сохранены (для тестирования)");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка при сохранении: {}", msg);
        },
        _ => {
            println!("   ✗ Неожиданная ошибка при сохранении");
        }
    }
    
    // Пытаемся загрузить невалидные данные
    match storage.get_individual("test:invalid", &mut individual) {
        StorageResult::Ok(_) => {
            println!("   ✓ Данные загружены (неожиданно)");
        },
        StorageResult::UnprocessableEntity => {
            println!("   ✓ Корректно обработаны невалидные данные");
            println!("   • Система правильно определила, что данные не являются Individual");
        },
        StorageResult::NotFound => {
            println!("   ✗ Данные не найдены (неожиданно)");
        },
        StorageResult::NotReady => {
            println!("   ✗ Хранилище не готово");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка: {}", msg);
        }
    }
    
    println!("\n5. Работа с различными типами хранилищ:");
    
    // Демонстрация работы с разными типами хранилищ
    let mut memory_storage = VStorageEnum::memory();
    
    println!("   • Память: сохранение данных...");
    match memory_storage.put_value(StorageId::Individuals, "test:memory", individual_data) {
        StorageResult::Ok(_) => {
            println!("     ✓ Данные сохранены в памяти");
            
            // Проверяем загрузку
                         match memory_storage.get_individual(StorageId::Individuals, "test:memory", &mut individual) {
                StorageResult::Ok(_) => {
                    println!("     ✓ Данные успешно загружены из памяти");
                    println!("     • ID: {}", individual.get_id());
                },
                result => {
                    println!("     ✗ Не удалось загрузить данные: {:?}", result);
                }
            }
        },
        StorageResult::Error(msg) => {
            println!("     ✗ Ошибка при сохранении: {}", msg);
        },
        _ => {
            println!("     ✗ Неожиданная ошибка при сохранении");
        }
    }
    
    println!("\n6. Подсчет количества Individual:");
    match storage.count(StorageId::Individuals) {
        StorageResult::Ok(count) => {
            println!("   ✓ В хранилище {} Individual(s)", count);
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка при подсчете: {}", msg);
        },
        _ => {
            println!("   ✗ Подсчет недоступен");
        }
    }
    
    println!("\n7. Лучшие практики:");
    println!("   • Всегда проверяйте StorageResult при загрузке Individual");
    println!("   • StorageResult::UnprocessableEntity означает, что данные есть, но не валидны");
    println!("   • StorageResult::NotFound означает, что данных нет");
    println!("   • StorageResult::NotReady означает, что хранилище не готово к работе");
    println!("   • Используйте соответствующие методы для разных типов данных");
    
    println!("\n=== Демонстрация завершена ===");
}

pub fn builder() -> StorageBuilder

Получает ссылку на Builder для создания хранилищ

Examples found in repository

examples/basic_usage.rs (line 16)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Basic v-storage Usage Example ===\n");

    // Create memory storage using Builder pattern
    let storage = VStorage::builder()
        .memory()
        .build()?;
    let mut storage = VStorage::new(storage);

    println!("✅ Storage created successfully");

    // === Basic data operations ===
    
    // 1. Storing data
    println!("\n📝 Storing data:");
    
    let _ = storage.put_value(StorageId::Individuals, "user:1", r#"{
        "@": "user:1", 
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Ivan Petrov"}],
        "foaf:name": [{"type": "String", "data": "Ivan"}],
        "foaf:familyName": [{"type": "String", "data": "Petrov"}], 
        "foaf:age": [{"type": "Integer", "data": 30}],
        "foaf:mbox": [{"type": "String", "data": "ivan.petrov@example.com"}],
        "veda:created": [{"type": "Datetime", "data": "2024-01-15T10:30:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Tickets, "ticket:123", r#"{
        "@": "ticket:123",
        "rdf:type": [{"type": "Uri", "data": "veda:Ticket"}],
        "rdfs:label": [{"type": "String", "data": "Support Request"}],
        "dcterms:title": [{"type": "String", "data": "Email server issue"}],
        "veda:status": [{"type": "String", "data": "pending"}],
        "veda:priority": [{"type": "String", "data": "medium"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T09:15:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Az, "permission:read", r#"{
        "@": "permission:read",
        "rdf:type": [{"type": "Uri", "data": "veda:Permission"}],
        "rdfs:label": [{"type": "String", "data": "Read Access"}],
        "veda:permissionSubject": [{"type": "Uri", "data": "user:1"}],
        "veda:permissionObject": [{"type": "Uri", "data": "resource:documents"}],
        "veda:canRead": [{"type": "Boolean", "data": true}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T08:00:00Z"}]
    }"#);

    println!("   • Stored user: user:1");
    println!("   • Stored ticket: ticket:123");
    println!("   • Stored permission: permission:read");

    // 2. Reading data
    println!("\n📖 Reading data:");
    
    if let StorageResult::Ok(user_data) = storage.get_value(StorageId::Individuals, "user:1") {
        println!("   • User Individual ({}): Ivan Petrov", user_data.len());
    }
    
    if let StorageResult::Ok(ticket_data) = storage.get_value(StorageId::Tickets, "ticket:123") {
        println!("   • Ticket Individual ({}): Support Request", ticket_data.len());
    }
    
    if let StorageResult::Ok(permission_data) = storage.get_value(StorageId::Az, "permission:read") {
        println!("   • Permission Individual ({}): Read Access", permission_data.len());
    }

    // 3. Working with binary data
    println!("\n🔢 Working with binary data:");
    
    let binary_data = vec![0xFF, 0xFE, 0xFD, 0x00, 0x01, 0x02];
    let _ = storage.put_raw_value(StorageId::Individuals, "binary:data", binary_data.clone());
    
    if let StorageResult::Ok(retrieved_binary) = storage.get_raw_value(StorageId::Individuals, "binary:data") {
        println!("   • Stored {} bytes of binary data", retrieved_binary.len());
        println!("   • Data matches: {}", retrieved_binary == binary_data);
    }

    // 4. Counting records
    println!("\n📊 Statistics:");
    
    if let StorageResult::Ok(individuals_count) = storage.count(StorageId::Individuals) {
        println!("   • Individuals count: {}", individuals_count);
    }
    
    if let StorageResult::Ok(tickets_count) = storage.count(StorageId::Tickets) {
        println!("   • Tickets count: {}", tickets_count);
    }
    
    if let StorageResult::Ok(az_count) = storage.count(StorageId::Az) {
        println!("   • Permissions count: {}", az_count);
    }

    // 5. Removing data
    println!("\n🗑️  Removing data:");
    
    let _ = storage.remove_value(StorageId::Tickets, "ticket:123");
    println!("   • Ticket ticket:123 removed");
    
    // Check that data is actually removed
    match storage.get_value(StorageId::Tickets, "ticket:123") {
        StorageResult::NotFound => println!("   • Confirmed: ticket not found"),
        _ => println!("   • Error: ticket still exists"),
    }

    // 6. Error handling
    println!("\n⚠️  Error handling:");
    
    match storage.get_value(StorageId::Individuals, "nonexistent") {
        StorageResult::NotFound => println!("   • Correctly handled missing key case"),
        StorageResult::Ok(_) => println!("   • Unexpected: found data"),
        StorageResult::Error(e) => println!("   • Error: {}", e),
        _ => println!("   • Other result"),
    }

    // === Backward compatibility demonstration ===
    println!("\n🔄 Backward compatibility:");
    
    #[allow(deprecated)]
    {
        // Using old methods
        let success = storage.put_kv(StorageId::Individuals, "old:key", "old:value");
        println!("   • Old put_kv: {}", if success { "success" } else { "error" });
        
        if let Some(value) = storage.get_v(StorageId::Individuals, "old:key") {
            println!("   • Old get_v: {}", value);
        }
    }

    println!("\n✨ Example completed successfully!");
    Ok(())
}

examples/storage_types.rs (line 20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== v-storage Storage Types Comparison ===\n");

    // === 1. Dynamic storage (VStorage) ===
    println!("🎭 1. Dynamic storage (VStorage)");
    println!("   • Uses trait objects (Box<dyn Storage>)");
    println!("   • Runtime flexibility, but has vtable lookup overhead");
    
    let storage_box = VStorage::builder().memory().build()?;
    let mut dynamic_storage = VStorage::new(storage_box);
    
    // Demonstrate operations
    let _ = dynamic_storage.put_value(StorageId::Individuals, "dynamic:key", "dynamic:value");
    
    if let StorageResult::Ok(value) = dynamic_storage.get_value(StorageId::Individuals, "dynamic:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", dynamic_storage.is_empty());

    // === 2. Generic storage (VStorageGeneric) ===
    println!("\n🔧 2. Generic storage (VStorageGeneric)");
    println!("   • Compile-time typing");
    println!("   • No vtable overhead, but less flexible");
    
    let mut generic_storage = VMemoryStorage::new(memory_storage::MemoryStorage::new());
    
    let _ = generic_storage.put_value(StorageId::Individuals, "generic:key", "generic:value");
    
    if let StorageResult::Ok(value) = generic_storage.get_value(StorageId::Individuals, "generic:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", generic_storage.is_empty());
    
    // Can extract inner storage
    if let Some(inner_storage) = generic_storage.storage() {
        println!("   • Access to inner storage: available");
    }

    // === 3. Enum storage (VStorageEnum) ===
    println!("\n⚡ 3. Enum storage (VStorageEnum)");
    println!("   • Static dispatch through enum");
    println!("   • Static dispatch");
    
    let mut enum_storage = VStorageEnum::memory();
    
    let _ = enum_storage.put_value(StorageId::Individuals, "enum:key", "enum:value");
    
    if let StorageResult::Ok(value) = enum_storage.get_value(StorageId::Individuals, "enum:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", enum_storage.is_empty());

    // === 4. API consistency ===
    println!("\n🔄 4. API consistency between types");
    println!("   • All types have the same Storage interface");
    
    let test_data = vec![
        ("test1", "value1"),
        ("test2", "value2"),
        ("test3", "value3"),
    ];

    // Store data in all storage types
    for (key, value) in &test_data {
        let _ = dynamic_storage.put_value(StorageId::Tickets, key, value);
        let _ = generic_storage.put_value(StorageId::Tickets, key, value);
        let _ = enum_storage.put_value(StorageId::Tickets, key, value);
    }

    // Check that all return the same results
    println!("   • Consistency check:");
    for (key, expected_value) in &test_data {
        let dynamic_result = dynamic_storage.get_value(StorageId::Tickets, key);
        let generic_result = generic_storage.get_value(StorageId::Tickets, key);
        let enum_result = enum_storage.get_value(StorageId::Tickets, key);

        match (dynamic_result, generic_result, enum_result) {
            (StorageResult::Ok(v1), StorageResult::Ok(v2), StorageResult::Ok(v3)) => {
                let consistent = v1 == *expected_value && v2 == *expected_value && v3 == *expected_value;
                println!("     {} -> {}", key, if consistent { "✅ consistent" } else { "❌ inconsistent" });
            }
            _ => println!("     {} -> ❌ read error", key),
        }
    }

    // === 5. Different constructor demonstrations ===
    println!("\n🏗️  5. Different ways to create storages");
    
    // VStorageEnum - direct creation
    let _enum_direct = VStorageEnum::memory();
    println!("   • VStorageEnum::memory() - direct creation");
    
    // VStorageGeneric - through constructor
    let _generic_direct = VMemoryStorage::new(memory_storage::MemoryStorage::new());
    println!("   • VMemoryStorage::new() - through constructor");
    
    // VStorage - through builder
    let _dynamic_builder = VStorage::builder().memory().build()?;
    println!("   • VStorage::builder() - through builder pattern");

    // === 6. Features of each type ===
    println!("\n📋 6. Usage characteristics");
    
    println!("   VStorage (Dynamic):");
    println!("     ✅ Maximum flexibility");
    println!("     ✅ Can change storage type at runtime");
    println!("     ❌ Vtable lookup overhead");
    println!("     ❌ No access to inner type");
    
    println!("   VStorageGeneric<T> (Generic):");
    println!("     ✅ Compile-time optimization");
    println!("     ✅ Access to inner storage");
    println!("     ✅ Type safety");
    println!("     ❌ Less flexible at runtime");
    
    println!("   VStorageEnum (Enum):");
    println!("     ✅ Static dispatch");
    println!("     ✅ No heap allocation for storage");
    println!("     ❌ Fixed set of types");

    // === 7. Usage recommendations ===
    println!("\n💡 7. Storage type selection recommendations");
    
    println!("   Use VStorage when:");
    println!("     • Maximum flexibility is needed");
    println!("     • Storage type is determined at runtime");
    println!("     • Flexibility is more important than dispatch overhead");
    
    println!("   Use VStorageGeneric when:");
    println!("     • Access to inner storage is needed");
    println!("     • Type safety is important");
    println!("     • Storage type is known at compile time");
    
    println!("   Use VStorageEnum when:");
    println!("     • Static dispatch is preferred");
    println!("     • Doing many operations (batch processing)");
    println!("     • Fixed set of types is suitable");

    println!("\n✨ Demonstration completed!");
    Ok(())
}

pub fn from_config(config: StorageConfig) -> Result<VStorage, StorageError>

Создание через конфигурацию

Examples found in repository

examples/factory_patterns.rs (line 96)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== v-storage Factory Patterns Demonstration ===\n");

    // === 1. Builder Pattern ===
    println!("🏗️  1. Builder Pattern - step-by-step creation");
    println!("   • Flexible and readable way to configure storage");
    
    // Create memory storage through builder
    let memory_storage = StorageBuilder::new()
        .memory()
        .build()?;
    println!("   • Created memory storage through builder");
    
    // Create LMDB storage through builder
    let lmdb_storage = StorageBuilder::new()
        .lmdb("/tmp/example_lmdb", StorageMode::ReadWrite, Some(1000))
        .build();
    
    match lmdb_storage {
        Ok(_) => println!("   • Created LMDB storage through builder"),
        Err(e) => println!("   • LMDB unavailable: {}", e),
    }
    
    // Create remote storage through builder
    let remote_storage = StorageBuilder::new()
        .remote("127.0.0.1:8080")
        .build();
    
    match remote_storage {
        Ok(_) => println!("   • Created remote storage through builder"),
        Err(e) => println!("   • Remote unavailable: {}", e),
    }

    // === 2. Provider Pattern ===
    println!("\n🏭 2. Provider Pattern - ready factory methods");
    println!("   • Quick creation of standard configurations");
    
    // Direct creation of storages through Provider
    let _provider_memory = StorageProvider::memory();
    println!("   • StorageProvider::memory() - created");
    
    let _provider_lmdb = StorageProvider::lmdb("/tmp/provider_lmdb", StorageMode::ReadOnly, None);
    println!("   • StorageProvider::lmdb() - created");
    
    let _provider_remote = StorageProvider::remote("127.0.0.1:8080");
    println!("   • StorageProvider::remote() - created");
    
    // Create VStorage through Provider
    let mut vstorage_memory = StorageProvider::vstorage_memory();
    println!("   • StorageProvider::vstorage_memory() - created VStorage");
    
    // Demonstrate functionality with semantic Individual
    let provider_individual = r#"{
        "@": "provider:test",
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Provider Test User"}],
        "foaf:name": [{"type": "String", "data": "Test"}],
        "veda:createdBy": [{"type": "Uri", "data": "provider:factory"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T17:00:00Z"}]
    }"#;
    
    let _ = vstorage_memory.put_value(StorageId::Individuals, "provider:test", provider_individual);
    if let StorageResult::Ok(value) = vstorage_memory.get_value(StorageId::Individuals, "provider:test") {
        println!("     Test: stored Individual ({} bytes) through Provider", value.len());
    }

    // === 3. Config Pattern ===
    println!("\n⚙️  3. Config Pattern - creation from configuration");
    println!("   • Creating storages from configuration structures");
    
    // Create from different configurations
    let configs = vec![
        ("Memory", StorageConfig::Memory),
        ("LMDB", StorageConfig::Lmdb { 
            path: "/tmp/config_lmdb".to_string(), 
            mode: StorageMode::ReadWrite, 
            max_read_counter_reopen: Some(500) 
        }),
        ("Remote", StorageConfig::Remote { 
            address: "127.0.0.1:8080".to_string() 
        }),
    ];
    
    for (name, config) in configs {
        match VStorage::from_config(config) {
            Ok(mut storage) => {
                println!("   • {} configuration: created successfully", name);
                
                // Test the created storage with semantic Individual
                let test_key = format!("config:{}:key", name.to_lowercase());
                let test_value = format!(r#"{{
                    "@": "{}",
                    "rdf:type": [{{"type": "Uri", "data": "veda:ConfigTest"}}],
                    "rdfs:label": [{{"type": "String", "data": "Config Test for {}"}}],
                    "veda:configType": [{{"type": "String", "data": "{}"}}],
                    "dcterms:created": [{{"type": "Datetime", "data": "2024-01-15T17:30:00Z"}}]
                }}"#, test_key, name, name);
                
                let _ = storage.put_value(StorageId::Individuals, &test_key, &test_value);
                if let StorageResult::Ok(retrieved) = storage.get_value(StorageId::Individuals, &test_key) {
                    println!("     Test: {} Individual ({} bytes)", name, retrieved.len());
                }
            },
            Err(e) => println!("   • {} configuration: error - {}", name, e),
        }
    }

    // === 4. Generic Builders ===
    println!("\n🔧 4. Generic Builders - compile-time optimization");
    println!("   • Typed builders without runtime overhead");
    
    // Generic memory builder
    let generic_memory = StorageBuilder::new()
        .memory()
        .build_memory_generic()?;
    println!("   • build_memory_generic() - created VMemoryStorage");
    
    // Generic LMDB builder
    let generic_lmdb = StorageBuilder::new()
        .lmdb("/tmp/generic_lmdb", StorageMode::ReadWrite, None)
        .build_lmdb_generic();
    
    match generic_lmdb {
        Ok(_storage) => println!("   • build_lmdb_generic() - created VLMDBStorage"),
        Err(e) => println!("   • build_lmdb_generic() - error: {}", e),
    }
    
    // Generic remote builder
    let generic_remote = StorageBuilder::new()
        .remote("127.0.0.1:8080")
        .build_remote_generic();
    
    match generic_remote {
        Ok(_storage) => println!("   • build_remote_generic() - created VRemoteStorage"),
        Err(e) => println!("   • build_remote_generic() - error: {}", e),
    }

    // === 5. Provider Generic Methods ===
    println!("\n🎯 5. Provider Generic Methods - static types");
    println!("   • Direct creation of typed storages");
    
    let mut provider_generic_memory = StorageProvider::memory_generic();
    println!("   • StorageProvider::memory_generic() - VMemoryStorage");
    
    let provider_generic_lmdb = StorageProvider::lmdb_generic("/tmp/generic_provider", StorageMode::ReadOnly, None);
    println!("   • StorageProvider::lmdb_generic() - VLMDBStorage");
    
    let provider_generic_remote = StorageProvider::remote_generic("127.0.0.1:8080");
    println!("   • StorageProvider::remote_generic() - VRemoteStorage");
    
    // Demonstrate work with typed storage using semantic Individual
    let generic_individual = r#"{
        "@": "generic:test",
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Generic Test User"}],
        "foaf:name": [{"type": "String", "data": "Generic"}],
        "veda:storageType": [{"type": "String", "data": "memory_generic"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T18:00:00Z"}]
    }"#;
    
    let _ = provider_generic_memory.put_value(StorageId::Individuals, "generic:test", generic_individual);
    if let StorageResult::Ok(value) = provider_generic_memory.get_value(StorageId::Individuals, "generic:test") {
        println!("     Generic test: Individual ({} bytes)", value.len());
    }

    // === 6. Approach comparison ===
    println!("\n📊 6. Storage creation approach comparison");
    
    println!("   Builder Pattern:");
    println!("     ✅ Readable and flexible API");
    println!("     ✅ Validation at build() stage");
    println!("     ✅ Can create both dynamic and generic types");
    println!("     ❌ More code for simple cases");
    
    println!("   Provider Pattern:");
    println!("     ✅ Concise code for standard cases");
    println!("     ✅ Ready optimal configurations");
    println!("     ❌ Less flexible for customization");
    
    println!("   Config Pattern:");
    println!("     ✅ Excellent for loading from files/ENV");
    println!("     ✅ Unified interface for all types");
    println!("     ❌ Only dynamic dispatch");
    
    println!("   Generic Methods:");
    println!("     ✅ Static dispatch");
    println!("     ✅ Compile-time typing");
    println!("     ❌ Less flexible at runtime");

    // === 7. Usage recommendations ===
    println!("\n💡 7. Pattern selection recommendations");
    
    println!("   Use Builder when:");
    println!("     • Parameter customization is needed");
    println!("     • Complex creation logic");
    println!("     • Code readability is needed");
    
    println!("   Use Provider when:");
    println!("     • Need to quickly create standard storage");
    println!("     • Default parameters are suitable");
    println!("     • Minimal boilerplate code");
    
    println!("   Use Config when:");
    println!("     • Configuration is loaded from external sources");
    println!("     • Storage type is determined at runtime");
    println!("     • Uniform handling of different types is needed");
    
    println!("   Use Generic methods when:");
    println!("     • Static dispatch is preferred");
    println!("     • Storage type is known at compile time");
    println!("     • Access to type-specific methods is needed");

    println!("\n✨ Factory patterns demonstration completed!");
    Ok(())
}

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

Examples found in repository

examples/individual_operations.rs (line 26)

fn main() {
    println!("=== Демонстрация работы с Individual в v-storage ===\n");

    // Создаем хранилище в памяти
    let mut storage = VStorage::new(Box::new(MemoryStorage::new()));
    
    // Создаем Individual
    let mut individual = Individual::default();
    
    println!("1. Загрузка несуществующего Individual:");
    match storage.get_individual("test:nonexistent", &mut individual) {
        StorageResult::Ok(_) => {
            println!("   ✓ Individual найден!");
            println!("   • ID: {}", individual.get_id());
        },
        StorageResult::UnprocessableEntity => {
            println!("   ✗ Individual найден, но не может быть обработан");
            println!("   • Возможно, данные повреждены или имеют неверный формат");
        },
        StorageResult::NotFound => {
            println!("   ✗ Individual не найден");
            println!("   • Ключ 'test:nonexistent' не существует в хранилище");
        },
        StorageResult::NotReady => {
            println!("   ✗ Хранилище не готово");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка: {}", msg);
        }
    }
    
    println!("\n2. Сохранение Individual данных:");
    
    // Сохраняем корректные данные Individual
    let individual_data = r#"{"@":"individual","@id":"test:person","rdfs:label":[{"data":"Тестовый пользователь","lang":"ru","type":"_string"}]}"#;
    
    match storage.put_value(StorageId::Individuals, "test:person", individual_data) {
        StorageResult::Ok(_) => {
            println!("   ✓ Individual успешно сохранен");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка при сохранении: {}", msg);
        },
        _ => {
            println!("   ✗ Неожиданная ошибка при сохранении");
        }
    }
    
    println!("\n3. Загрузка существующего Individual:");
    match storage.get_individual("test:person", &mut individual) {
        StorageResult::Ok(_) => {
            println!("   ✓ Individual успешно загружен!");
            println!("   • ID: {}", individual.get_id());
            println!("   • Сырые данные: {} байт", individual.get_raw_len());
        },
        StorageResult::UnprocessableEntity => {
            println!("   ✗ Individual найден, но не может быть обработан");
            println!("   • Проверьте формат данных");
        },
        StorageResult::NotFound => {
            println!("   ✗ Individual не найден");
        },
        StorageResult::NotReady => {
            println!("   ✗ Хранилище не готово");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка: {}", msg);
        }
    }
    
    println!("\n4. Тестирование с невалидными данными:");
    
    // Сохраняем невалидные данные
    let invalid_data = "это не JSON и не Individual";
    match storage.put_value(StorageId::Individuals, "test:invalid", invalid_data) {
        StorageResult::Ok(_) => {
            println!("   ✓ Невалидные данные сохранены (для тестирования)");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка при сохранении: {}", msg);
        },
        _ => {
            println!("   ✗ Неожиданная ошибка при сохранении");
        }
    }
    
    // Пытаемся загрузить невалидные данные
    match storage.get_individual("test:invalid", &mut individual) {
        StorageResult::Ok(_) => {
            println!("   ✓ Данные загружены (неожиданно)");
        },
        StorageResult::UnprocessableEntity => {
            println!("   ✓ Корректно обработаны невалидные данные");
            println!("   • Система правильно определила, что данные не являются Individual");
        },
        StorageResult::NotFound => {
            println!("   ✗ Данные не найдены (неожиданно)");
        },
        StorageResult::NotReady => {
            println!("   ✗ Хранилище не готово");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка: {}", msg);
        }
    }
    
    println!("\n5. Работа с различными типами хранилищ:");
    
    // Демонстрация работы с разными типами хранилищ
    let mut memory_storage = VStorageEnum::memory();
    
    println!("   • Память: сохранение данных...");
    match memory_storage.put_value(StorageId::Individuals, "test:memory", individual_data) {
        StorageResult::Ok(_) => {
            println!("     ✓ Данные сохранены в памяти");
            
            // Проверяем загрузку
                         match memory_storage.get_individual(StorageId::Individuals, "test:memory", &mut individual) {
                StorageResult::Ok(_) => {
                    println!("     ✓ Данные успешно загружены из памяти");
                    println!("     • ID: {}", individual.get_id());
                },
                result => {
                    println!("     ✗ Не удалось загрузить данные: {:?}", result);
                }
            }
        },
        StorageResult::Error(msg) => {
            println!("     ✗ Ошибка при сохранении: {}", msg);
        },
        _ => {
            println!("     ✗ Неожиданная ошибка при сохранении");
        }
    }
    
    println!("\n6. Подсчет количества Individual:");
    match storage.count(StorageId::Individuals) {
        StorageResult::Ok(count) => {
            println!("   ✓ В хранилище {} Individual(s)", count);
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка при подсчете: {}", msg);
        },
        _ => {
            println!("   ✗ Подсчет недоступен");
        }
    }
    
    println!("\n7. Лучшие практики:");
    println!("   • Всегда проверяйте StorageResult при загрузке Individual");
    println!("   • StorageResult::UnprocessableEntity означает, что данные есть, но не валидны");
    println!("   • StorageResult::NotFound означает, что данных нет");
    println!("   • StorageResult::NotReady означает, что хранилище не готово к работе");
    println!("   • Используйте соответствующие методы для разных типов данных");
    
    println!("\n=== Демонстрация завершена ===");
}

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

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

Examples found in repository

examples/basic_usage.rs (line 64)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Basic v-storage Usage Example ===\n");

    // Create memory storage using Builder pattern
    let storage = VStorage::builder()
        .memory()
        .build()?;
    let mut storage = VStorage::new(storage);

    println!("✅ Storage created successfully");

    // === Basic data operations ===
    
    // 1. Storing data
    println!("\n📝 Storing data:");
    
    let _ = storage.put_value(StorageId::Individuals, "user:1", r#"{
        "@": "user:1", 
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Ivan Petrov"}],
        "foaf:name": [{"type": "String", "data": "Ivan"}],
        "foaf:familyName": [{"type": "String", "data": "Petrov"}], 
        "foaf:age": [{"type": "Integer", "data": 30}],
        "foaf:mbox": [{"type": "String", "data": "ivan.petrov@example.com"}],
        "veda:created": [{"type": "Datetime", "data": "2024-01-15T10:30:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Tickets, "ticket:123", r#"{
        "@": "ticket:123",
        "rdf:type": [{"type": "Uri", "data": "veda:Ticket"}],
        "rdfs:label": [{"type": "String", "data": "Support Request"}],
        "dcterms:title": [{"type": "String", "data": "Email server issue"}],
        "veda:status": [{"type": "String", "data": "pending"}],
        "veda:priority": [{"type": "String", "data": "medium"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T09:15:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Az, "permission:read", r#"{
        "@": "permission:read",
        "rdf:type": [{"type": "Uri", "data": "veda:Permission"}],
        "rdfs:label": [{"type": "String", "data": "Read Access"}],
        "veda:permissionSubject": [{"type": "Uri", "data": "user:1"}],
        "veda:permissionObject": [{"type": "Uri", "data": "resource:documents"}],
        "veda:canRead": [{"type": "Boolean", "data": true}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T08:00:00Z"}]
    }"#);

    println!("   • Stored user: user:1");
    println!("   • Stored ticket: ticket:123");
    println!("   • Stored permission: permission:read");

    // 2. Reading data
    println!("\n📖 Reading data:");
    
    if let StorageResult::Ok(user_data) = storage.get_value(StorageId::Individuals, "user:1") {
        println!("   • User Individual ({}): Ivan Petrov", user_data.len());
    }
    
    if let StorageResult::Ok(ticket_data) = storage.get_value(StorageId::Tickets, "ticket:123") {
        println!("   • Ticket Individual ({}): Support Request", ticket_data.len());
    }
    
    if let StorageResult::Ok(permission_data) = storage.get_value(StorageId::Az, "permission:read") {
        println!("   • Permission Individual ({}): Read Access", permission_data.len());
    }

    // 3. Working with binary data
    println!("\n🔢 Working with binary data:");
    
    let binary_data = vec![0xFF, 0xFE, 0xFD, 0x00, 0x01, 0x02];
    let _ = storage.put_raw_value(StorageId::Individuals, "binary:data", binary_data.clone());
    
    if let StorageResult::Ok(retrieved_binary) = storage.get_raw_value(StorageId::Individuals, "binary:data") {
        println!("   • Stored {} bytes of binary data", retrieved_binary.len());
        println!("   • Data matches: {}", retrieved_binary == binary_data);
    }

    // 4. Counting records
    println!("\n📊 Statistics:");
    
    if let StorageResult::Ok(individuals_count) = storage.count(StorageId::Individuals) {
        println!("   • Individuals count: {}", individuals_count);
    }
    
    if let StorageResult::Ok(tickets_count) = storage.count(StorageId::Tickets) {
        println!("   • Tickets count: {}", tickets_count);
    }
    
    if let StorageResult::Ok(az_count) = storage.count(StorageId::Az) {
        println!("   • Permissions count: {}", az_count);
    }

    // 5. Removing data
    println!("\n🗑️  Removing data:");
    
    let _ = storage.remove_value(StorageId::Tickets, "ticket:123");
    println!("   • Ticket ticket:123 removed");
    
    // Check that data is actually removed
    match storage.get_value(StorageId::Tickets, "ticket:123") {
        StorageResult::NotFound => println!("   • Confirmed: ticket not found"),
        _ => println!("   • Error: ticket still exists"),
    }

    // 6. Error handling
    println!("\n⚠️  Error handling:");
    
    match storage.get_value(StorageId::Individuals, "nonexistent") {
        StorageResult::NotFound => println!("   • Correctly handled missing key case"),
        StorageResult::Ok(_) => println!("   • Unexpected: found data"),
        StorageResult::Error(e) => println!("   • Error: {}", e),
        _ => println!("   • Other result"),
    }

    // === Backward compatibility demonstration ===
    println!("\n🔄 Backward compatibility:");
    
    #[allow(deprecated)]
    {
        // Using old methods
        let success = storage.put_kv(StorageId::Individuals, "old:key", "old:value");
        println!("   • Old put_kv: {}", if success { "success" } else { "error" });
        
        if let Some(value) = storage.get_v(StorageId::Individuals, "old:key") {
            println!("   • Old get_v: {}", value);
        }
    }

    println!("\n✨ Example completed successfully!");
    Ok(())
}

examples/storage_types.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== v-storage Storage Types Comparison ===\n");

    // === 1. Dynamic storage (VStorage) ===
    println!("🎭 1. Dynamic storage (VStorage)");
    println!("   • Uses trait objects (Box<dyn Storage>)");
    println!("   • Runtime flexibility, but has vtable lookup overhead");
    
    let storage_box = VStorage::builder().memory().build()?;
    let mut dynamic_storage = VStorage::new(storage_box);
    
    // Demonstrate operations
    let _ = dynamic_storage.put_value(StorageId::Individuals, "dynamic:key", "dynamic:value");
    
    if let StorageResult::Ok(value) = dynamic_storage.get_value(StorageId::Individuals, "dynamic:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", dynamic_storage.is_empty());

    // === 2. Generic storage (VStorageGeneric) ===
    println!("\n🔧 2. Generic storage (VStorageGeneric)");
    println!("   • Compile-time typing");
    println!("   • No vtable overhead, but less flexible");
    
    let mut generic_storage = VMemoryStorage::new(memory_storage::MemoryStorage::new());
    
    let _ = generic_storage.put_value(StorageId::Individuals, "generic:key", "generic:value");
    
    if let StorageResult::Ok(value) = generic_storage.get_value(StorageId::Individuals, "generic:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", generic_storage.is_empty());
    
    // Can extract inner storage
    if let Some(inner_storage) = generic_storage.storage() {
        println!("   • Access to inner storage: available");
    }

    // === 3. Enum storage (VStorageEnum) ===
    println!("\n⚡ 3. Enum storage (VStorageEnum)");
    println!("   • Static dispatch through enum");
    println!("   • Static dispatch");
    
    let mut enum_storage = VStorageEnum::memory();
    
    let _ = enum_storage.put_value(StorageId::Individuals, "enum:key", "enum:value");
    
    if let StorageResult::Ok(value) = enum_storage.get_value(StorageId::Individuals, "enum:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", enum_storage.is_empty());

    // === 4. API consistency ===
    println!("\n🔄 4. API consistency between types");
    println!("   • All types have the same Storage interface");
    
    let test_data = vec![
        ("test1", "value1"),
        ("test2", "value2"),
        ("test3", "value3"),
    ];

    // Store data in all storage types
    for (key, value) in &test_data {
        let _ = dynamic_storage.put_value(StorageId::Tickets, key, value);
        let _ = generic_storage.put_value(StorageId::Tickets, key, value);
        let _ = enum_storage.put_value(StorageId::Tickets, key, value);
    }

    // Check that all return the same results
    println!("   • Consistency check:");
    for (key, expected_value) in &test_data {
        let dynamic_result = dynamic_storage.get_value(StorageId::Tickets, key);
        let generic_result = generic_storage.get_value(StorageId::Tickets, key);
        let enum_result = enum_storage.get_value(StorageId::Tickets, key);

        match (dynamic_result, generic_result, enum_result) {
            (StorageResult::Ok(v1), StorageResult::Ok(v2), StorageResult::Ok(v3)) => {
                let consistent = v1 == *expected_value && v2 == *expected_value && v3 == *expected_value;
                println!("     {} -> {}", key, if consistent { "✅ consistent" } else { "❌ inconsistent" });
            }
            _ => println!("     {} -> ❌ read error", key),
        }
    }

    // === 5. Different constructor demonstrations ===
    println!("\n🏗️  5. Different ways to create storages");
    
    // VStorageEnum - direct creation
    let _enum_direct = VStorageEnum::memory();
    println!("   • VStorageEnum::memory() - direct creation");
    
    // VStorageGeneric - through constructor
    let _generic_direct = VMemoryStorage::new(memory_storage::MemoryStorage::new());
    println!("   • VMemoryStorage::new() - through constructor");
    
    // VStorage - through builder
    let _dynamic_builder = VStorage::builder().memory().build()?;
    println!("   • VStorage::builder() - through builder pattern");

    // === 6. Features of each type ===
    println!("\n📋 6. Usage characteristics");
    
    println!("   VStorage (Dynamic):");
    println!("     ✅ Maximum flexibility");
    println!("     ✅ Can change storage type at runtime");
    println!("     ❌ Vtable lookup overhead");
    println!("     ❌ No access to inner type");
    
    println!("   VStorageGeneric<T> (Generic):");
    println!("     ✅ Compile-time optimization");
    println!("     ✅ Access to inner storage");
    println!("     ✅ Type safety");
    println!("     ❌ Less flexible at runtime");
    
    println!("   VStorageEnum (Enum):");
    println!("     ✅ Static dispatch");
    println!("     ✅ No heap allocation for storage");
    println!("     ❌ Fixed set of types");

    // === 7. Usage recommendations ===
    println!("\n💡 7. Storage type selection recommendations");
    
    println!("   Use VStorage when:");
    println!("     • Maximum flexibility is needed");
    println!("     • Storage type is determined at runtime");
    println!("     • Flexibility is more important than dispatch overhead");
    
    println!("   Use VStorageGeneric when:");
    println!("     • Access to inner storage is needed");
    println!("     • Type safety is important");
    println!("     • Storage type is known at compile time");
    
    println!("   Use VStorageEnum when:");
    println!("     • Static dispatch is preferred");
    println!("     • Doing many operations (batch processing)");
    println!("     • Fixed set of types is suitable");

    println!("\n✨ Demonstration completed!");
    Ok(())
}

examples/factory_patterns.rs (line 74)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== v-storage Factory Patterns Demonstration ===\n");

    // === 1. Builder Pattern ===
    println!("🏗️  1. Builder Pattern - step-by-step creation");
    println!("   • Flexible and readable way to configure storage");
    
    // Create memory storage through builder
    let memory_storage = StorageBuilder::new()
        .memory()
        .build()?;
    println!("   • Created memory storage through builder");
    
    // Create LMDB storage through builder
    let lmdb_storage = StorageBuilder::new()
        .lmdb("/tmp/example_lmdb", StorageMode::ReadWrite, Some(1000))
        .build();
    
    match lmdb_storage {
        Ok(_) => println!("   • Created LMDB storage through builder"),
        Err(e) => println!("   • LMDB unavailable: {}", e),
    }
    
    // Create remote storage through builder
    let remote_storage = StorageBuilder::new()
        .remote("127.0.0.1:8080")
        .build();
    
    match remote_storage {
        Ok(_) => println!("   • Created remote storage through builder"),
        Err(e) => println!("   • Remote unavailable: {}", e),
    }

    // === 2. Provider Pattern ===
    println!("\n🏭 2. Provider Pattern - ready factory methods");
    println!("   • Quick creation of standard configurations");
    
    // Direct creation of storages through Provider
    let _provider_memory = StorageProvider::memory();
    println!("   • StorageProvider::memory() - created");
    
    let _provider_lmdb = StorageProvider::lmdb("/tmp/provider_lmdb", StorageMode::ReadOnly, None);
    println!("   • StorageProvider::lmdb() - created");
    
    let _provider_remote = StorageProvider::remote("127.0.0.1:8080");
    println!("   • StorageProvider::remote() - created");
    
    // Create VStorage through Provider
    let mut vstorage_memory = StorageProvider::vstorage_memory();
    println!("   • StorageProvider::vstorage_memory() - created VStorage");
    
    // Demonstrate functionality with semantic Individual
    let provider_individual = r#"{
        "@": "provider:test",
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Provider Test User"}],
        "foaf:name": [{"type": "String", "data": "Test"}],
        "veda:createdBy": [{"type": "Uri", "data": "provider:factory"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T17:00:00Z"}]
    }"#;
    
    let _ = vstorage_memory.put_value(StorageId::Individuals, "provider:test", provider_individual);
    if let StorageResult::Ok(value) = vstorage_memory.get_value(StorageId::Individuals, "provider:test") {
        println!("     Test: stored Individual ({} bytes) through Provider", value.len());
    }

    // === 3. Config Pattern ===
    println!("\n⚙️  3. Config Pattern - creation from configuration");
    println!("   • Creating storages from configuration structures");
    
    // Create from different configurations
    let configs = vec![
        ("Memory", StorageConfig::Memory),
        ("LMDB", StorageConfig::Lmdb { 
            path: "/tmp/config_lmdb".to_string(), 
            mode: StorageMode::ReadWrite, 
            max_read_counter_reopen: Some(500) 
        }),
        ("Remote", StorageConfig::Remote { 
            address: "127.0.0.1:8080".to_string() 
        }),
    ];
    
    for (name, config) in configs {
        match VStorage::from_config(config) {
            Ok(mut storage) => {
                println!("   • {} configuration: created successfully", name);
                
                // Test the created storage with semantic Individual
                let test_key = format!("config:{}:key", name.to_lowercase());
                let test_value = format!(r#"{{
                    "@": "{}",
                    "rdf:type": [{{"type": "Uri", "data": "veda:ConfigTest"}}],
                    "rdfs:label": [{{"type": "String", "data": "Config Test for {}"}}],
                    "veda:configType": [{{"type": "String", "data": "{}"}}],
                    "dcterms:created": [{{"type": "Datetime", "data": "2024-01-15T17:30:00Z"}}]
                }}"#, test_key, name, name);
                
                let _ = storage.put_value(StorageId::Individuals, &test_key, &test_value);
                if let StorageResult::Ok(retrieved) = storage.get_value(StorageId::Individuals, &test_key) {
                    println!("     Test: {} Individual ({} bytes)", name, retrieved.len());
                }
            },
            Err(e) => println!("   • {} configuration: error - {}", name, e),
        }
    }

    // === 4. Generic Builders ===
    println!("\n🔧 4. Generic Builders - compile-time optimization");
    println!("   • Typed builders without runtime overhead");
    
    // Generic memory builder
    let generic_memory = StorageBuilder::new()
        .memory()
        .build_memory_generic()?;
    println!("   • build_memory_generic() - created VMemoryStorage");
    
    // Generic LMDB builder
    let generic_lmdb = StorageBuilder::new()
        .lmdb("/tmp/generic_lmdb", StorageMode::ReadWrite, None)
        .build_lmdb_generic();
    
    match generic_lmdb {
        Ok(_storage) => println!("   • build_lmdb_generic() - created VLMDBStorage"),
        Err(e) => println!("   • build_lmdb_generic() - error: {}", e),
    }
    
    // Generic remote builder
    let generic_remote = StorageBuilder::new()
        .remote("127.0.0.1:8080")
        .build_remote_generic();
    
    match generic_remote {
        Ok(_storage) => println!("   • build_remote_generic() - created VRemoteStorage"),
        Err(e) => println!("   • build_remote_generic() - error: {}", e),
    }

    // === 5. Provider Generic Methods ===
    println!("\n🎯 5. Provider Generic Methods - static types");
    println!("   • Direct creation of typed storages");
    
    let mut provider_generic_memory = StorageProvider::memory_generic();
    println!("   • StorageProvider::memory_generic() - VMemoryStorage");
    
    let provider_generic_lmdb = StorageProvider::lmdb_generic("/tmp/generic_provider", StorageMode::ReadOnly, None);
    println!("   • StorageProvider::lmdb_generic() - VLMDBStorage");
    
    let provider_generic_remote = StorageProvider::remote_generic("127.0.0.1:8080");
    println!("   • StorageProvider::remote_generic() - VRemoteStorage");
    
    // Demonstrate work with typed storage using semantic Individual
    let generic_individual = r#"{
        "@": "generic:test",
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Generic Test User"}],
        "foaf:name": [{"type": "String", "data": "Generic"}],
        "veda:storageType": [{"type": "String", "data": "memory_generic"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T18:00:00Z"}]
    }"#;
    
    let _ = provider_generic_memory.put_value(StorageId::Individuals, "generic:test", generic_individual);
    if let StorageResult::Ok(value) = provider_generic_memory.get_value(StorageId::Individuals, "generic:test") {
        println!("     Generic test: Individual ({} bytes)", value.len());
    }

    // === 6. Approach comparison ===
    println!("\n📊 6. Storage creation approach comparison");
    
    println!("   Builder Pattern:");
    println!("     ✅ Readable and flexible API");
    println!("     ✅ Validation at build() stage");
    println!("     ✅ Can create both dynamic and generic types");
    println!("     ❌ More code for simple cases");
    
    println!("   Provider Pattern:");
    println!("     ✅ Concise code for standard cases");
    println!("     ✅ Ready optimal configurations");
    println!("     ❌ Less flexible for customization");
    
    println!("   Config Pattern:");
    println!("     ✅ Excellent for loading from files/ENV");
    println!("     ✅ Unified interface for all types");
    println!("     ❌ Only dynamic dispatch");
    
    println!("   Generic Methods:");
    println!("     ✅ Static dispatch");
    println!("     ✅ Compile-time typing");
    println!("     ❌ Less flexible at runtime");

    // === 7. Usage recommendations ===
    println!("\n💡 7. Pattern selection recommendations");
    
    println!("   Use Builder when:");
    println!("     • Parameter customization is needed");
    println!("     • Complex creation logic");
    println!("     • Code readability is needed");
    
    println!("   Use Provider when:");
    println!("     • Need to quickly create standard storage");
    println!("     • Default parameters are suitable");
    println!("     • Minimal boilerplate code");
    
    println!("   Use Config when:");
    println!("     • Configuration is loaded from external sources");
    println!("     • Storage type is determined at runtime");
    println!("     • Uniform handling of different types is needed");
    
    println!("   Use Generic methods when:");
    println!("     • Static dispatch is preferred");
    println!("     • Storage type is known at compile time");
    println!("     • Access to type-specific methods is needed");

    println!("\n✨ Factory patterns demonstration completed!");
    Ok(())
}

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

Examples found in repository

examples/basic_usage.rs (line 82)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Basic v-storage Usage Example ===\n");

    // Create memory storage using Builder pattern
    let storage = VStorage::builder()
        .memory()
        .build()?;
    let mut storage = VStorage::new(storage);

    println!("✅ Storage created successfully");

    // === Basic data operations ===
    
    // 1. Storing data
    println!("\n📝 Storing data:");
    
    let _ = storage.put_value(StorageId::Individuals, "user:1", r#"{
        "@": "user:1", 
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Ivan Petrov"}],
        "foaf:name": [{"type": "String", "data": "Ivan"}],
        "foaf:familyName": [{"type": "String", "data": "Petrov"}], 
        "foaf:age": [{"type": "Integer", "data": 30}],
        "foaf:mbox": [{"type": "String", "data": "ivan.petrov@example.com"}],
        "veda:created": [{"type": "Datetime", "data": "2024-01-15T10:30:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Tickets, "ticket:123", r#"{
        "@": "ticket:123",
        "rdf:type": [{"type": "Uri", "data": "veda:Ticket"}],
        "rdfs:label": [{"type": "String", "data": "Support Request"}],
        "dcterms:title": [{"type": "String", "data": "Email server issue"}],
        "veda:status": [{"type": "String", "data": "pending"}],
        "veda:priority": [{"type": "String", "data": "medium"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T09:15:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Az, "permission:read", r#"{
        "@": "permission:read",
        "rdf:type": [{"type": "Uri", "data": "veda:Permission"}],
        "rdfs:label": [{"type": "String", "data": "Read Access"}],
        "veda:permissionSubject": [{"type": "Uri", "data": "user:1"}],
        "veda:permissionObject": [{"type": "Uri", "data": "resource:documents"}],
        "veda:canRead": [{"type": "Boolean", "data": true}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T08:00:00Z"}]
    }"#);

    println!("   • Stored user: user:1");
    println!("   • Stored ticket: ticket:123");
    println!("   • Stored permission: permission:read");

    // 2. Reading data
    println!("\n📖 Reading data:");
    
    if let StorageResult::Ok(user_data) = storage.get_value(StorageId::Individuals, "user:1") {
        println!("   • User Individual ({}): Ivan Petrov", user_data.len());
    }
    
    if let StorageResult::Ok(ticket_data) = storage.get_value(StorageId::Tickets, "ticket:123") {
        println!("   • Ticket Individual ({}): Support Request", ticket_data.len());
    }
    
    if let StorageResult::Ok(permission_data) = storage.get_value(StorageId::Az, "permission:read") {
        println!("   • Permission Individual ({}): Read Access", permission_data.len());
    }

    // 3. Working with binary data
    println!("\n🔢 Working with binary data:");
    
    let binary_data = vec![0xFF, 0xFE, 0xFD, 0x00, 0x01, 0x02];
    let _ = storage.put_raw_value(StorageId::Individuals, "binary:data", binary_data.clone());
    
    if let StorageResult::Ok(retrieved_binary) = storage.get_raw_value(StorageId::Individuals, "binary:data") {
        println!("   • Stored {} bytes of binary data", retrieved_binary.len());
        println!("   • Data matches: {}", retrieved_binary == binary_data);
    }

    // 4. Counting records
    println!("\n📊 Statistics:");
    
    if let StorageResult::Ok(individuals_count) = storage.count(StorageId::Individuals) {
        println!("   • Individuals count: {}", individuals_count);
    }
    
    if let StorageResult::Ok(tickets_count) = storage.count(StorageId::Tickets) {
        println!("   • Tickets count: {}", tickets_count);
    }
    
    if let StorageResult::Ok(az_count) = storage.count(StorageId::Az) {
        println!("   • Permissions count: {}", az_count);
    }

    // 5. Removing data
    println!("\n🗑️  Removing data:");
    
    let _ = storage.remove_value(StorageId::Tickets, "ticket:123");
    println!("   • Ticket ticket:123 removed");
    
    // Check that data is actually removed
    match storage.get_value(StorageId::Tickets, "ticket:123") {
        StorageResult::NotFound => println!("   • Confirmed: ticket not found"),
        _ => println!("   • Error: ticket still exists"),
    }

    // 6. Error handling
    println!("\n⚠️  Error handling:");
    
    match storage.get_value(StorageId::Individuals, "nonexistent") {
        StorageResult::NotFound => println!("   • Correctly handled missing key case"),
        StorageResult::Ok(_) => println!("   • Unexpected: found data"),
        StorageResult::Error(e) => println!("   • Error: {}", e),
        _ => println!("   • Other result"),
    }

    // === Backward compatibility demonstration ===
    println!("\n🔄 Backward compatibility:");
    
    #[allow(deprecated)]
    {
        // Using old methods
        let success = storage.put_kv(StorageId::Individuals, "old:key", "old:value");
        println!("   • Old put_kv: {}", if success { "success" } else { "error" });
        
        if let Some(value) = storage.get_v(StorageId::Individuals, "old:key") {
            println!("   • Old get_v: {}", value);
        }
    }

    println!("\n✨ Example completed successfully!");
    Ok(())
}

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

Examples found in repository

examples/basic_usage.rs (lines 28-37)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Basic v-storage Usage Example ===\n");

    // Create memory storage using Builder pattern
    let storage = VStorage::builder()
        .memory()
        .build()?;
    let mut storage = VStorage::new(storage);

    println!("✅ Storage created successfully");

    // === Basic data operations ===
    
    // 1. Storing data
    println!("\n📝 Storing data:");
    
    let _ = storage.put_value(StorageId::Individuals, "user:1", r#"{
        "@": "user:1", 
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Ivan Petrov"}],
        "foaf:name": [{"type": "String", "data": "Ivan"}],
        "foaf:familyName": [{"type": "String", "data": "Petrov"}], 
        "foaf:age": [{"type": "Integer", "data": 30}],
        "foaf:mbox": [{"type": "String", "data": "ivan.petrov@example.com"}],
        "veda:created": [{"type": "Datetime", "data": "2024-01-15T10:30:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Tickets, "ticket:123", r#"{
        "@": "ticket:123",
        "rdf:type": [{"type": "Uri", "data": "veda:Ticket"}],
        "rdfs:label": [{"type": "String", "data": "Support Request"}],
        "dcterms:title": [{"type": "String", "data": "Email server issue"}],
        "veda:status": [{"type": "String", "data": "pending"}],
        "veda:priority": [{"type": "String", "data": "medium"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T09:15:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Az, "permission:read", r#"{
        "@": "permission:read",
        "rdf:type": [{"type": "Uri", "data": "veda:Permission"}],
        "rdfs:label": [{"type": "String", "data": "Read Access"}],
        "veda:permissionSubject": [{"type": "Uri", "data": "user:1"}],
        "veda:permissionObject": [{"type": "Uri", "data": "resource:documents"}],
        "veda:canRead": [{"type": "Boolean", "data": true}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T08:00:00Z"}]
    }"#);

    println!("   • Stored user: user:1");
    println!("   • Stored ticket: ticket:123");
    println!("   • Stored permission: permission:read");

    // 2. Reading data
    println!("\n📖 Reading data:");
    
    if let StorageResult::Ok(user_data) = storage.get_value(StorageId::Individuals, "user:1") {
        println!("   • User Individual ({}): Ivan Petrov", user_data.len());
    }
    
    if let StorageResult::Ok(ticket_data) = storage.get_value(StorageId::Tickets, "ticket:123") {
        println!("   • Ticket Individual ({}): Support Request", ticket_data.len());
    }
    
    if let StorageResult::Ok(permission_data) = storage.get_value(StorageId::Az, "permission:read") {
        println!("   • Permission Individual ({}): Read Access", permission_data.len());
    }

    // 3. Working with binary data
    println!("\n🔢 Working with binary data:");
    
    let binary_data = vec![0xFF, 0xFE, 0xFD, 0x00, 0x01, 0x02];
    let _ = storage.put_raw_value(StorageId::Individuals, "binary:data", binary_data.clone());
    
    if let StorageResult::Ok(retrieved_binary) = storage.get_raw_value(StorageId::Individuals, "binary:data") {
        println!("   • Stored {} bytes of binary data", retrieved_binary.len());
        println!("   • Data matches: {}", retrieved_binary == binary_data);
    }

    // 4. Counting records
    println!("\n📊 Statistics:");
    
    if let StorageResult::Ok(individuals_count) = storage.count(StorageId::Individuals) {
        println!("   • Individuals count: {}", individuals_count);
    }
    
    if let StorageResult::Ok(tickets_count) = storage.count(StorageId::Tickets) {
        println!("   • Tickets count: {}", tickets_count);
    }
    
    if let StorageResult::Ok(az_count) = storage.count(StorageId::Az) {
        println!("   • Permissions count: {}", az_count);
    }

    // 5. Removing data
    println!("\n🗑️  Removing data:");
    
    let _ = storage.remove_value(StorageId::Tickets, "ticket:123");
    println!("   • Ticket ticket:123 removed");
    
    // Check that data is actually removed
    match storage.get_value(StorageId::Tickets, "ticket:123") {
        StorageResult::NotFound => println!("   • Confirmed: ticket not found"),
        _ => println!("   • Error: ticket still exists"),
    }

    // 6. Error handling
    println!("\n⚠️  Error handling:");
    
    match storage.get_value(StorageId::Individuals, "nonexistent") {
        StorageResult::NotFound => println!("   • Correctly handled missing key case"),
        StorageResult::Ok(_) => println!("   • Unexpected: found data"),
        StorageResult::Error(e) => println!("   • Error: {}", e),
        _ => println!("   • Other result"),
    }

    // === Backward compatibility demonstration ===
    println!("\n🔄 Backward compatibility:");
    
    #[allow(deprecated)]
    {
        // Using old methods
        let success = storage.put_kv(StorageId::Individuals, "old:key", "old:value");
        println!("   • Old put_kv: {}", if success { "success" } else { "error" });
        
        if let Some(value) = storage.get_v(StorageId::Individuals, "old:key") {
            println!("   • Old get_v: {}", value);
        }
    }

    println!("\n✨ Example completed successfully!");
    Ok(())
}

examples/storage_types.rs (line 24)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== v-storage Storage Types Comparison ===\n");

    // === 1. Dynamic storage (VStorage) ===
    println!("🎭 1. Dynamic storage (VStorage)");
    println!("   • Uses trait objects (Box<dyn Storage>)");
    println!("   • Runtime flexibility, but has vtable lookup overhead");
    
    let storage_box = VStorage::builder().memory().build()?;
    let mut dynamic_storage = VStorage::new(storage_box);
    
    // Demonstrate operations
    let _ = dynamic_storage.put_value(StorageId::Individuals, "dynamic:key", "dynamic:value");
    
    if let StorageResult::Ok(value) = dynamic_storage.get_value(StorageId::Individuals, "dynamic:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", dynamic_storage.is_empty());

    // === 2. Generic storage (VStorageGeneric) ===
    println!("\n🔧 2. Generic storage (VStorageGeneric)");
    println!("   • Compile-time typing");
    println!("   • No vtable overhead, but less flexible");
    
    let mut generic_storage = VMemoryStorage::new(memory_storage::MemoryStorage::new());
    
    let _ = generic_storage.put_value(StorageId::Individuals, "generic:key", "generic:value");
    
    if let StorageResult::Ok(value) = generic_storage.get_value(StorageId::Individuals, "generic:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", generic_storage.is_empty());
    
    // Can extract inner storage
    if let Some(inner_storage) = generic_storage.storage() {
        println!("   • Access to inner storage: available");
    }

    // === 3. Enum storage (VStorageEnum) ===
    println!("\n⚡ 3. Enum storage (VStorageEnum)");
    println!("   • Static dispatch through enum");
    println!("   • Static dispatch");
    
    let mut enum_storage = VStorageEnum::memory();
    
    let _ = enum_storage.put_value(StorageId::Individuals, "enum:key", "enum:value");
    
    if let StorageResult::Ok(value) = enum_storage.get_value(StorageId::Individuals, "enum:key") {
        println!("   • Stored and read: {}", value);
    }
    
    println!("   • Storage is empty: {}", enum_storage.is_empty());

    // === 4. API consistency ===
    println!("\n🔄 4. API consistency between types");
    println!("   • All types have the same Storage interface");
    
    let test_data = vec![
        ("test1", "value1"),
        ("test2", "value2"),
        ("test3", "value3"),
    ];

    // Store data in all storage types
    for (key, value) in &test_data {
        let _ = dynamic_storage.put_value(StorageId::Tickets, key, value);
        let _ = generic_storage.put_value(StorageId::Tickets, key, value);
        let _ = enum_storage.put_value(StorageId::Tickets, key, value);
    }

    // Check that all return the same results
    println!("   • Consistency check:");
    for (key, expected_value) in &test_data {
        let dynamic_result = dynamic_storage.get_value(StorageId::Tickets, key);
        let generic_result = generic_storage.get_value(StorageId::Tickets, key);
        let enum_result = enum_storage.get_value(StorageId::Tickets, key);

        match (dynamic_result, generic_result, enum_result) {
            (StorageResult::Ok(v1), StorageResult::Ok(v2), StorageResult::Ok(v3)) => {
                let consistent = v1 == *expected_value && v2 == *expected_value && v3 == *expected_value;
                println!("     {} -> {}", key, if consistent { "✅ consistent" } else { "❌ inconsistent" });
            }
            _ => println!("     {} -> ❌ read error", key),
        }
    }

    // === 5. Different constructor demonstrations ===
    println!("\n🏗️  5. Different ways to create storages");
    
    // VStorageEnum - direct creation
    let _enum_direct = VStorageEnum::memory();
    println!("   • VStorageEnum::memory() - direct creation");
    
    // VStorageGeneric - through constructor
    let _generic_direct = VMemoryStorage::new(memory_storage::MemoryStorage::new());
    println!("   • VMemoryStorage::new() - through constructor");
    
    // VStorage - through builder
    let _dynamic_builder = VStorage::builder().memory().build()?;
    println!("   • VStorage::builder() - through builder pattern");

    // === 6. Features of each type ===
    println!("\n📋 6. Usage characteristics");
    
    println!("   VStorage (Dynamic):");
    println!("     ✅ Maximum flexibility");
    println!("     ✅ Can change storage type at runtime");
    println!("     ❌ Vtable lookup overhead");
    println!("     ❌ No access to inner type");
    
    println!("   VStorageGeneric<T> (Generic):");
    println!("     ✅ Compile-time optimization");
    println!("     ✅ Access to inner storage");
    println!("     ✅ Type safety");
    println!("     ❌ Less flexible at runtime");
    
    println!("   VStorageEnum (Enum):");
    println!("     ✅ Static dispatch");
    println!("     ✅ No heap allocation for storage");
    println!("     ❌ Fixed set of types");

    // === 7. Usage recommendations ===
    println!("\n💡 7. Storage type selection recommendations");
    
    println!("   Use VStorage when:");
    println!("     • Maximum flexibility is needed");
    println!("     • Storage type is determined at runtime");
    println!("     • Flexibility is more important than dispatch overhead");
    
    println!("   Use VStorageGeneric when:");
    println!("     • Access to inner storage is needed");
    println!("     • Type safety is important");
    println!("     • Storage type is known at compile time");
    
    println!("   Use VStorageEnum when:");
    println!("     • Static dispatch is preferred");
    println!("     • Doing many operations (batch processing)");
    println!("     • Fixed set of types is suitable");

    println!("\n✨ Demonstration completed!");
    Ok(())
}

examples/individual_operations.rs (line 52)

fn main() {
    println!("=== Демонстрация работы с Individual в v-storage ===\n");

    // Создаем хранилище в памяти
    let mut storage = VStorage::new(Box::new(MemoryStorage::new()));
    
    // Создаем Individual
    let mut individual = Individual::default();
    
    println!("1. Загрузка несуществующего Individual:");
    match storage.get_individual("test:nonexistent", &mut individual) {
        StorageResult::Ok(_) => {
            println!("   ✓ Individual найден!");
            println!("   • ID: {}", individual.get_id());
        },
        StorageResult::UnprocessableEntity => {
            println!("   ✗ Individual найден, но не может быть обработан");
            println!("   • Возможно, данные повреждены или имеют неверный формат");
        },
        StorageResult::NotFound => {
            println!("   ✗ Individual не найден");
            println!("   • Ключ 'test:nonexistent' не существует в хранилище");
        },
        StorageResult::NotReady => {
            println!("   ✗ Хранилище не готово");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка: {}", msg);
        }
    }
    
    println!("\n2. Сохранение Individual данных:");
    
    // Сохраняем корректные данные Individual
    let individual_data = r#"{"@":"individual","@id":"test:person","rdfs:label":[{"data":"Тестовый пользователь","lang":"ru","type":"_string"}]}"#;
    
    match storage.put_value(StorageId::Individuals, "test:person", individual_data) {
        StorageResult::Ok(_) => {
            println!("   ✓ Individual успешно сохранен");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка при сохранении: {}", msg);
        },
        _ => {
            println!("   ✗ Неожиданная ошибка при сохранении");
        }
    }
    
    println!("\n3. Загрузка существующего Individual:");
    match storage.get_individual("test:person", &mut individual) {
        StorageResult::Ok(_) => {
            println!("   ✓ Individual успешно загружен!");
            println!("   • ID: {}", individual.get_id());
            println!("   • Сырые данные: {} байт", individual.get_raw_len());
        },
        StorageResult::UnprocessableEntity => {
            println!("   ✗ Individual найден, но не может быть обработан");
            println!("   • Проверьте формат данных");
        },
        StorageResult::NotFound => {
            println!("   ✗ Individual не найден");
        },
        StorageResult::NotReady => {
            println!("   ✗ Хранилище не готово");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка: {}", msg);
        }
    }
    
    println!("\n4. Тестирование с невалидными данными:");
    
    // Сохраняем невалидные данные
    let invalid_data = "это не JSON и не Individual";
    match storage.put_value(StorageId::Individuals, "test:invalid", invalid_data) {
        StorageResult::Ok(_) => {
            println!("   ✓ Невалидные данные сохранены (для тестирования)");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка при сохранении: {}", msg);
        },
        _ => {
            println!("   ✗ Неожиданная ошибка при сохранении");
        }
    }
    
    // Пытаемся загрузить невалидные данные
    match storage.get_individual("test:invalid", &mut individual) {
        StorageResult::Ok(_) => {
            println!("   ✓ Данные загружены (неожиданно)");
        },
        StorageResult::UnprocessableEntity => {
            println!("   ✓ Корректно обработаны невалидные данные");
            println!("   • Система правильно определила, что данные не являются Individual");
        },
        StorageResult::NotFound => {
            println!("   ✗ Данные не найдены (неожиданно)");
        },
        StorageResult::NotReady => {
            println!("   ✗ Хранилище не готово");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка: {}", msg);
        }
    }
    
    println!("\n5. Работа с различными типами хранилищ:");
    
    // Демонстрация работы с разными типами хранилищ
    let mut memory_storage = VStorageEnum::memory();
    
    println!("   • Память: сохранение данных...");
    match memory_storage.put_value(StorageId::Individuals, "test:memory", individual_data) {
        StorageResult::Ok(_) => {
            println!("     ✓ Данные сохранены в памяти");
            
            // Проверяем загрузку
                         match memory_storage.get_individual(StorageId::Individuals, "test:memory", &mut individual) {
                StorageResult::Ok(_) => {
                    println!("     ✓ Данные успешно загружены из памяти");
                    println!("     • ID: {}", individual.get_id());
                },
                result => {
                    println!("     ✗ Не удалось загрузить данные: {:?}", result);
                }
            }
        },
        StorageResult::Error(msg) => {
            println!("     ✗ Ошибка при сохранении: {}", msg);
        },
        _ => {
            println!("     ✗ Неожиданная ошибка при сохранении");
        }
    }
    
    println!("\n6. Подсчет количества Individual:");
    match storage.count(StorageId::Individuals) {
        StorageResult::Ok(count) => {
            println!("   ✓ В хранилище {} Individual(s)", count);
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка при подсчете: {}", msg);
        },
        _ => {
            println!("   ✗ Подсчет недоступен");
        }
    }
    
    println!("\n7. Лучшие практики:");
    println!("   • Всегда проверяйте StorageResult при загрузке Individual");
    println!("   • StorageResult::UnprocessableEntity означает, что данные есть, но не валидны");
    println!("   • StorageResult::NotFound означает, что данных нет");
    println!("   • StorageResult::NotReady означает, что хранилище не готово к работе");
    println!("   • Используйте соответствующие методы для разных типов данных");
    
    println!("\n=== Демонстрация завершена ===");
}

examples/factory_patterns.rs (line 73)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== v-storage Factory Patterns Demonstration ===\n");

    // === 1. Builder Pattern ===
    println!("🏗️  1. Builder Pattern - step-by-step creation");
    println!("   • Flexible and readable way to configure storage");
    
    // Create memory storage through builder
    let memory_storage = StorageBuilder::new()
        .memory()
        .build()?;
    println!("   • Created memory storage through builder");
    
    // Create LMDB storage through builder
    let lmdb_storage = StorageBuilder::new()
        .lmdb("/tmp/example_lmdb", StorageMode::ReadWrite, Some(1000))
        .build();
    
    match lmdb_storage {
        Ok(_) => println!("   • Created LMDB storage through builder"),
        Err(e) => println!("   • LMDB unavailable: {}", e),
    }
    
    // Create remote storage through builder
    let remote_storage = StorageBuilder::new()
        .remote("127.0.0.1:8080")
        .build();
    
    match remote_storage {
        Ok(_) => println!("   • Created remote storage through builder"),
        Err(e) => println!("   • Remote unavailable: {}", e),
    }

    // === 2. Provider Pattern ===
    println!("\n🏭 2. Provider Pattern - ready factory methods");
    println!("   • Quick creation of standard configurations");
    
    // Direct creation of storages through Provider
    let _provider_memory = StorageProvider::memory();
    println!("   • StorageProvider::memory() - created");
    
    let _provider_lmdb = StorageProvider::lmdb("/tmp/provider_lmdb", StorageMode::ReadOnly, None);
    println!("   • StorageProvider::lmdb() - created");
    
    let _provider_remote = StorageProvider::remote("127.0.0.1:8080");
    println!("   • StorageProvider::remote() - created");
    
    // Create VStorage through Provider
    let mut vstorage_memory = StorageProvider::vstorage_memory();
    println!("   • StorageProvider::vstorage_memory() - created VStorage");
    
    // Demonstrate functionality with semantic Individual
    let provider_individual = r#"{
        "@": "provider:test",
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Provider Test User"}],
        "foaf:name": [{"type": "String", "data": "Test"}],
        "veda:createdBy": [{"type": "Uri", "data": "provider:factory"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T17:00:00Z"}]
    }"#;
    
    let _ = vstorage_memory.put_value(StorageId::Individuals, "provider:test", provider_individual);
    if let StorageResult::Ok(value) = vstorage_memory.get_value(StorageId::Individuals, "provider:test") {
        println!("     Test: stored Individual ({} bytes) through Provider", value.len());
    }

    // === 3. Config Pattern ===
    println!("\n⚙️  3. Config Pattern - creation from configuration");
    println!("   • Creating storages from configuration structures");
    
    // Create from different configurations
    let configs = vec![
        ("Memory", StorageConfig::Memory),
        ("LMDB", StorageConfig::Lmdb { 
            path: "/tmp/config_lmdb".to_string(), 
            mode: StorageMode::ReadWrite, 
            max_read_counter_reopen: Some(500) 
        }),
        ("Remote", StorageConfig::Remote { 
            address: "127.0.0.1:8080".to_string() 
        }),
    ];
    
    for (name, config) in configs {
        match VStorage::from_config(config) {
            Ok(mut storage) => {
                println!("   • {} configuration: created successfully", name);
                
                // Test the created storage with semantic Individual
                let test_key = format!("config:{}:key", name.to_lowercase());
                let test_value = format!(r#"{{
                    "@": "{}",
                    "rdf:type": [{{"type": "Uri", "data": "veda:ConfigTest"}}],
                    "rdfs:label": [{{"type": "String", "data": "Config Test for {}"}}],
                    "veda:configType": [{{"type": "String", "data": "{}"}}],
                    "dcterms:created": [{{"type": "Datetime", "data": "2024-01-15T17:30:00Z"}}]
                }}"#, test_key, name, name);
                
                let _ = storage.put_value(StorageId::Individuals, &test_key, &test_value);
                if let StorageResult::Ok(retrieved) = storage.get_value(StorageId::Individuals, &test_key) {
                    println!("     Test: {} Individual ({} bytes)", name, retrieved.len());
                }
            },
            Err(e) => println!("   • {} configuration: error - {}", name, e),
        }
    }

    // === 4. Generic Builders ===
    println!("\n🔧 4. Generic Builders - compile-time optimization");
    println!("   • Typed builders without runtime overhead");
    
    // Generic memory builder
    let generic_memory = StorageBuilder::new()
        .memory()
        .build_memory_generic()?;
    println!("   • build_memory_generic() - created VMemoryStorage");
    
    // Generic LMDB builder
    let generic_lmdb = StorageBuilder::new()
        .lmdb("/tmp/generic_lmdb", StorageMode::ReadWrite, None)
        .build_lmdb_generic();
    
    match generic_lmdb {
        Ok(_storage) => println!("   • build_lmdb_generic() - created VLMDBStorage"),
        Err(e) => println!("   • build_lmdb_generic() - error: {}", e),
    }
    
    // Generic remote builder
    let generic_remote = StorageBuilder::new()
        .remote("127.0.0.1:8080")
        .build_remote_generic();
    
    match generic_remote {
        Ok(_storage) => println!("   • build_remote_generic() - created VRemoteStorage"),
        Err(e) => println!("   • build_remote_generic() - error: {}", e),
    }

    // === 5. Provider Generic Methods ===
    println!("\n🎯 5. Provider Generic Methods - static types");
    println!("   • Direct creation of typed storages");
    
    let mut provider_generic_memory = StorageProvider::memory_generic();
    println!("   • StorageProvider::memory_generic() - VMemoryStorage");
    
    let provider_generic_lmdb = StorageProvider::lmdb_generic("/tmp/generic_provider", StorageMode::ReadOnly, None);
    println!("   • StorageProvider::lmdb_generic() - VLMDBStorage");
    
    let provider_generic_remote = StorageProvider::remote_generic("127.0.0.1:8080");
    println!("   • StorageProvider::remote_generic() - VRemoteStorage");
    
    // Demonstrate work with typed storage using semantic Individual
    let generic_individual = r#"{
        "@": "generic:test",
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Generic Test User"}],
        "foaf:name": [{"type": "String", "data": "Generic"}],
        "veda:storageType": [{"type": "String", "data": "memory_generic"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T18:00:00Z"}]
    }"#;
    
    let _ = provider_generic_memory.put_value(StorageId::Individuals, "generic:test", generic_individual);
    if let StorageResult::Ok(value) = provider_generic_memory.get_value(StorageId::Individuals, "generic:test") {
        println!("     Generic test: Individual ({} bytes)", value.len());
    }

    // === 6. Approach comparison ===
    println!("\n📊 6. Storage creation approach comparison");
    
    println!("   Builder Pattern:");
    println!("     ✅ Readable and flexible API");
    println!("     ✅ Validation at build() stage");
    println!("     ✅ Can create both dynamic and generic types");
    println!("     ❌ More code for simple cases");
    
    println!("   Provider Pattern:");
    println!("     ✅ Concise code for standard cases");
    println!("     ✅ Ready optimal configurations");
    println!("     ❌ Less flexible for customization");
    
    println!("   Config Pattern:");
    println!("     ✅ Excellent for loading from files/ENV");
    println!("     ✅ Unified interface for all types");
    println!("     ❌ Only dynamic dispatch");
    
    println!("   Generic Methods:");
    println!("     ✅ Static dispatch");
    println!("     ✅ Compile-time typing");
    println!("     ❌ Less flexible at runtime");

    // === 7. Usage recommendations ===
    println!("\n💡 7. Pattern selection recommendations");
    
    println!("   Use Builder when:");
    println!("     • Parameter customization is needed");
    println!("     • Complex creation logic");
    println!("     • Code readability is needed");
    
    println!("   Use Provider when:");
    println!("     • Need to quickly create standard storage");
    println!("     • Default parameters are suitable");
    println!("     • Minimal boilerplate code");
    
    println!("   Use Config when:");
    println!("     • Configuration is loaded from external sources");
    println!("     • Storage type is determined at runtime");
    println!("     • Uniform handling of different types is needed");
    
    println!("   Use Generic methods when:");
    println!("     • Static dispatch is preferred");
    println!("     • Storage type is known at compile time");
    println!("     • Access to type-specific methods is needed");

    println!("\n✨ Factory patterns demonstration completed!");
    Ok(())
}

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

Examples found in repository

examples/basic_usage.rs (line 80)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Basic v-storage Usage Example ===\n");

    // Create memory storage using Builder pattern
    let storage = VStorage::builder()
        .memory()
        .build()?;
    let mut storage = VStorage::new(storage);

    println!("✅ Storage created successfully");

    // === Basic data operations ===
    
    // 1. Storing data
    println!("\n📝 Storing data:");
    
    let _ = storage.put_value(StorageId::Individuals, "user:1", r#"{
        "@": "user:1", 
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Ivan Petrov"}],
        "foaf:name": [{"type": "String", "data": "Ivan"}],
        "foaf:familyName": [{"type": "String", "data": "Petrov"}], 
        "foaf:age": [{"type": "Integer", "data": 30}],
        "foaf:mbox": [{"type": "String", "data": "ivan.petrov@example.com"}],
        "veda:created": [{"type": "Datetime", "data": "2024-01-15T10:30:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Tickets, "ticket:123", r#"{
        "@": "ticket:123",
        "rdf:type": [{"type": "Uri", "data": "veda:Ticket"}],
        "rdfs:label": [{"type": "String", "data": "Support Request"}],
        "dcterms:title": [{"type": "String", "data": "Email server issue"}],
        "veda:status": [{"type": "String", "data": "pending"}],
        "veda:priority": [{"type": "String", "data": "medium"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T09:15:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Az, "permission:read", r#"{
        "@": "permission:read",
        "rdf:type": [{"type": "Uri", "data": "veda:Permission"}],
        "rdfs:label": [{"type": "String", "data": "Read Access"}],
        "veda:permissionSubject": [{"type": "Uri", "data": "user:1"}],
        "veda:permissionObject": [{"type": "Uri", "data": "resource:documents"}],
        "veda:canRead": [{"type": "Boolean", "data": true}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T08:00:00Z"}]
    }"#);

    println!("   • Stored user: user:1");
    println!("   • Stored ticket: ticket:123");
    println!("   • Stored permission: permission:read");

    // 2. Reading data
    println!("\n📖 Reading data:");
    
    if let StorageResult::Ok(user_data) = storage.get_value(StorageId::Individuals, "user:1") {
        println!("   • User Individual ({}): Ivan Petrov", user_data.len());
    }
    
    if let StorageResult::Ok(ticket_data) = storage.get_value(StorageId::Tickets, "ticket:123") {
        println!("   • Ticket Individual ({}): Support Request", ticket_data.len());
    }
    
    if let StorageResult::Ok(permission_data) = storage.get_value(StorageId::Az, "permission:read") {
        println!("   • Permission Individual ({}): Read Access", permission_data.len());
    }

    // 3. Working with binary data
    println!("\n🔢 Working with binary data:");
    
    let binary_data = vec![0xFF, 0xFE, 0xFD, 0x00, 0x01, 0x02];
    let _ = storage.put_raw_value(StorageId::Individuals, "binary:data", binary_data.clone());
    
    if let StorageResult::Ok(retrieved_binary) = storage.get_raw_value(StorageId::Individuals, "binary:data") {
        println!("   • Stored {} bytes of binary data", retrieved_binary.len());
        println!("   • Data matches: {}", retrieved_binary == binary_data);
    }

    // 4. Counting records
    println!("\n📊 Statistics:");
    
    if let StorageResult::Ok(individuals_count) = storage.count(StorageId::Individuals) {
        println!("   • Individuals count: {}", individuals_count);
    }
    
    if let StorageResult::Ok(tickets_count) = storage.count(StorageId::Tickets) {
        println!("   • Tickets count: {}", tickets_count);
    }
    
    if let StorageResult::Ok(az_count) = storage.count(StorageId::Az) {
        println!("   • Permissions count: {}", az_count);
    }

    // 5. Removing data
    println!("\n🗑️  Removing data:");
    
    let _ = storage.remove_value(StorageId::Tickets, "ticket:123");
    println!("   • Ticket ticket:123 removed");
    
    // Check that data is actually removed
    match storage.get_value(StorageId::Tickets, "ticket:123") {
        StorageResult::NotFound => println!("   • Confirmed: ticket not found"),
        _ => println!("   • Error: ticket still exists"),
    }

    // 6. Error handling
    println!("\n⚠️  Error handling:");
    
    match storage.get_value(StorageId::Individuals, "nonexistent") {
        StorageResult::NotFound => println!("   • Correctly handled missing key case"),
        StorageResult::Ok(_) => println!("   • Unexpected: found data"),
        StorageResult::Error(e) => println!("   • Error: {}", e),
        _ => println!("   • Other result"),
    }

    // === Backward compatibility demonstration ===
    println!("\n🔄 Backward compatibility:");
    
    #[allow(deprecated)]
    {
        // Using old methods
        let success = storage.put_kv(StorageId::Individuals, "old:key", "old:value");
        println!("   • Old put_kv: {}", if success { "success" } else { "error" });
        
        if let Some(value) = storage.get_v(StorageId::Individuals, "old:key") {
            println!("   • Old get_v: {}", value);
        }
    }

    println!("\n✨ Example completed successfully!");
    Ok(())
}

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

Examples found in repository

examples/basic_usage.rs (line 105)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Basic v-storage Usage Example ===\n");

    // Create memory storage using Builder pattern
    let storage = VStorage::builder()
        .memory()
        .build()?;
    let mut storage = VStorage::new(storage);

    println!("✅ Storage created successfully");

    // === Basic data operations ===
    
    // 1. Storing data
    println!("\n📝 Storing data:");
    
    let _ = storage.put_value(StorageId::Individuals, "user:1", r#"{
        "@": "user:1", 
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Ivan Petrov"}],
        "foaf:name": [{"type": "String", "data": "Ivan"}],
        "foaf:familyName": [{"type": "String", "data": "Petrov"}], 
        "foaf:age": [{"type": "Integer", "data": 30}],
        "foaf:mbox": [{"type": "String", "data": "ivan.petrov@example.com"}],
        "veda:created": [{"type": "Datetime", "data": "2024-01-15T10:30:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Tickets, "ticket:123", r#"{
        "@": "ticket:123",
        "rdf:type": [{"type": "Uri", "data": "veda:Ticket"}],
        "rdfs:label": [{"type": "String", "data": "Support Request"}],
        "dcterms:title": [{"type": "String", "data": "Email server issue"}],
        "veda:status": [{"type": "String", "data": "pending"}],
        "veda:priority": [{"type": "String", "data": "medium"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T09:15:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Az, "permission:read", r#"{
        "@": "permission:read",
        "rdf:type": [{"type": "Uri", "data": "veda:Permission"}],
        "rdfs:label": [{"type": "String", "data": "Read Access"}],
        "veda:permissionSubject": [{"type": "Uri", "data": "user:1"}],
        "veda:permissionObject": [{"type": "Uri", "data": "resource:documents"}],
        "veda:canRead": [{"type": "Boolean", "data": true}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T08:00:00Z"}]
    }"#);

    println!("   • Stored user: user:1");
    println!("   • Stored ticket: ticket:123");
    println!("   • Stored permission: permission:read");

    // 2. Reading data
    println!("\n📖 Reading data:");
    
    if let StorageResult::Ok(user_data) = storage.get_value(StorageId::Individuals, "user:1") {
        println!("   • User Individual ({}): Ivan Petrov", user_data.len());
    }
    
    if let StorageResult::Ok(ticket_data) = storage.get_value(StorageId::Tickets, "ticket:123") {
        println!("   • Ticket Individual ({}): Support Request", ticket_data.len());
    }
    
    if let StorageResult::Ok(permission_data) = storage.get_value(StorageId::Az, "permission:read") {
        println!("   • Permission Individual ({}): Read Access", permission_data.len());
    }

    // 3. Working with binary data
    println!("\n🔢 Working with binary data:");
    
    let binary_data = vec![0xFF, 0xFE, 0xFD, 0x00, 0x01, 0x02];
    let _ = storage.put_raw_value(StorageId::Individuals, "binary:data", binary_data.clone());
    
    if let StorageResult::Ok(retrieved_binary) = storage.get_raw_value(StorageId::Individuals, "binary:data") {
        println!("   • Stored {} bytes of binary data", retrieved_binary.len());
        println!("   • Data matches: {}", retrieved_binary == binary_data);
    }

    // 4. Counting records
    println!("\n📊 Statistics:");
    
    if let StorageResult::Ok(individuals_count) = storage.count(StorageId::Individuals) {
        println!("   • Individuals count: {}", individuals_count);
    }
    
    if let StorageResult::Ok(tickets_count) = storage.count(StorageId::Tickets) {
        println!("   • Tickets count: {}", tickets_count);
    }
    
    if let StorageResult::Ok(az_count) = storage.count(StorageId::Az) {
        println!("   • Permissions count: {}", az_count);
    }

    // 5. Removing data
    println!("\n🗑️  Removing data:");
    
    let _ = storage.remove_value(StorageId::Tickets, "ticket:123");
    println!("   • Ticket ticket:123 removed");
    
    // Check that data is actually removed
    match storage.get_value(StorageId::Tickets, "ticket:123") {
        StorageResult::NotFound => println!("   • Confirmed: ticket not found"),
        _ => println!("   • Error: ticket still exists"),
    }

    // 6. Error handling
    println!("\n⚠️  Error handling:");
    
    match storage.get_value(StorageId::Individuals, "nonexistent") {
        StorageResult::NotFound => println!("   • Correctly handled missing key case"),
        StorageResult::Ok(_) => println!("   • Unexpected: found data"),
        StorageResult::Error(e) => println!("   • Error: {}", e),
        _ => println!("   • Other result"),
    }

    // === Backward compatibility demonstration ===
    println!("\n🔄 Backward compatibility:");
    
    #[allow(deprecated)]
    {
        // Using old methods
        let success = storage.put_kv(StorageId::Individuals, "old:key", "old:value");
        println!("   • Old put_kv: {}", if success { "success" } else { "error" });
        
        if let Some(value) = storage.get_v(StorageId::Individuals, "old:key") {
            println!("   • Old get_v: {}", value);
        }
    }

    println!("\n✨ Example completed successfully!");
    Ok(())
}

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

Examples found in repository

examples/basic_usage.rs (line 90)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Basic v-storage Usage Example ===\n");

    // Create memory storage using Builder pattern
    let storage = VStorage::builder()
        .memory()
        .build()?;
    let mut storage = VStorage::new(storage);

    println!("✅ Storage created successfully");

    // === Basic data operations ===
    
    // 1. Storing data
    println!("\n📝 Storing data:");
    
    let _ = storage.put_value(StorageId::Individuals, "user:1", r#"{
        "@": "user:1", 
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Ivan Petrov"}],
        "foaf:name": [{"type": "String", "data": "Ivan"}],
        "foaf:familyName": [{"type": "String", "data": "Petrov"}], 
        "foaf:age": [{"type": "Integer", "data": 30}],
        "foaf:mbox": [{"type": "String", "data": "ivan.petrov@example.com"}],
        "veda:created": [{"type": "Datetime", "data": "2024-01-15T10:30:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Tickets, "ticket:123", r#"{
        "@": "ticket:123",
        "rdf:type": [{"type": "Uri", "data": "veda:Ticket"}],
        "rdfs:label": [{"type": "String", "data": "Support Request"}],
        "dcterms:title": [{"type": "String", "data": "Email server issue"}],
        "veda:status": [{"type": "String", "data": "pending"}],
        "veda:priority": [{"type": "String", "data": "medium"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T09:15:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Az, "permission:read", r#"{
        "@": "permission:read",
        "rdf:type": [{"type": "Uri", "data": "veda:Permission"}],
        "rdfs:label": [{"type": "String", "data": "Read Access"}],
        "veda:permissionSubject": [{"type": "Uri", "data": "user:1"}],
        "veda:permissionObject": [{"type": "Uri", "data": "resource:documents"}],
        "veda:canRead": [{"type": "Boolean", "data": true}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T08:00:00Z"}]
    }"#);

    println!("   • Stored user: user:1");
    println!("   • Stored ticket: ticket:123");
    println!("   • Stored permission: permission:read");

    // 2. Reading data
    println!("\n📖 Reading data:");
    
    if let StorageResult::Ok(user_data) = storage.get_value(StorageId::Individuals, "user:1") {
        println!("   • User Individual ({}): Ivan Petrov", user_data.len());
    }
    
    if let StorageResult::Ok(ticket_data) = storage.get_value(StorageId::Tickets, "ticket:123") {
        println!("   • Ticket Individual ({}): Support Request", ticket_data.len());
    }
    
    if let StorageResult::Ok(permission_data) = storage.get_value(StorageId::Az, "permission:read") {
        println!("   • Permission Individual ({}): Read Access", permission_data.len());
    }

    // 3. Working with binary data
    println!("\n🔢 Working with binary data:");
    
    let binary_data = vec![0xFF, 0xFE, 0xFD, 0x00, 0x01, 0x02];
    let _ = storage.put_raw_value(StorageId::Individuals, "binary:data", binary_data.clone());
    
    if let StorageResult::Ok(retrieved_binary) = storage.get_raw_value(StorageId::Individuals, "binary:data") {
        println!("   • Stored {} bytes of binary data", retrieved_binary.len());
        println!("   • Data matches: {}", retrieved_binary == binary_data);
    }

    // 4. Counting records
    println!("\n📊 Statistics:");
    
    if let StorageResult::Ok(individuals_count) = storage.count(StorageId::Individuals) {
        println!("   • Individuals count: {}", individuals_count);
    }
    
    if let StorageResult::Ok(tickets_count) = storage.count(StorageId::Tickets) {
        println!("   • Tickets count: {}", tickets_count);
    }
    
    if let StorageResult::Ok(az_count) = storage.count(StorageId::Az) {
        println!("   • Permissions count: {}", az_count);
    }

    // 5. Removing data
    println!("\n🗑️  Removing data:");
    
    let _ = storage.remove_value(StorageId::Tickets, "ticket:123");
    println!("   • Ticket ticket:123 removed");
    
    // Check that data is actually removed
    match storage.get_value(StorageId::Tickets, "ticket:123") {
        StorageResult::NotFound => println!("   • Confirmed: ticket not found"),
        _ => println!("   • Error: ticket still exists"),
    }

    // 6. Error handling
    println!("\n⚠️  Error handling:");
    
    match storage.get_value(StorageId::Individuals, "nonexistent") {
        StorageResult::NotFound => println!("   • Correctly handled missing key case"),
        StorageResult::Ok(_) => println!("   • Unexpected: found data"),
        StorageResult::Error(e) => println!("   • Error: {}", e),
        _ => println!("   • Other result"),
    }

    // === Backward compatibility demonstration ===
    println!("\n🔄 Backward compatibility:");
    
    #[allow(deprecated)]
    {
        // Using old methods
        let success = storage.put_kv(StorageId::Individuals, "old:key", "old:value");
        println!("   • Old put_kv: {}", if success { "success" } else { "error" });
        
        if let Some(value) = storage.get_v(StorageId::Individuals, "old:key") {
            println!("   • Old get_v: {}", value);
        }
    }

    println!("\n✨ Example completed successfully!");
    Ok(())
}

examples/individual_operations.rs (line 152)

fn main() {
    println!("=== Демонстрация работы с Individual в v-storage ===\n");

    // Создаем хранилище в памяти
    let mut storage = VStorage::new(Box::new(MemoryStorage::new()));
    
    // Создаем Individual
    let mut individual = Individual::default();
    
    println!("1. Загрузка несуществующего Individual:");
    match storage.get_individual("test:nonexistent", &mut individual) {
        StorageResult::Ok(_) => {
            println!("   ✓ Individual найден!");
            println!("   • ID: {}", individual.get_id());
        },
        StorageResult::UnprocessableEntity => {
            println!("   ✗ Individual найден, но не может быть обработан");
            println!("   • Возможно, данные повреждены или имеют неверный формат");
        },
        StorageResult::NotFound => {
            println!("   ✗ Individual не найден");
            println!("   • Ключ 'test:nonexistent' не существует в хранилище");
        },
        StorageResult::NotReady => {
            println!("   ✗ Хранилище не готово");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка: {}", msg);
        }
    }
    
    println!("\n2. Сохранение Individual данных:");
    
    // Сохраняем корректные данные Individual
    let individual_data = r#"{"@":"individual","@id":"test:person","rdfs:label":[{"data":"Тестовый пользователь","lang":"ru","type":"_string"}]}"#;
    
    match storage.put_value(StorageId::Individuals, "test:person", individual_data) {
        StorageResult::Ok(_) => {
            println!("   ✓ Individual успешно сохранен");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка при сохранении: {}", msg);
        },
        _ => {
            println!("   ✗ Неожиданная ошибка при сохранении");
        }
    }
    
    println!("\n3. Загрузка существующего Individual:");
    match storage.get_individual("test:person", &mut individual) {
        StorageResult::Ok(_) => {
            println!("   ✓ Individual успешно загружен!");
            println!("   • ID: {}", individual.get_id());
            println!("   • Сырые данные: {} байт", individual.get_raw_len());
        },
        StorageResult::UnprocessableEntity => {
            println!("   ✗ Individual найден, но не может быть обработан");
            println!("   • Проверьте формат данных");
        },
        StorageResult::NotFound => {
            println!("   ✗ Individual не найден");
        },
        StorageResult::NotReady => {
            println!("   ✗ Хранилище не готово");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка: {}", msg);
        }
    }
    
    println!("\n4. Тестирование с невалидными данными:");
    
    // Сохраняем невалидные данные
    let invalid_data = "это не JSON и не Individual";
    match storage.put_value(StorageId::Individuals, "test:invalid", invalid_data) {
        StorageResult::Ok(_) => {
            println!("   ✓ Невалидные данные сохранены (для тестирования)");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка при сохранении: {}", msg);
        },
        _ => {
            println!("   ✗ Неожиданная ошибка при сохранении");
        }
    }
    
    // Пытаемся загрузить невалидные данные
    match storage.get_individual("test:invalid", &mut individual) {
        StorageResult::Ok(_) => {
            println!("   ✓ Данные загружены (неожиданно)");
        },
        StorageResult::UnprocessableEntity => {
            println!("   ✓ Корректно обработаны невалидные данные");
            println!("   • Система правильно определила, что данные не являются Individual");
        },
        StorageResult::NotFound => {
            println!("   ✗ Данные не найдены (неожиданно)");
        },
        StorageResult::NotReady => {
            println!("   ✗ Хранилище не готово");
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка: {}", msg);
        }
    }
    
    println!("\n5. Работа с различными типами хранилищ:");
    
    // Демонстрация работы с разными типами хранилищ
    let mut memory_storage = VStorageEnum::memory();
    
    println!("   • Память: сохранение данных...");
    match memory_storage.put_value(StorageId::Individuals, "test:memory", individual_data) {
        StorageResult::Ok(_) => {
            println!("     ✓ Данные сохранены в памяти");
            
            // Проверяем загрузку
                         match memory_storage.get_individual(StorageId::Individuals, "test:memory", &mut individual) {
                StorageResult::Ok(_) => {
                    println!("     ✓ Данные успешно загружены из памяти");
                    println!("     • ID: {}", individual.get_id());
                },
                result => {
                    println!("     ✗ Не удалось загрузить данные: {:?}", result);
                }
            }
        },
        StorageResult::Error(msg) => {
            println!("     ✗ Ошибка при сохранении: {}", msg);
        },
        _ => {
            println!("     ✗ Неожиданная ошибка при сохранении");
        }
    }
    
    println!("\n6. Подсчет количества Individual:");
    match storage.count(StorageId::Individuals) {
        StorageResult::Ok(count) => {
            println!("   ✓ В хранилище {} Individual(s)", count);
        },
        StorageResult::Error(msg) => {
            println!("   ✗ Ошибка при подсчете: {}", msg);
        },
        _ => {
            println!("   ✗ Подсчет недоступен");
        }
    }
    
    println!("\n7. Лучшие практики:");
    println!("   • Всегда проверяйте StorageResult при загрузке Individual");
    println!("   • StorageResult::UnprocessableEntity означает, что данные есть, но не валидны");
    println!("   • StorageResult::NotFound означает, что данных нет");
    println!("   • StorageResult::NotReady означает, что хранилище не готово к работе");
    println!("   • Используйте соответствующие методы для разных типов данных");
    
    println!("\n=== Демонстрация завершена ===");
}

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

👎Deprecated since 0.1.0: Use get_individual_from_storage instead

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

👎Deprecated since 0.1.0: Use get_value instead

Examples found in repository

examples/basic_usage.rs (line 133)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Basic v-storage Usage Example ===\n");

    // Create memory storage using Builder pattern
    let storage = VStorage::builder()
        .memory()
        .build()?;
    let mut storage = VStorage::new(storage);

    println!("✅ Storage created successfully");

    // === Basic data operations ===
    
    // 1. Storing data
    println!("\n📝 Storing data:");
    
    let _ = storage.put_value(StorageId::Individuals, "user:1", r#"{
        "@": "user:1", 
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Ivan Petrov"}],
        "foaf:name": [{"type": "String", "data": "Ivan"}],
        "foaf:familyName": [{"type": "String", "data": "Petrov"}], 
        "foaf:age": [{"type": "Integer", "data": 30}],
        "foaf:mbox": [{"type": "String", "data": "ivan.petrov@example.com"}],
        "veda:created": [{"type": "Datetime", "data": "2024-01-15T10:30:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Tickets, "ticket:123", r#"{
        "@": "ticket:123",
        "rdf:type": [{"type": "Uri", "data": "veda:Ticket"}],
        "rdfs:label": [{"type": "String", "data": "Support Request"}],
        "dcterms:title": [{"type": "String", "data": "Email server issue"}],
        "veda:status": [{"type": "String", "data": "pending"}],
        "veda:priority": [{"type": "String", "data": "medium"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T09:15:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Az, "permission:read", r#"{
        "@": "permission:read",
        "rdf:type": [{"type": "Uri", "data": "veda:Permission"}],
        "rdfs:label": [{"type": "String", "data": "Read Access"}],
        "veda:permissionSubject": [{"type": "Uri", "data": "user:1"}],
        "veda:permissionObject": [{"type": "Uri", "data": "resource:documents"}],
        "veda:canRead": [{"type": "Boolean", "data": true}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T08:00:00Z"}]
    }"#);

    println!("   • Stored user: user:1");
    println!("   • Stored ticket: ticket:123");
    println!("   • Stored permission: permission:read");

    // 2. Reading data
    println!("\n📖 Reading data:");
    
    if let StorageResult::Ok(user_data) = storage.get_value(StorageId::Individuals, "user:1") {
        println!("   • User Individual ({}): Ivan Petrov", user_data.len());
    }
    
    if let StorageResult::Ok(ticket_data) = storage.get_value(StorageId::Tickets, "ticket:123") {
        println!("   • Ticket Individual ({}): Support Request", ticket_data.len());
    }
    
    if let StorageResult::Ok(permission_data) = storage.get_value(StorageId::Az, "permission:read") {
        println!("   • Permission Individual ({}): Read Access", permission_data.len());
    }

    // 3. Working with binary data
    println!("\n🔢 Working with binary data:");
    
    let binary_data = vec![0xFF, 0xFE, 0xFD, 0x00, 0x01, 0x02];
    let _ = storage.put_raw_value(StorageId::Individuals, "binary:data", binary_data.clone());
    
    if let StorageResult::Ok(retrieved_binary) = storage.get_raw_value(StorageId::Individuals, "binary:data") {
        println!("   • Stored {} bytes of binary data", retrieved_binary.len());
        println!("   • Data matches: {}", retrieved_binary == binary_data);
    }

    // 4. Counting records
    println!("\n📊 Statistics:");
    
    if let StorageResult::Ok(individuals_count) = storage.count(StorageId::Individuals) {
        println!("   • Individuals count: {}", individuals_count);
    }
    
    if let StorageResult::Ok(tickets_count) = storage.count(StorageId::Tickets) {
        println!("   • Tickets count: {}", tickets_count);
    }
    
    if let StorageResult::Ok(az_count) = storage.count(StorageId::Az) {
        println!("   • Permissions count: {}", az_count);
    }

    // 5. Removing data
    println!("\n🗑️  Removing data:");
    
    let _ = storage.remove_value(StorageId::Tickets, "ticket:123");
    println!("   • Ticket ticket:123 removed");
    
    // Check that data is actually removed
    match storage.get_value(StorageId::Tickets, "ticket:123") {
        StorageResult::NotFound => println!("   • Confirmed: ticket not found"),
        _ => println!("   • Error: ticket still exists"),
    }

    // 6. Error handling
    println!("\n⚠️  Error handling:");
    
    match storage.get_value(StorageId::Individuals, "nonexistent") {
        StorageResult::NotFound => println!("   • Correctly handled missing key case"),
        StorageResult::Ok(_) => println!("   • Unexpected: found data"),
        StorageResult::Error(e) => println!("   • Error: {}", e),
        _ => println!("   • Other result"),
    }

    // === Backward compatibility demonstration ===
    println!("\n🔄 Backward compatibility:");
    
    #[allow(deprecated)]
    {
        // Using old methods
        let success = storage.put_kv(StorageId::Individuals, "old:key", "old:value");
        println!("   • Old put_kv: {}", if success { "success" } else { "error" });
        
        if let Some(value) = storage.get_v(StorageId::Individuals, "old:key") {
            println!("   • Old get_v: {}", value);
        }
    }

    println!("\n✨ Example completed successfully!");
    Ok(())
}

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

👎Deprecated since 0.1.0: Use get_raw_value instead

pub fn put_kv(&mut self, storage: StorageId, key: &str, val: &str) -> bool

👎Deprecated since 0.1.0: Use put_value instead

Examples found in repository

examples/basic_usage.rs (line 130)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Basic v-storage Usage Example ===\n");

    // Create memory storage using Builder pattern
    let storage = VStorage::builder()
        .memory()
        .build()?;
    let mut storage = VStorage::new(storage);

    println!("✅ Storage created successfully");

    // === Basic data operations ===
    
    // 1. Storing data
    println!("\n📝 Storing data:");
    
    let _ = storage.put_value(StorageId::Individuals, "user:1", r#"{
        "@": "user:1", 
        "rdf:type": [{"type": "Uri", "data": "foaf:Person"}],
        "rdfs:label": [{"type": "String", "data": "Ivan Petrov"}],
        "foaf:name": [{"type": "String", "data": "Ivan"}],
        "foaf:familyName": [{"type": "String", "data": "Petrov"}], 
        "foaf:age": [{"type": "Integer", "data": 30}],
        "foaf:mbox": [{"type": "String", "data": "ivan.petrov@example.com"}],
        "veda:created": [{"type": "Datetime", "data": "2024-01-15T10:30:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Tickets, "ticket:123", r#"{
        "@": "ticket:123",
        "rdf:type": [{"type": "Uri", "data": "veda:Ticket"}],
        "rdfs:label": [{"type": "String", "data": "Support Request"}],
        "dcterms:title": [{"type": "String", "data": "Email server issue"}],
        "veda:status": [{"type": "String", "data": "pending"}],
        "veda:priority": [{"type": "String", "data": "medium"}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T09:15:00Z"}]
    }"#);
    let _ = storage.put_value(StorageId::Az, "permission:read", r#"{
        "@": "permission:read",
        "rdf:type": [{"type": "Uri", "data": "veda:Permission"}],
        "rdfs:label": [{"type": "String", "data": "Read Access"}],
        "veda:permissionSubject": [{"type": "Uri", "data": "user:1"}],
        "veda:permissionObject": [{"type": "Uri", "data": "resource:documents"}],
        "veda:canRead": [{"type": "Boolean", "data": true}],
        "dcterms:created": [{"type": "Datetime", "data": "2024-01-15T08:00:00Z"}]
    }"#);

    println!("   • Stored user: user:1");
    println!("   • Stored ticket: ticket:123");
    println!("   • Stored permission: permission:read");

    // 2. Reading data
    println!("\n📖 Reading data:");
    
    if let StorageResult::Ok(user_data) = storage.get_value(StorageId::Individuals, "user:1") {
        println!("   • User Individual ({}): Ivan Petrov", user_data.len());
    }
    
    if let StorageResult::Ok(ticket_data) = storage.get_value(StorageId::Tickets, "ticket:123") {
        println!("   • Ticket Individual ({}): Support Request", ticket_data.len());
    }
    
    if let StorageResult::Ok(permission_data) = storage.get_value(StorageId::Az, "permission:read") {
        println!("   • Permission Individual ({}): Read Access", permission_data.len());
    }

    // 3. Working with binary data
    println!("\n🔢 Working with binary data:");
    
    let binary_data = vec![0xFF, 0xFE, 0xFD, 0x00, 0x01, 0x02];
    let _ = storage.put_raw_value(StorageId::Individuals, "binary:data", binary_data.clone());
    
    if let StorageResult::Ok(retrieved_binary) = storage.get_raw_value(StorageId::Individuals, "binary:data") {
        println!("   • Stored {} bytes of binary data", retrieved_binary.len());
        println!("   • Data matches: {}", retrieved_binary == binary_data);
    }

    // 4. Counting records
    println!("\n📊 Statistics:");
    
    if let StorageResult::Ok(individuals_count) = storage.count(StorageId::Individuals) {
        println!("   • Individuals count: {}", individuals_count);
    }
    
    if let StorageResult::Ok(tickets_count) = storage.count(StorageId::Tickets) {
        println!("   • Tickets count: {}", tickets_count);
    }
    
    if let StorageResult::Ok(az_count) = storage.count(StorageId::Az) {
        println!("   • Permissions count: {}", az_count);
    }

    // 5. Removing data
    println!("\n🗑️  Removing data:");
    
    let _ = storage.remove_value(StorageId::Tickets, "ticket:123");
    println!("   • Ticket ticket:123 removed");
    
    // Check that data is actually removed
    match storage.get_value(StorageId::Tickets, "ticket:123") {
        StorageResult::NotFound => println!("   • Confirmed: ticket not found"),
        _ => println!("   • Error: ticket still exists"),
    }

    // 6. Error handling
    println!("\n⚠️  Error handling:");
    
    match storage.get_value(StorageId::Individuals, "nonexistent") {
        StorageResult::NotFound => println!("   • Correctly handled missing key case"),
        StorageResult::Ok(_) => println!("   • Unexpected: found data"),
        StorageResult::Error(e) => println!("   • Error: {}", e),
        _ => println!("   • Other result"),
    }

    // === Backward compatibility demonstration ===
    println!("\n🔄 Backward compatibility:");
    
    #[allow(deprecated)]
    {
        // Using old methods
        let success = storage.put_kv(StorageId::Individuals, "old:key", "old:value");
        println!("   • Old put_kv: {}", if success { "success" } else { "error" });
        
        if let Some(value) = storage.get_v(StorageId::Individuals, "old:key") {
            println!("   • Old get_v: {}", value);
        }
    }

    println!("\n✨ Example completed successfully!");
    Ok(())
}

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

👎Deprecated since 0.1.0: Use put_raw_value instead

pub fn remove(&mut self, storage: StorageId, key: &str) -> bool

👎Deprecated since 0.1.0: Use remove_value instead

Trait Implementations

impl StorageDispatcher for VStorage

type Storage = Box<dyn Storage>

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

where F: FnOnce(&mut Self::Storage) -> T,

fn with_storage_result<F>(&mut self, operation: F) -> StorageResult<()>

where F: FnOnce(&mut Self::Storage) -> StorageResult<()>,

fn with_storage_value<T, F>(&mut self, operation: F) -> StorageResult<T>

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