StorageManagerExample.java

Go to the documentation of this file.

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

public class StorageManagerExample {
    private NavigineSdk sdk;
    private StorageManager storageManager;
    private KeyValueStorage userStorage;
    private KeyValueStorage appStorage;
    private KeyValueStorage cacheStorage;
 
    public StorageManagerExample() {
        initializeSdk();
        setupStorages();
    }

    private void initializeSdk() {
        try {
            // [java_NavigineSdk_getInstance]
            // Get SDK instance
            sdk = NavigineSdk.getInstance();
            // [java_NavigineSdk_getInstance]
 
            // [java_NavigineSdk_setUserHash]
            // Set user hash
            sdk.setUserHash("USER-HASH-HERE");
            // [java_NavigineSdk_setUserHash]
 
            // [java_NavigineSdk_setServer]
            // Set server URL (optional)
            sdk.setServer("https://custom.navigine.com");
            // [java_NavigineSdk_setServer]
 
            // [java_NavigineSdk_getStorageManager]
            // Get StorageManager for working with storages
            storageManager = sdk.getStorageManager();
            // [java_NavigineSdk_getStorageManager]
 
            if (storageManager != null) {
                System.out.println("StorageManager successfully initialized");
            }
        } catch (Exception e) {
            System.out.println("Error initializing SDK: " + e.getMessage());
        }
    }

    private void setupStorages() {
        if (storageManager == null) {
            System.out.println("StorageManager not initialized");
            return;
        }
 
        // [java_StorageManager_getStorage]
        // Get or create different storage instances
        userStorage = storageManager.getStorage("user_preferences");
        appStorage = storageManager.getStorage("app_settings");
        cacheStorage = storageManager.getStorage("cache");
        // [java_StorageManager_getStorage]
 
        System.out.println("Storage instances created");
    }

    public void demonstrateStorageManagerMethods() {
        if (storageManager == null) {
            System.out.println("StorageManager not initialized");
            return;
        }
 
        // [java_StorageManager_getStorageList]
        // Get list of all existing storages
        List<String> storageList = storageManager.getStorageList();
        System.out.println("Existing storages: " + storageList);
        // [java_StorageManager_getStorageList]
 
        // [java_StorageManager_getStorage1]
        // Get or create storage by name
        KeyValueStorage testStorage = storageManager.getStorage("test_storage");
        System.out.println("Created test storage");
        // [java_StorageManager_getStorage1]
 
        // Demonstrate storage creation and listing
        storageManager.getStorage("another_storage");
        List<String> updatedList = storageManager.getStorageList();
        System.out.println("Updated storage list: " + updatedList);
 
        // [java_StorageManager_removeStorage]
        // Remove storage and all its data
        storageManager.removeStorage("test_storage");
        System.out.println("Removed test storage");
        // [java_StorageManager_removeStorage]
 
        List<String> finalList = storageManager.getStorageList();
        System.out.println("Final storage list: " + finalList);
    }

