3 files changed, 24 insertions, 33 deletions

diff --git a/src/core/module/Event.cpp b/src/core/module/Event.cpp
index a1fd2fdc..cbffb096 100644
--- a/src/core/module/Event.cpp
+++ b/src/core/module/Event.cpp
@@ -34,20 +34,17 @@ namespace GpgFrontend::Module {
 
 class Event::Impl {
  public:
-  Impl(QString event_id, std::initializer_list<ParameterInitializer> params,
-       EventCallback callback)
+  Impl(QString event_id, Params params, EventCallback callback)
       : event_identifier_(std::move(event_id)),
         callback_(std::move(callback)),
         callback_thread_(QThread::currentThread()) {
-    for (const auto& param : params) {
-      AddParameter(param);
-    }
+    data_.insert(params);
   }
 
   auto operator[](const QString& key) const -> std::optional<ParameterValue> {
     auto it_data = data_.find(key);
     if (it_data != data_.end()) {
-      return it_data->second;
+      return it_data.value();
     }
     return std::nullopt;
   }
@@ -81,7 +78,7 @@ class Event::Impl {
   }
 
   void ExecuteCallback(ListenerIdentifier listener_id,
-                       const DataObjectPtr& data_object) {
+                       const Params& data_object) {
     if (callback_) {
       if (!QMetaObject::invokeMethod(
               callback_thread_,
@@ -107,7 +104,7 @@ class Event::Impl {
     GFModuleEventParam* p_param;
 
     int index = 0;
-    for (const auto& data : data_) {
+    for (const auto& data : data_.asKeyValueRange()) {
       p_param = static_cast<GFModuleEventParam*>(
           SecureMalloc(sizeof(GFModuleEventParam)));
       if (index++ == 0) event->params = p_param;
@@ -126,14 +123,12 @@ class Event::Impl {
  private:
   EventIdentifier event_identifier_;
   EventTriggerIdentifier trigger_uuid_ = QUuid::createUuid().toString();
-  std::map<QString, QString> data_;
+  QMap<QString, QString> data_;
   EventCallback callback_;
   QThread* callback_thread_ = nullptr;  ///<
 };
 
-Event::Event(const QString& event_id,
-             std::initializer_list<ParameterInitializer> params,
-             EventCallback callback)
+Event::Event(const QString& event_id, Params params, EventCallback callback)
     : p_(SecureCreateUniqueObject<Impl>(event_id, params,
                                         std::move(callback))) {}
 
@@ -165,8 +160,8 @@ void Event::AddParameter(const QString& key, const QString& value) {
   p_->AddParameter(key, value);
 }
 
-void Event::ExecuteCallback(ListenerIdentifier l_id, DataObjectPtr d_o) {
-  p_->ExecuteCallback(std::move(l_id), d_o);
+void Event::ExecuteCallback(ListenerIdentifier l_id, const Params& param) {
+  p_->ExecuteCallback(std::move(l_id), param);
 }
 
 auto Event::ToModuleEvent() -> GFModuleEvent* { return p_->ToModuleEvent(); }
diff --git a/src/core/module/Event.h b/src/core/module/Event.h
index cb41c125..64c35592 100644
--- a/src/core/module/Event.h
+++ b/src/core/module/Event.h
@@ -50,16 +50,16 @@ class GPGFRONTEND_CORE_EXPORT Event {
   using ParameterValue = std::any;
   using EventIdentifier = QString;
   using ListenerIdentifier = QString;
+  using Params = QMap<QString, QString>;
+
   using EventCallback =
-      std::function<void(EventIdentifier, ListenerIdentifier, DataObjectPtr)>;
+      std::function<void(EventIdentifier, ListenerIdentifier, Params)>;
   struct ParameterInitializer {
     QString key;
     QString value;
   };
 
-  explicit Event(const QString&,
-                 std::initializer_list<ParameterInitializer> = {},
-                 EventCallback = nullptr);
+  explicit Event(const QString&, Params = {}, EventCallback = nullptr);
 
   ~Event();
 
@@ -81,7 +81,7 @@ class GPGFRONTEND_CORE_EXPORT Event {
 
   void AddParameter(const QString& key, const QString& value);
 
-  void ExecuteCallback(ListenerIdentifier, DataObjectPtr);
+  void ExecuteCallback(ListenerIdentifier, const Params&);
 
   auto ToModuleEvent() -> GFModuleEvent*;
 
@@ -91,10 +91,8 @@ class GPGFRONTEND_CORE_EXPORT Event {
 };
 
 template <typename... Args>
-auto MakeEvent(const EventIdentifier& event_id, Args&&... args,
+auto MakeEvent(const EventIdentifier& event_id, const Event::Params& params,
                Event::EventCallback e_cb) -> EventReference {
-  std::initializer_list<Event::ParameterInitializer> params = {
-      Event::ParameterInitializer{std::forward<Args>(args)}...};
   return GpgFrontend::SecureCreateSharedObject<Event>(event_id, params, e_cb);
 }
 
diff --git a/src/core/module/ModuleManager.h b/src/core/module/ModuleManager.h
index ea2d88cb..08abbd27 100644
--- a/src/core/module/ModuleManager.h
+++ b/src/core/module/ModuleManager.h
@@ -28,7 +28,6 @@
 
 #pragma once
 
-#include <mutex>
 #include <vector>
 
 #include "core/function/SecureMemoryAllocator.h"
@@ -123,10 +122,10 @@ void RegisterAndActivateModule(Args&&... args) {
 }
 
 template <typename... Args>
-void TriggerEvent(const EventIdentifier& event_id, Args&&... args,
+void TriggerEvent(const EventIdentifier& event_id,
+                  const Event::Params& params = {},
                   Event::EventCallback e_cb = nullptr) {
-  ModuleManager::GetInstance().TriggerEvent(
-      std::move(MakeEvent(event_id, std::forward<Args>(args)..., e_cb)));
+  ModuleManager::GetInstance().TriggerEvent(MakeEvent(event_id, params, e_cb));
 }
 
 /**
@@ -166,13 +165,12 @@ auto GPGFRONTEND_CORE_EXPORT ListenRTPublishEvent(QObject*, Namespace, Key,
  * @param key
  * @return std::vector<Key>
  */
-auto GPGFRONTEND_CORE_EXPORT ListRTChildKeys(const QString& namespace_,
-                                             const QString& key)
-    -> std::vector<Key>;
+auto GPGFRONTEND_CORE_EXPORT ListRTChildKeys(
+    const QString& namespace_, const QString& key) -> std::vector<Key>;
 
 template <typename T>
-auto RetrieveRTValueTyped(const QString& namespace_, const QString& key)
-    -> std::optional<T> {
+auto RetrieveRTValueTyped(const QString& namespace_,
+                          const QString& key) -> std::optional<T> {
   auto any_value =
       ModuleManager::GetInstance().RetrieveRTValue(namespace_, key);
   if (any_value && any_value->type() == typeid(T)) {
@@ -183,8 +181,8 @@ auto RetrieveRTValueTyped(const QString& namespace_, const QString& key)
 
 template <typename T>
 auto RetrieveRTValueTypedOrDefault(const QString& namespace_,
-                                   const QString& key, const T& defaultValue)
-    -> T {
+                                   const QString& key,
+                                   const T& defaultValue) -> T {
   auto any_value =
       ModuleManager::GetInstance().RetrieveRTValue(namespace_, key);
   if (any_value && any_value->type() == typeid(T)) {