StorageManagerExample.swift

Go to the documentation of this file.

import Foundation
 
/**
 * StorageManager and KeyValueStorage usage example for Swift
 * Demonstrates working with storage management, key-value storage operations, and data persistence
 */
class StorageManagerExample {
    private var sdk: NavigineSdk?
    private var storageManager: StorageManager?
    private var userStorage: KeyValueStorage?
    private var appStorage: KeyValueStorage?
    private var cacheStorage: KeyValueStorage?
    
    init() {
        initializeSdk()
        setupStorages()
    }
    
    /**
     * Initialize SDK and get StorageManager
     */
    private func initializeSdk() {
        do {
            // [swift_NavigineSdk_getInstance]
            // Get SDK instance
            sdk = NavigineSdk.getInstance()
            // [swift_NavigineSdk_getInstance]
            
            // [swift_NavigineSdk_setUserHash]
            // Set user hash
            sdk?.setUserHash("USER-HASH-HERE")
            // [swift_NavigineSdk_setUserHash]
            
            // [swift_NavigineSdk_setServer]
            // Set server URL (optional)
            sdk?.setServer("https://custom.navigine.com")
            // [swift_NavigineSdk_setServer]
            
            // [swift_NavigineSdk_getStorageManager]
            // Get StorageManager for working with storages
            storageManager = sdk?.getStorageManager()
            // [swift_NavigineSdk_getStorageManager]
            
            if storageManager != nil {
                print("StorageManager successfully initialized")
            }
        } catch {
            print("Error initializing SDK: \‍(error)")
        }
    }
    
    /**
     * Setup different storage instances
     */
    private func setupStorages() {
        guard let storageManager = storageManager else {
            print("StorageManager not initialized")
            return
        }
        
        // [swift_StorageManager_getStorage]
        // Get or create different storage instances
        userStorage = storageManager.getStorage(name: "user_preferences")
        appStorage = storageManager.getStorage(name: "app_settings")
        cacheStorage = storageManager.getStorage(name: "cache")
        // [swift_StorageManager_getStorage]
        
        print("Storage instances created")
    }
    
    /**
     * Demonstrate StorageManager methods
     */
    func demonstrateStorageManagerMethods() {
        guard let storageManager = storageManager else {
            print("StorageManager not initialized")
            return
        }
        
        // [swift_StorageManager_getStorageList]
        // Get list of all existing storages
        let storageList: [String] = storageManager.getStorageList()
        print("Existing storages: \‍(storageList)")
        // [swift_StorageManager_getStorageList]
        
        // [swift_StorageManager_getStorage1]
        // Get or create storage by name
        let testStorage: KeyValueStorage = storageManager.getStorage(name: "test_storage")
        print("Created test storage")
        // [swift_StorageManager_getStorage1]
        
        // Demonstrate storage creation and listing
        storageManager.getStorage(name: "another_storage")
        let updatedList: [String] = storageManager.getStorageList()
        print("Updated storage list: \‍(updatedList)")
        
        // [swift_StorageManager_removeStorage]
        // Remove storage and all its data
        storageManager.removeStorage(name: "test_storage")
        print("Removed test storage")
        // [swift_StorageManager_removeStorage]
        
        let finalList: [String] = storageManager.getStorageList()
        print("Final storage list: \‍(finalList)")
    }
    