    public void demonstrateKeyValueStorageMethods() {
        if (userStorage == null) {
            System.out.println("User storage not initialized");
            return;
        }
 
        System.out.println("\n=== KeyValueStorage Methods Demonstration ===");
 
        // [java_KeyValueStorage_putString]
        // Store string values
        userStorage.putString("user_name", "John Doe");
        userStorage.putString("user_email", "john.doe@example.com");
        System.out.println("Stored string values");
        // [java_KeyValueStorage_putString]
 
        // [java_KeyValueStorage_putInt]
        // Store integer values
        userStorage.putInt("user_age", 25);
        userStorage.putInt("login_count", 42);
        System.out.println("Stored integer values");
        // [java_KeyValueStorage_putInt]
 
        // [java_KeyValueStorage_putLong]
        // Store long values
        userStorage.putLong("registration_timestamp", 1640995200000L);
        userStorage.putLong("last_login_timestamp", System.currentTimeMillis());
        System.out.println("Stored long values");
        // [java_KeyValueStorage_putLong]
 
        // [java_KeyValueStorage_putBool]
        // Store boolean values
        userStorage.putBool("is_premium", true);
        userStorage.putBool("notifications_enabled", false);
        System.out.println("Stored boolean values");
        // [java_KeyValueStorage_putBool]
 
        // [java_KeyValueStorage_putFloat]
        // Store float values
        userStorage.putFloat("user_rating", 4.5f);
        userStorage.putFloat("temperature", 23.5f);
        System.out.println("Stored float values");
        // [java_KeyValueStorage_putFloat]
 
        // [java_KeyValueStorage_putDouble]
        // Store double values
        userStorage.putDouble("user_location_lat", 55.7558);
        userStorage.putDouble("user_location_lng", 37.6176);
        System.out.println("Stored double values");
        // [java_KeyValueStorage_putDouble]
 
        // [java_KeyValueStorage_contains]
        // Check if keys exist
        boolean hasUserName = userStorage.contains("user_name");
        boolean hasNonExistent = userStorage.contains("non_existent_key");
        System.out.println("Contains 'user_name': " + hasUserName);
        System.out.println("Contains 'non_existent_key': " + hasNonExistent);
        // [java_KeyValueStorage_contains]
 
        // [java_KeyValueStorage_getKeys]
        // Get all stored keys
        List<String> allKeys = userStorage.getKeys();
        System.out.println("All stored keys: " + allKeys);
        // [java_KeyValueStorage_getKeys]
 
        // [java_KeyValueStorage_getString]
        // Retrieve string values with defaults
        String userName = userStorage.getString("user_name", "Unknown");
        String userEmail = userStorage.getString("user_email", "");
        String nonExistent = userStorage.getString("non_existent_key", "default_value");
        System.out.println("User name: " + userName);
        System.out.println("User email: " + userEmail);
        System.out.println("Non-existent key: " + nonExistent);
        // [java_KeyValueStorage_getString]
 
        // [java_KeyValueStorage_getInt]
        // Retrieve integer values with defaults
        int userAge = userStorage.getInt("user_age", 0);
        int loginCount = userStorage.getInt("login_count", 0);
        int nonExistentInt = userStorage.getInt("non_existent_int", -1);
        System.out.println("User age: " + userAge);
        System.out.println("Login count: " + loginCount);
        System.out.println("Non-existent int: " + nonExistentInt);
        // [java_KeyValueStorage_getInt]
 
        // [java_KeyValueStorage_getLong]
        // Retrieve long values with defaults
        long regTimestamp = userStorage.getLong("registration_timestamp", 0);
        long lastLogin = userStorage.getLong("last_login_timestamp", 0);
        long nonExistentLong = userStorage.getLong("non_existent_long", -1);
        System.out.println("Registration timestamp: " + regTimestamp);
        System.out.println("Last login timestamp: " + lastLogin);
        System.out.println("Non-existent long: " + nonExistentLong);
        // [java_KeyValueStorage_getLong]
 
        // [java_KeyValueStorage_getBool]
        // Retrieve boolean values with defaults
        boolean isPremium = userStorage.getBool("is_premium", false);
        boolean notificationsEnabled = userStorage.getBool("notifications_enabled", true);
        boolean nonExistentBool = userStorage.getBool("non_existent_bool", false);
        System.out.println("Is premium: " + isPremium);
        System.out.println("Notifications enabled: " + notificationsEnabled);
        System.out.println("Non-existent bool: " + nonExistentBool);
        // [java_KeyValueStorage_getBool]
 
        // [java_KeyValueStorage_getFloat]
        // Retrieve float values with defaults
        float userRating = userStorage.getFloat("user_rating", 0.0f);
        float temperature = userStorage.getFloat("temperature", 0.0f);
        float nonExistentFloat = userStorage.getFloat("non_existent_float", -1.0f);
        System.out.println("User rating: " + userRating);
        System.out.println("Temperature: " + temperature);
        System.out.println("Non-existent float: " + nonExistentFloat);
        // [java_KeyValueStorage_getFloat]
 
        // [java_KeyValueStorage_getDouble]
        // Retrieve double values with defaults
        double userLat = userStorage.getDouble("user_location_lat", 0.0);
        double userLng = userStorage.getDouble("user_location_lng", 0.0);
        double nonExistentDouble = userStorage.getDouble("non_existent_double", -1.0);
        System.out.println("User location lat: " + userLat);
        System.out.println("User location lng: " + userLng);
        System.out.println("Non-existent double: " + nonExistentDouble);
        // [java_KeyValueStorage_getDouble]
 
        // [java_KeyValueStorage_remove]
        // Remove specific keys
        userStorage.remove("user_age");
        userStorage.remove("non_existent_key"); // No-op
        System.out.println("Removed 'user_age' key");
        // [java_KeyValueStorage_remove]
 
        // Verify removal
        boolean stillHasAge = userStorage.contains("user_age");
        System.out.println("Still contains 'user_age': " + stillHasAge);
 
        // [java_KeyValueStorage_clear]
        // Clear all data
        userStorage.clear();
        System.out.println("Cleared all data from user storage");
        // [java_KeyValueStorage_clear]
 
        // Verify clear
        List<String> keysAfterClear = userStorage.getKeys();
        System.out.println("Keys after clear: " + keysAfterClear);
    }

