checking persistence on desktop and esp32

Signed-off-by: Peter Siegmund <developer@mars3142.org>

components/insa/include/common/IPersistenceManager.h

@@ -0,0 +1,136 @@
+#pragma once
+
+#include <string>
+#include <type_traits>
+
+/**
+ * @interface IPersistenceManager
+ * @brief Abstract interface for platform-independent persistence management
+ * @details This interface defines the contract for key-value storage and retrieval
+ *          systems across different platforms (Desktop/SDL3 and ESP32).
+ */
+class IPersistenceManager
+{
+public:
+    virtual ~IPersistenceManager() = default;
+
+    /**
+     * @brief Template methods for type-safe setting and retrieving of values
+     * @tparam T The type of value to set (must be one of: bool, int, float, double, std::string)
+     * @param key The key to associate with the value
+     * @param value The value to store
+     */
+    template<typename T>
+    void SetValue(const std::string& key, const T& value) {
+        static_assert(std::is_same_v<T, bool> || 
+                     std::is_same_v<T, int> || 
+                     std::is_same_v<T, float> || 
+                     std::is_same_v<T, double> || 
+                     std::is_same_v<T, std::string>,
+                     "Unsupported type for IPersistenceManager");
+        SetValueImpl(key, value);
+    }
+
+    /**
+     * @brief Template method for type-safe retrieval of values
+     * @tparam T The type of value to retrieve
+     * @param key The key to look up
+     * @param defaultValue The default value to return if key is not found
+     * @return The stored value or default value if key doesn't exist
+     */
+    template<typename T>
+    T GetValue(const std::string& key, const T& defaultValue = T{}) const {
+        return GetValueImpl<T>(key, defaultValue);
+    }
+
+    /**
+     * @brief Convenience methods for setting specific types
+     */
+    void SetBool(const std::string& key, bool value) { SetValue(key, value); }
+    void SetInt(const std::string& key, int value) { SetValue(key, value); }
+    void SetFloat(const std::string& key, float value) { SetValue(key, value); }
+    void SetDouble(const std::string& key, double value) { SetValue(key, value); }
+    void SetString(const std::string& key, const std::string& value) { SetValue(key, value); }
+
+    /**
+     * @brief Convenience methods for getting specific types with default values
+     */
+    bool GetBool(const std::string& key, bool defaultValue = false) const { 
+        return GetValue(key, defaultValue); 
+    }
+    int GetInt(const std::string& key, int defaultValue = 0) const { 
+        return GetValue(key, defaultValue); 
+    }
+    float GetFloat(const std::string& key, float defaultValue = 0.0f) const { 
+        return GetValue(key, defaultValue); 
+    }
+    double GetDouble(const std::string& key, double defaultValue = 0.0) const { 
+        return GetValue(key, defaultValue); 
+    }
+    std::string GetString(const std::string& key, const std::string& defaultValue = "") const { 
+        return GetValue(key, defaultValue); 
+    }
+
+    /**
+     * @brief Utility methods for key management
+     */
+    virtual bool HasKey(const std::string& key) const = 0; ///< Check if a key exists
+    virtual void RemoveKey(const std::string& key) = 0; ///< Remove a key-value pair
+    virtual void Clear() = 0; ///< Clear all stored data
+    virtual size_t GetKeyCount() const = 0; ///< Get the number of stored keys
+
+    /**
+     * @brief Persistence operations
+     */
+    virtual bool Save() = 0; ///< Save data to persistent storage
+    virtual bool Load() = 0; ///< Load data from persistent storage
+
+protected:
+    /**
+     * @brief Template-specific implementations that must be overridden by derived classes
+     * @details These methods handle the actual storage and retrieval of different data types
+     */
+    virtual void SetValueImpl(const std::string& key, bool value) = 0;
+    virtual void SetValueImpl(const std::string& key, int value) = 0;
+    virtual void SetValueImpl(const std::string& key, float value) = 0;
+    virtual void SetValueImpl(const std::string& key, double value) = 0;
+    virtual void SetValueImpl(const std::string& key, const std::string& value) = 0;
+
+    virtual bool GetValueImpl(const std::string& key, bool defaultValue) const = 0;
+    virtual int GetValueImpl(const std::string& key, int defaultValue) const = 0;
+    virtual float GetValueImpl(const std::string& key, float defaultValue) const = 0;
+    virtual double GetValueImpl(const std::string& key, double defaultValue) const = 0;
+    virtual std::string GetValueImpl(const std::string& key, const std::string& defaultValue) const = 0;
+
+private:
+    /**
+     * @brief Template dispatch methods for type-safe value retrieval
+     * @tparam T The type to retrieve
+     * @param key The key to look up
+     * @param defaultValue The default value to return
+     * @return The retrieved value or default if not found
+     */
+    template<typename T>
+    T GetValueImpl(const std::string& key, const T& defaultValue) const
+    {
+        if constexpr (std::is_same_v<T, bool>) {
+            return GetValueImpl(key, defaultValue);
+        } else if constexpr (std::is_same_v<T, int>) {
+            return GetValueImpl(key, defaultValue);
+        } else if constexpr (std::is_same_v<T, float>) {
+            return GetValueImpl(key, defaultValue);
+        } else if constexpr (std::is_same_v<T, double>) {
+            return GetValueImpl(key, defaultValue);
+        } else if constexpr (std::is_same_v<T, std::string>) {
+            return GetValueImpl(key, defaultValue);
+        } else {
+            static_assert(std::is_same_v<T, bool> || 
+                         std::is_same_v<T, int> || 
+                         std::is_same_v<T, float> || 
+                         std::is_same_v<T, double> || 
+                         std::is_same_v<T, std::string>,
+                         "Unsupported type for IPersistenceManager");
+            return defaultValue; // This line will never be reached, but satisfies compiler
+        }
+    }
+};