    /**
     * Demonstrate KeyValueStorage methods
     */
    func demonstrateKeyValueStorageMethods() {
        guard let userStorage = userStorage else {
            print("User storage not initialized")
            return
        }
        
        print("\n=== KeyValueStorage Methods Demonstration ===")
        
        // [swift_KeyValueStorage_putString]
        // Store string values
        userStorage.putString(key: "user_name", value: "John Doe")
        userStorage.putString(key: "user_email", value: "john.doe@example.com")
        print("Stored string values")
        // [swift_KeyValueStorage_putString]
        
        // [swift_KeyValueStorage_putInt]
        // Store integer values
        userStorage.putInt(key: "user_age", value: 25)
        userStorage.putInt(key: "login_count", value: 42)
        print("Stored integer values")
        // [swift_KeyValueStorage_putInt]
        
        // [swift_KeyValueStorage_putLong]
        // Store long values
        userStorage.putLong(key: "registration_timestamp", value: 1640995200000)
        userStorage.putLong(key: "last_login_timestamp", value: Int64(Date().timeIntervalSince1970 * 1000))
        print("Stored long values")
        // [swift_KeyValueStorage_putLong]
        
        // [swift_KeyValueStorage_putBool]
        // Store boolean values
        userStorage.putBool(key: "is_premium", value: true)
        userStorage.putBool(key: "notifications_enabled", value: false)
        print("Stored boolean values")
        // [swift_KeyValueStorage_putBool]
        
        // [swift_KeyValueStorage_putFloat]
        // Store float values
        userStorage.putFloat(key: "user_rating", value: 4.5)
        userStorage.putFloat(key: "temperature", value: 23.5)
        print("Stored float values")
        // [swift_KeyValueStorage_putFloat]
        
        // [swift_KeyValueStorage_putDouble]
        // Store double values
        userStorage.putDouble(key: "user_location_lat", value: 55.7558)
        userStorage.putDouble(key: "user_location_lng", value: 37.6176)
        print("Stored double values")
        // [swift_KeyValueStorage_putDouble]
        
        // [swift_KeyValueStorage_contains]
        // Check if keys exist
        let hasUserName: Bool = userStorage.contains(key: "user_name")
        let hasNonExistent: Bool = userStorage.contains(key: "non_existent_key")
        print("Contains 'user_name': \‍(hasUserName)")
        print("Contains 'non_existent_key': \‍(hasNonExistent)")
        // [swift_KeyValueStorage_contains]
        
        // [swift_KeyValueStorage_getKeys]
        // Get all stored keys
        let allKeys: [String] = userStorage.getKeys()
        print("All stored keys: \‍(allKeys)")
        // [swift_KeyValueStorage_getKeys]
        
        // [swift_KeyValueStorage_getString]
        // Retrieve string values with defaults
        let userName: String = userStorage.getString(key: "user_name", defaultValue: "Unknown")
        let userEmail: String = userStorage.getString(key: "user_email", defaultValue: "")
        let nonExistent: String = userStorage.getString(key: "non_existent_key", defaultValue: "default_value")
        print("User name: \‍(userName)")
        print("User email: \‍(userEmail)")
        print("Non-existent key: \‍(nonExistent)")
        // [swift_KeyValueStorage_getString]
        
        // [swift_KeyValueStorage_getInt]
        // Retrieve integer values with defaults
        let userAge: Int32 = userStorage.getInt(key: "user_age", defaultValue: 0)
        let loginCount: Int32 = userStorage.getInt(key: "login_count", defaultValue: 0)
        let nonExistentInt: Int32 = userStorage.getInt(key: "non_existent_int", defaultValue: -1)
        print("User age: \‍(userAge)")
        print("Login count: \‍(loginCount)")
        print("Non-existent int: \‍(nonExistentInt)")
        // [swift_KeyValueStorage_getInt]
        
        // [swift_KeyValueStorage_getLong]
        // Retrieve long values with defaults
        let regTimestamp: Int64 = userStorage.getLong(key: "registration_timestamp", defaultValue: 0)
        let lastLogin: Int64 = userStorage.getLong(key: "last_login_timestamp", defaultValue: 0)
        let nonExistentLong: Int64 = userStorage.getLong(key: "non_existent_long", defaultValue: -1)
        print("Registration timestamp: \‍(regTimestamp)")
        print("Last login timestamp: \‍(lastLogin)")
        print("Non-existent long: \‍(nonExistentLong)")
        // [swift_KeyValueStorage_getLong]
        
        // [swift_KeyValueStorage_getBool]
        // Retrieve boolean values with defaults
        let isPremium: Bool = userStorage.getBool(key: "is_premium", defaultValue: false)
        let notificationsEnabled: Bool = userStorage.getBool(key: "notifications_enabled", defaultValue: true)
        let nonExistentBool: Bool = userStorage.getBool(key: "non_existent_bool", defaultValue: false)
        print("Is premium: \‍(isPremium)")
        print("Notifications enabled: \‍(notificationsEnabled)")
        print("Non-existent bool: \‍(nonExistentBool)")
        // [swift_KeyValueStorage_getBool]
        
        // [swift_KeyValueStorage_getFloat]
        // Retrieve float values with defaults
        let userRating: Float = userStorage.getFloat(key: "user_rating", defaultValue: 0.0)
        let temperature: Float = userStorage.getFloat(key: "temperature", defaultValue: 0.0)
        let nonExistentFloat: Float = userStorage.getFloat(key: "non_existent_float", defaultValue: -1.0)
        print("User rating: \‍(userRating)")
        print("Temperature: \‍(temperature)")
        print("Non-existent float: \‍(nonExistentFloat)")
        // [swift_KeyValueStorage_getFloat]
        
        // [swift_KeyValueStorage_getDouble]
        // Retrieve double values with defaults
        let userLat: Double = userStorage.getDouble(key: "user_location_lat", defaultValue: 0.0)
        let userLng: Double = userStorage.getDouble(key: "user_location_lng", defaultValue: 0.0)
        let nonExistentDouble: Double = userStorage.getDouble(key: "non_existent_double", defaultValue: -1.0)
        print("User location lat: \‍(userLat)")
        print("User location lng: \‍(userLng)")
        print("Non-existent double: \‍(nonExistentDouble)")
        // [swift_KeyValueStorage_getDouble]
        
        // [swift_KeyValueStorage_remove]
        // Remove specific keys
        userStorage.remove(key: "user_age")
        userStorage.remove(key: "non_existent_key") // No-op
        print("Removed 'user_age' key")
        // [swift_KeyValueStorage_remove]
        
        // Verify removal
        let stillHasAge: Bool = userStorage.contains(key: "user_age")
        print("Still contains 'user_age': \‍(stillHasAge)")
        
        // [swift_KeyValueStorage_clear]
        // Clear all data
        userStorage.clear()
        print("Cleared all data from user storage")
        // [swift_KeyValueStorage_clear]
        
        // Verify clear
        let keysAfterClear: [String] = userStorage.getKeys()
        print("Keys after clear: \‍(keysAfterClear)")
    }
    