    public void demonstrateMultipleStorages() {
        if (userStorage == null || appStorage == null || cacheStorage == null) {
            System.out.println("Storages not initialized");
            return;
        }
 
        System.out.println("\n=== Multiple Storages Demonstration ===");
 
        // Store different data in different storages
        userStorage.putString("name", "John Doe");
        userStorage.putInt("age", 25);
        userStorage.putBool("is_premium", true);
 
        appStorage.putString("theme", "dark");
        appStorage.putInt("api_version", 2);
        appStorage.putBool("debug_mode", false);
 
        cacheStorage.putLong("last_update", System.currentTimeMillis());
        cacheStorage.putString("api_token", "abc123");
        cacheStorage.putDouble("cached_rating", 4.2);
 
        // Retrieve data from different storages
        System.out.println("User storage data:");
        demonstrateStorageData(userStorage);
 
        System.out.println("\nApp storage data:");
        demonstrateStorageData(appStorage);
 
        System.out.println("\nCache storage data:");
        demonstrateStorageData(cacheStorage);
    }

    private void demonstrateStorageData(KeyValueStorage storage) {
        List<String> keys = storage.getKeys();
        for (String key : keys) {
            if (storage.contains(key)) {
                // Try to get value as string first
                String stringValue = storage.getString(key, "");
                if (!stringValue.isEmpty()) {
                    System.out.println("  " + key + ": " + stringValue + " (string)");
                    continue;
                }
 
                // Try integer
                int intValue = storage.getInt(key, -999999);
                if (intValue != -999999) {
                    System.out.println("  " + key + ": " + intValue + " (int)");
                    continue;
                }
 
                // Try long
                long longValue = storage.getLong(key, -999999);
                if (longValue != -999999) {
                    System.out.println("  " + key + ": " + longValue + " (long)");
                    continue;
                }
 
                // Try boolean
                boolean boolValue = storage.getBool(key, false);
                if (storage.contains(key)) {
                    System.out.println("  " + key + ": " + boolValue + " (bool)");
                    continue;
                }
 
                // Try float
                float floatValue = storage.getFloat(key, -999999.0f);
                if (floatValue != -999999.0f) {
                    System.out.println("  " + key + ": " + floatValue + " (float)");
                    continue;
                }
 
                // Try double
                double doubleValue = storage.getDouble(key, -999999.0);
                if (doubleValue != -999999.0) {
                    System.out.println("  " + key + ": " + doubleValue + " (double)");
                }
            }
        }
    }

    public void demonstrateStorageAnalytics() {
        if (storageManager == null) {
            System.out.println("StorageManager not initialized");
            return;
        }
 
        System.out.println("\n=== Storage Analytics ===");
 
        // Analyze all storages
        List<String> allStorages = storageManager.getStorageList();
        System.out.println("Total storages: " + allStorages.size());
 
        for (String storageName : allStorages) {
            KeyValueStorage storage = storageManager.getStorage(storageName);
            List<String> keys = storage.getKeys();
            System.out.println("Storage '" + storageName + "' contains " + keys.size() + " items");
 
            // Analyze data types
            int stringCount = 0;
            int intCount = 0;
            int longCount = 0;
            int boolCount = 0;
            int floatCount = 0;
            int doubleCount = 0;
 
            for (String key : keys) {
                // Count by trying to get each type
                String stringValue = storage.getString(key, "");
                if (!stringValue.isEmpty()) {
                    stringCount++;
                    continue;
                }
 
                int intValue = storage.getInt(key, -999999);
                if (intValue != -999999) {
                    intCount++;
                    continue;
                }
 
                long longValue = storage.getLong(key, -999999);
                if (longValue != -999999) {
                    longCount++;
                    continue;
                }
 
                boolean boolValue = storage.getBool(key, false);
                if (storage.contains(key)) {
                    boolCount++;
                    continue;
                }
 
                float floatValue = storage.getFloat(key, -999999.0f);
                if (floatValue != -999999.0f) {
                    floatCount++;
                    continue;
                }
 
                double doubleValue = storage.getDouble(key, -999999.0);
                if (doubleValue != -999999.0) {
                    doubleCount++;
                }
            }
 
            System.out.println("  - Strings: " + stringCount);
            System.out.println("  - Integers: " + intCount);
            System.out.println("  - Longs: " + longCount);
            System.out.println("  - Booleans: " + boolCount);
            System.out.println("  - Floats: " + floatCount);
            System.out.println("  - Doubles: " + doubleCount);
        }
    }

