qt: Add Qt Wrapper library and QML module

3 files changed, 49 insertions, 50 deletions

diff --git a/src/changewatcher.cpp b/src/changewatcher.cpp
index 4762ebb..ef54019 100644
--- a/src/changewatcher.cpp
+++ b/src/changewatcher.cpp
@@ -1,5 +1,4 @@
 #include "changewatcher.h"
-#include <iostream>
 #include <filesystem>
 #include <sys/inotify.h>
 #include <sys/eventfd.h>
diff --git a/src/settings.cpp b/src/kzsettings.cpp
index addaa32..5580a80 100644
--- a/src/settings.cpp
+++ b/src/kzsettings.cpp
@@ -1,4 +1,4 @@
-#include "settings.h"
+#include "kzsettings.h"
 #include <iostream>
 #include <fstream>
 #include <map>
@@ -23,29 +23,29 @@ static inline bool list_contains(std::vector<std::string> list, const std::strin
 }
 
 namespace KaZoe {
-class SettingsPrivate {
-    friend class Settings;
-    Settings *m_parent;
-    std::map<SettingKey, SettingValue> m_data;
+class KzSettingsPrivate {
+    friend class KzSettings;
+    KzSettings *m_parent;
+    std::map<KzSettingKey, KzSettingValue> m_data;
     ChangeWatcher m_watcher;
-    std::map<SettingKey, std::string> m_owner;
+    std::map<KzSettingKey, std::string> m_owner;
     std::string m_id;
     std::mutex m_mutex_data;
     std::mutex m_mutex_notifier;
     bool m_bypass {false};
-    std::vector<std::function<void(const std::string&, const std::string&, SettingValue)>> m_notifier;
+    std::vector<std::function<void(const std::string&, const std::string&, KzSettingValue)>> m_notifier;
 
 public:
-    SettingsPrivate(Settings *parent)
+    KzSettingsPrivate(KzSettings *parent)
         : m_parent(parent) {
         char result[PATH_MAX];
         ssize_t count = readlink("/proc/self/exe", result, PATH_MAX);
         std::string binary = std::string(result, (count > 0) ? count : 0);
         std::filesystem::path bin = binary;
         m_id = bin.filename();
-        if(m_id == "settings")
+        if(m_id == "kzsettings")
         {
-            // Only "settings cli tools can bypass the owner protection"
+            // Only "kzsettings cli tools can bypass the owner protection"
             m_bypass = true;
         }
 
@@ -54,7 +54,7 @@ public:
         m_watcher.setFileWrited([this](const std::string path){ refreshFile(path); });
     }
 
-    void parseFile(const std::string &filename, std::map<SettingKey, SettingValue> &data, bool watch = false)
+    void parseFile(const std::string &filename, std::map<KzSettingKey, KzSettingValue> &data, bool watch = false)
     {
         if(!std::filesystem::exists(filename))
         {
@@ -92,21 +92,21 @@ public:
 
             if(key.starts_with("@"))
             {
-                m_owner[SettingKey(category, key.substr(1))] = value;
+                m_owner[KzSettingKey(category, key.substr(1))] = value;
                 continue;
             }
             if(key.ends_with("/owner"))
             {
                 std::cerr << "WARNING: Legacy usage for owner: " << key << " should be @" << key.substr(0, key.size() - 6) << std::endl;
-                m_owner[SettingKey(category, key.substr(0, key.size() - 6))] = value;
+                m_owner[KzSettingKey(category, key.substr(0, key.size() - 6))] = value;
                 continue;
             }
 
-            data[SettingKey(category, key)] = makeValue(value);
+            data[KzSettingKey(category, key)] = makeValue(value);
         }
     }
 
-    void parseDir(const std::string &dconf, std::map<SettingKey, SettingValue> &data, bool watch)
+    void parseDir(const std::string &dconf, std::map<KzSettingKey, KzSettingValue> &data, bool watch)
     {
         if(std::filesystem::exists(dconf) && std::filesystem::is_directory(dconf))
         {
@@ -118,7 +118,7 @@ public:
         }
     }
 
-    void parseConf(const std::string &fconf, std::map<SettingKey, SettingValue> &data, bool watch)
+    void parseConf(const std::string &fconf, std::map<KzSettingKey, KzSettingValue> &data, bool watch)
     {
         if(std::filesystem::exists(fconf))
         {
@@ -132,7 +132,7 @@ public:
         }
     }
 
-    void refreshData(const std::map<SettingKey, SettingValue> &cust_data)
+    void refreshData(const std::map<KzSettingKey, KzSettingValue> &cust_data)
     {
         std::lock_guard<std::mutex> lock(m_mutex_data);
         std::lock_guard<std::mutex> lock_notifier(m_mutex_notifier);
@@ -152,21 +152,21 @@ public:
 
     void refreshFile(const std::string &file)
     {
-        std::map<SettingKey, SettingValue> cust_data;
+        std::map<KzSettingKey, KzSettingValue> cust_data;
         parseFile(file, cust_data);
         refreshData(cust_data);
     }
 
     void refreshDirectory(const std::string &dirname)
     {
-        std::map<SettingKey, SettingValue> cust_data;
+        std::map<KzSettingKey, KzSettingValue> cust_data;
         parseDir(dirname, cust_data, true);
         refreshData(cust_data);
     }
 
     void refreshAll()
     {
-        std::map<SettingKey, SettingValue> cust_data;
+        std::map<KzSettingKey, KzSettingValue> cust_data;
         parseConf("/etc/kazoe.conf", cust_data, false);
         parseConf("/var/kazoe.conf", cust_data, true);
         refreshData(cust_data);
@@ -174,14 +174,14 @@ public:
 };
 };
 
-Settings::Settings()
-    : m_ptr(std::make_unique<SettingsPrivate>(this))
+KzSettings::KzSettings()
+    : m_ptr(std::make_unique<KzSettingsPrivate>(this))
 {
     m_ptr->parseConf("/etc/kazoe.conf", m_ptr->m_data, false);
     m_ptr->parseConf("/var/kazoe.conf", m_ptr->m_data, true);
 }
 
-SettingValue Settings::get(const std::string &key, const std::string &category, SettingValue def) const
+KzSettingValue KzSettings::get(const std::string &key, const std::string &category, KzSettingValue def) const
 {
     std::lock_guard<std::mutex> lock(m_ptr->m_mutex_data);
     std::string gkey = key;
@@ -192,7 +192,7 @@ SettingValue Settings::get(const std::string &key, const std::string &category,
         gkey = gkey.substr(gkey.find(']') + 1);
     }
 
-    SettingKey pkey(gcategory, gkey);
+    KzSettingKey pkey(gcategory, gkey);
 
     if(m_ptr->m_data.count(pkey))
     {
@@ -201,11 +201,11 @@ SettingValue Settings::get(const std::string &key, const std::string &category,
     return def;
 }
 
-bool Settings::set(const std::string &key, SettingValue value, const std::string &category)
+bool KzSettings::set(const std::string &key, KzSettingValue value, const std::string &category)
 {
     // Check if variable is writable
     std::lock_guard<std::mutex> lock(m_ptr->m_mutex_data);
-    SettingKey pkey(category, key);
+    KzSettingKey pkey(category, key);
     std::string id;
 
     if(!m_ptr->m_owner.count(pkey))
@@ -229,7 +229,7 @@ bool Settings::set(const std::string &key, SettingValue value, const std::string
     }
 
     // Permission is OK, get old custom variable
-    std::map<SettingKey, SettingValue> cust_data;
+    std::map<KzSettingKey, KzSettingValue> cust_data;
     m_ptr->parseFile("/var/kazoe.conf.d/"+id+".conf", cust_data);
     cust_data[pkey] = value;
     std::string last_category = "";
@@ -248,30 +248,30 @@ bool Settings::set(const std::string &key, SettingValue value, const std::string
     return true;
 }
 
-std::string Settings::id() const
+std::string KzSettings::id() const
 {
     return m_ptr->m_id;
 }
 
-void Settings::setId(const std::string &newid)
+void KzSettings::setId(const std::string &newid)
 {
     m_ptr->m_id = newid;
 }
 
-void Settings::setNotifier(const std::function<void (const std::string &, const std::string &, SettingValue)> &callback)
+void KzSettings::setNotifier(const std::function<void (const std::string &, const std::string &, KzSettingValue)> &callback)
 {
     std::lock_guard<std::mutex> lock(m_ptr->m_mutex_notifier);
     m_ptr->m_notifier.push_back(callback);
     m_ptr->m_watcher.setEnable(true);
 }
 
-std::size_t Settings::size() const
+std::size_t KzSettings::size() const
 {
     std::lock_guard<std::mutex> lock(m_ptr->m_mutex_data);
     return m_ptr->m_data.size();
 }
 
-void Settings::forEach(const std::function<void (const SettingKey &, const SettingValue &)> &callback) const
+void KzSettings::forEach(const std::function<void (const KzSettingKey &, const KzSettingValue &)> &callback) const
 {
     std::lock_guard<std::mutex> lock(m_ptr->m_mutex_data);
     for (const auto& [key, value] : m_ptr->m_data) {
@@ -279,7 +279,7 @@ void Settings::forEach(const std::function<void (const SettingKey &, const Setti
     }
 }
 
-Settings::~Settings()
+KzSettings::~KzSettings()
 {
     m_ptr->m_watcher.setEnable(false);
 }
diff --git a/src/settings.h b/src/kzsettings.h
index 5dfe90b..9f8d35b 100644
--- a/src/settings.h
+++ b/src/kzsettings.h
@@ -1,5 +1,5 @@
-#ifndef KAZOESETTINGS_H
-#define KAZOESETTINGS_H
+#ifndef KZSETTINGS_H
+#define KZSETTINGS_H
 
 #include <functional>
 #include <memory>
@@ -8,15 +8,15 @@
 #include <algorithm>
 
 /** @brief Key type for settings, composed of category and name */
-using SettingKey = std::pair<std::string, std::string>;
+using KzSettingKey = std::pair<std::string, std::string>;
 
 /** @brief Value type that can hold string, int, double or boolean */
-using SettingValue = std::variant<std::string, int, double, bool>;
+using KzSettingValue = std::variant<std::string, int, double, bool>;
 
 
 namespace KaZoe {
 
-class SettingsPrivate;
+class KzSettingsPrivate;
 
 /**
  * @brief Main class for managing KaZoe settings
@@ -24,14 +24,14 @@ class SettingsPrivate;
  * This class provides a thread-safe interface for storing and retrieving
  * configuration settings with support for different value types.
  */
-class Settings
+class KzSettings
 {
 public:
     /** @brief Constructs a new Settings instance */
-    explicit Settings();
+    explicit KzSettings();
 
     /** @brief Virtual destructor */
-    virtual ~Settings();
+    virtual ~KzSettings();
 
     /**
      * @brief Retrieves a setting value
@@ -40,7 +40,7 @@ public:
      * @param def Default value if setting not found (optional)
      * @return The setting value or default if not found
      */
-    SettingValue get(const std::string &key, const std::string &category = "", SettingValue def = SettingValue()) const;
+    KzSettingValue get(const std::string &key, const std::string &category = "", KzSettingValue def = KzSettingValue()) const;
 
     /**
      * @brief Sets a setting value
@@ -49,7 +49,7 @@ public:
      * @param category The setting category (optional)
      * @return true if successful, false otherwise
      */
-    bool set(const std::string &key, SettingValue value, const std::string &category = "");
+    bool set(const std::string &key, KzSettingValue value, const std::string &category = "");
 
     /**
      * @brief Gets the current instance identifier
@@ -67,7 +67,7 @@ public:
      * @brief Sets a callback for setting changes notification
      * @param callback Function to call when settings change
      */
-    void setNotifier(const std::function<void(const std::string&, const std::string&, SettingValue)>& callback);
+    void setNotifier(const std::function<void(const std::string&, const std::string&, KzSettingValue)>& callback);
 
     /**
      * @brief Gets the number of settings
@@ -79,10 +79,10 @@ public:
      * @brief Iterates over all settings in a thread-safe manner
      * @param callback Function called for each key-value pair
      */
-    void forEach(const std::function<void(const SettingKey&, const SettingValue&)>& callback) const;
+    void forEach(const std::function<void(const KzSettingKey&, const KzSettingValue&)>& callback) const;
 
 private:
-    std::unique_ptr<SettingsPrivate> m_ptr; ///< Private implementation pointer
+    std::unique_ptr<KzSettingsPrivate> m_ptr; ///< Private implementation pointer
 };
 
 
@@ -103,7 +103,7 @@ struct settingValueFunctor {
  * @param value Input SettingValue to convert
  * @return std::string containing the converted value
  */
-static inline std::string valueToStr(const SettingValue &value)
+static inline std::string valueToStr(const KzSettingValue &value)
 {
     return std::visit(settingValueFunctor(), value);
 }
@@ -133,7 +133,7 @@ static inline bool is_numeric(const std::string& str) {
  * - "false"/"off" -> boolean false
  * - Other -> string
  */
-static inline SettingValue makeValue(const std::string &value)
+static inline KzSettingValue makeValue(const std::string &value)
 {
     if(value.starts_with('"') || value.starts_with('\''))
     {
@@ -177,4 +177,4 @@ static inline SettingValue makeValue(const std::string &value)
 
 };
 
-#endif // KAZOESETTINGS_H
+#endif // KZSETTINGS_H