    /**
     * Demonstrate multiple storages
     */
    func demonstrateMultipleStorages() {
        guard let userStorage = userStorage,
              let appStorage = appStorage,
              let cacheStorage = cacheStorage else {
            print("Storages not initialized")
            return
        }
        
        print("\n=== Multiple Storages Demonstration ===")
        
        // Store different data in different storages
        userStorage.putString(key: "name", value: "John Doe")
        userStorage.putInt(key: "age", value: 25)
        userStorage.putBool(key: "is_premium", value: true)
        
        appStorage.putString(key: "theme", value: "dark")
        appStorage.putInt(key: "api_version", value: 2)
        appStorage.putBool(key: "debug_mode", value: false)
        
        cacheStorage.putLong(key: "last_update", value: Int64(Date().timeIntervalSince1970 * 1000))
        cacheStorage.putString(key: "api_token", value: "abc123")
        cacheStorage.putDouble(key: "cached_rating", value: 4.2)
        
        // Retrieve data from different storages
        print("User storage data:")
        demonstrateStorageData(storage: userStorage)
        
        print("\nApp storage data:")
        demonstrateStorageData(storage: appStorage)
        
        print("\nCache storage data:")
        demonstrateStorageData(storage: cacheStorage)
    }
    
    /**
     * Demonstrate storage data
     */
    private func demonstrateStorageData(storage: KeyValueStorage) {
        let keys: [String] = storage.getKeys()
        for key in keys {
            if storage.contains(key: key) {
                // Try to get value as string first
                let stringValue: String = storage.getString(key: key, defaultValue: "")
                if !stringValue.isEmpty {
                    print("  \‍(key): \‍(stringValue) (string)")
                    continue
                }
                
                // Try integer
                let intValue: Int32 = storage.getInt(key: key, defaultValue: -999999)
                if intValue != -999999 {
                    print("  \‍(key): \‍(intValue) (int)")
                    continue
                }
                
                // Try long
                let longValue: Int64 = storage.getLong(key: key, defaultValue: -999999)
                if longValue != -999999 {
                    print("  \‍(key): \‍(longValue) (long)")
                    continue
                }
                
                // Try boolean
                let boolValue: Bool = storage.getBool(key: key, defaultValue: false)
                if storage.contains(key: key) {
                    print("  \‍(key): \‍(boolValue) (bool)")
                    continue
                }
                
                // Try float
                let floatValue: Float = storage.getFloat(key: key, defaultValue: -999999.0)
                if floatValue != -999999.0 {
                    print("  \‍(key): \‍(floatValue) (float)")
                    continue
                }
                
                // Try double
                let doubleValue: Double = storage.getDouble(key: key, defaultValue: -999999.0)
                if doubleValue != -999999.0 {
                    print("  \‍(key): \‍(doubleValue) (double)")
                }
            }
        }
    }
    