    public void demonstrateDataMigration() {
        if (storageManager == null) {
            System.out.println("StorageManager not initialized");
            return;
        }
 
        System.out.println("\n=== Data Migration Demonstration ===");
 
        // Create old and new storages
        KeyValueStorage oldStorage = storageManager.getStorage("old_storage");
        KeyValueStorage newStorage = storageManager.getStorage("new_storage");
 
        // Populate old storage with data
        oldStorage.putString("name", "John Doe");
        oldStorage.putInt("age", 25);
        oldStorage.putBool("is_premium", true);
        oldStorage.putDouble("rating", 4.5);
 
        System.out.println("Old storage before migration:");
        demonstrateStorageData(oldStorage);
 
        // Migrate data from old to new storage
        List<String> keys = oldStorage.getKeys();
        for (String key : keys) {
            // Migrate string data
            String stringValue = oldStorage.getString(key, "");
            if (!stringValue.isEmpty()) {
                newStorage.putString(key, stringValue);
                continue;
            }
 
            // Migrate integer data
            int intValue = oldStorage.getInt(key, -999999);
            if (intValue != -999999) {
                newStorage.putInt(key, intValue);
                continue;
            }
 
            // Migrate long data
            long longValue = oldStorage.getLong(key, -999999);
            if (longValue != -999999) {
                newStorage.putLong(key, longValue);
                continue;
            }
 
            // Migrate boolean data
            boolean boolValue = oldStorage.getBool(key, false);
            if (oldStorage.contains(key)) {
                newStorage.putBool(key, boolValue);
                continue;
            }
 
            // Migrate float data
            float floatValue = oldStorage.getFloat(key, -999999.0f);
            if (floatValue != -999999.0f) {
                newStorage.putFloat(key, floatValue);
                continue;
            }
 
            // Migrate double data
            double doubleValue = oldStorage.getDouble(key, -999999.0);
            if (doubleValue != -999999.0) {
                newStorage.putDouble(key, doubleValue);
            }
        }
 
        System.out.println("\nNew storage after migration:");
        demonstrateStorageData(newStorage);
 
        // Remove old storage
        storageManager.removeStorage("old_storage");
        System.out.println("\nRemoved old storage");
 
        // Verify migration
        List<String> finalStorages = storageManager.getStorageList();
        System.out.println("Final storage list: " + finalStorages);
    }

    public void demonstrateStorageCleanup() {
        if (storageManager == null) {
            System.out.println("StorageManager not initialized");
            return;
        }
 
        System.out.println("\n=== Storage Cleanup Demonstration ===");
 
        // Create some temporary storages
        storageManager.getStorage("temp_cache_1");
        storageManager.getStorage("temp_cache_2");
        storageManager.getStorage("permanent_storage");
 
        List<String> beforeCleanup = storageManager.getStorageList();
        System.out.println("Storages before cleanup: " + beforeCleanup);
 
        // Clean up temporary storages
        List<String> storages = storageManager.getStorageList();
        for (String storageName : storages) {
            if (storageName.startsWith("temp_")) {
                storageManager.removeStorage(storageName);
                System.out.println("Removed temporary storage: " + storageName);
            }
        }
 
        List<String> afterCleanup = storageManager.getStorageList();
        System.out.println("Storages after cleanup: " + afterCleanup);
    }

    public void runAllDemonstrations() {
        System.out.println("=== StorageManager and KeyValueStorage Examples ===\n");
 
        demonstrateStorageManagerMethods();
        demonstrateKeyValueStorageMethods();
        demonstrateMultipleStorages();
        demonstrateStorageAnalytics();
        demonstrateDataMigration();
        demonstrateStorageCleanup();
 
        System.out.println("\n=== All demonstrations completed ===");
    }

    public void cleanup() {
        if (storageManager != null) {
            // Remove test storages
            List<String> storages = storageManager.getStorageList();
            for (String storageName : storages) {
                if (storageName.startsWith("test_") ||
                    storageName.startsWith("temp_") ||
                    storageName.startsWith("old_") ||
                    storageName.startsWith("new_")) {
                    storageManager.removeStorage(storageName);
                }
            }
        }
    }

    public static void main(String[] args) {
        StorageManagerExample example = new StorageManagerExample();
        
        // Run all demonstrations
        example.runAllDemonstrations();
        
        // Cleanup
        example.cleanup();
        
        System.out.println("Example completed successfully!");
    }
}