    /**
     * Demonstrate storage analytics
     */
    func demonstrateStorageAnalytics() {
        guard let storageManager = storageManager else {
            print("StorageManager not initialized")
            return
        }
        
        print("\n=== Storage Analytics ===")
        
        // Analyze all storages
        let allStorages: [String] = storageManager.getStorageList()
        print("Total storages: \‍(allStorages.count)")
        
        for storageName in allStorages {
            let storage: KeyValueStorage = storageManager.getStorage(name: storageName)
            let keys: [String] = storage.getKeys()
            print("Storage '\‍(storageName)' contains \‍(keys.count) items")
            
            // Analyze data types
            var stringCount = 0
            var intCount = 0
            var longCount = 0
            var boolCount = 0
            var floatCount = 0
            var doubleCount = 0
            
            for key in keys {
                // Count by trying to get each type
                let stringValue: String = storage.getString(key: key, defaultValue: "")
                if !stringValue.isEmpty {
                    stringCount += 1
                    continue
                }
                
                let intValue: Int32 = storage.getInt(key: key, defaultValue: -999999)
                if intValue != -999999 {
                    intCount += 1
                    continue
                }
                
                let longValue: Int64 = storage.getLong(key: key, defaultValue: -999999)
                if longValue != -999999 {
                    longCount += 1
                    continue
                }
                
                let boolValue: Bool = storage.getBool(key: key, defaultValue: false)
                if storage.contains(key: key) {
                    boolCount += 1
                    continue
                }
                
                let floatValue: Float = storage.getFloat(key: key, defaultValue: -999999.0)
                if floatValue != -999999.0 {
                    floatCount += 1
                    continue
                }
                
                let doubleValue: Double = storage.getDouble(key: key, defaultValue: -999999.0)
                if doubleValue != -999999.0 {
                    doubleCount += 1
                }
            }
            
            print("  - Strings: \‍(stringCount)")
            print("  - Integers: \‍(intCount)")
            print("  - Longs: \‍(longCount)")
            print("  - Booleans: \‍(boolCount)")
            print("  - Floats: \‍(floatCount)")
            print("  - Doubles: \‍(doubleCount)")
        }
    }
    
    /**
     * Demonstrate data migration
     */
    func demonstrateDataMigration() {
        guard let storageManager = storageManager else {
            print("StorageManager not initialized")
            return
        }
        
        print("\n=== Data Migration Demonstration ===")
        
        // Create old and new storages
        let oldStorage: KeyValueStorage = storageManager.getStorage(name: "old_storage")
        let newStorage: KeyValueStorage = storageManager.getStorage(name: "new_storage")
        
        // Populate old storage with data
        oldStorage.putString(key: "name", value: "John Doe")
        oldStorage.putInt(key: "age", value: 25)
        oldStorage.putBool(key: "is_premium", value: true)
        oldStorage.putDouble(key: "rating", value: 4.5)
        
        print("Old storage before migration:")
        demonstrateStorageData(storage: oldStorage)
        
        // Migrate data from old to new storage
        let keys: [String] = oldStorage.getKeys()
        for key in keys {
            // Migrate string data
            let stringValue: String = oldStorage.getString(key: key, defaultValue: "")
            if !stringValue.isEmpty {
                newStorage.putString(key: key, value: stringValue)
                continue
            }
            
            // Migrate integer data
            let intValue: Int32 = oldStorage.getInt(key: key, defaultValue: -999999)
            if intValue != -999999 {
                newStorage.putInt(key: key, value: intValue)
                continue
            }
            
            // Migrate long data
            let longValue: Int64 = oldStorage.getLong(key: key, defaultValue: -999999)
            if longValue != -999999 {
                newStorage.putLong(key: key, value: longValue)
                continue
            }
            
            // Migrate boolean data
            let boolValue: Bool = oldStorage.getBool(key: key, defaultValue: false)
            if oldStorage.contains(key: key) {
                newStorage.putBool(key: key, value: boolValue)
                continue
            }
            
            // Migrate float data
            let floatValue: Float = oldStorage.getFloat(key: key, defaultValue: -999999.0)
            if floatValue != -999999.0 {
                newStorage.putFloat(key: key, value: floatValue)
                continue
            }
            
            // Migrate double data
            let doubleValue: Double = oldStorage.getDouble(key: key, defaultValue: -999999.0)
            if doubleValue != -999999.0 {
                newStorage.putDouble(key: key, value: doubleValue)
            }
        }
        
        print("\nNew storage after migration:")
        demonstrateStorageData(storage: newStorage)
        
        // Remove old storage
        storageManager.removeStorage(name: "old_storage")
        print("\nRemoved old storage")
        
        // Verify migration
        let finalStorages: [String] = storageManager.getStorageList()
        print("Final storage list: \‍(finalStorages)")
    }
    
    /**
     * Demonstrate storage cleanup
     */
    func demonstrateStorageCleanup() {
        guard let storageManager = storageManager else {
            print("StorageManager not initialized")
            return
        }
        
        print("\n=== Storage Cleanup Demonstration ===")
        
        // Create some temporary storages
        storageManager.getStorage(name: "temp_cache_1")
        storageManager.getStorage(name: "temp_cache_2")
        storageManager.getStorage(name: "permanent_storage")
        
        let beforeCleanup: [String] = storageManager.getStorageList()
        print("Storages before cleanup: \‍(beforeCleanup)")
        
        // Clean up temporary storages
        let storages: [String] = storageManager.getStorageList()
        for storageName in storages {
            if storageName.hasPrefix("temp_") {
                storageManager.removeStorage(name: storageName)
                print("Removed temporary storage: \‍(storageName)")
            }
        }
        
        let afterCleanup: [String] = storageManager.getStorageList()
        print("Storages after cleanup: \‍(afterCleanup)")
    }
    
    /**
     * Run all demonstrations
     */
    func runAllDemonstrations() {
        print("=== StorageManager and KeyValueStorage Examples ===\n")
        
        demonstrateStorageManagerMethods()
        demonstrateKeyValueStorageMethods()
        demonstrateMultipleStorages()
        demonstrateStorageAnalytics()
        demonstrateDataMigration()
        demonstrateStorageCleanup()
        
        print("\n=== All demonstrations completed ===")
    }
    
    /**
     * Cleanup resources
     */
    func cleanup() {
        guard let storageManager = storageManager else { return }
        
        // Remove test storages
        let storages: [String] = storageManager.getStorageList()
        for storageName in storages {
            if storageName.hasPrefix("test_") ||
               storageName.hasPrefix("temp_") ||
               storageName.hasPrefix("old_") ||
               storageName.hasPrefix("new_") {
                storageManager.removeStorage(name: storageName)
            }
        }
    }
}
 
/**
 * Main function to run the example
 */
func main() {
    let example = StorageManagerExample()
    
    // Run all demonstrations
    example.runAllDemonstrations()
    
    // Cleanup
    example.cleanup()
    
    print("Example completed successfully!")
}
 
// Run the example
main()