Create namespace "event" for event module

include/ls_std/event/Event.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -17,30 +17,36 @@
 
 namespace ls
 {
-  class Event : public ls::Class
+  namespace std
   {
-    public:
-
-      explicit Event(const ls::event_id &_id);
-      ~Event() override = default;
-
-      // additional functionality
-
-      bool addParameter(const ls::event_parameter &_eventParameter);
-      void clearParameterList();
-      ls::event_id getId();
-      ls::event_parameter_list getParameterList();
-      bool removeParameter(const ls::event_parameter_id &_id);
-      void setId(const ls::event_id &_id);
-
-    private:
-
-      ls::event_id id{};
-      ls::event_parameter_list parameterList{};
-
-      void _assignId(const ls::event_id &_id);
-      bool _hasParameter(const ls::event_id &_id);
-  };
+    namespace event
+    {
+      class Event : public ls::Class
+      {
+        public:
+
+          explicit Event(const ls::std::event::event_id &_id);
+          ~Event() override = default;
+
+          // additional functionality
+
+          bool addParameter(const ls::std::event::event_parameter &_eventParameter);
+          void clearParameterList();
+          ls::std::event::event_id getId();
+          ls::std::event::event_parameter_list getParameterList();
+          bool removeParameter(const ls::std::event::event_parameter_id &_id);
+          void setId(const ls::std::event::event_id &_id);
+
+        private:
+
+          ls::std::event::event_id id{};
+          ls::std::event::event_parameter_list parameterList{};
+
+          void _assignId(const ls::std::event::event_id &_id);
+          bool _hasParameter(const ls::std::event::event_id &_id);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/event/EventHandler.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -19,21 +19,27 @@
 
 namespace ls
 {
-  class EventHandler : public ls::Narrator
+  namespace std
   {
-    public:
+    namespace event
+    {
+      class EventHandler : public ls::Narrator
+      {
+        public:
 
-      explicit EventHandler(const ls::event_id& _id);
-      ~EventHandler() override = default;
+          explicit EventHandler(const ls::std::event::event_id &_id);
+          ~EventHandler() override = default;
 
-      ls::event_id getId();
+          ls::std::event::event_id getId();
 
-    private:
+        private:
 
-      ls::event_id id{};
+          ls::std::event::event_id id{};
 
-      void _assignId(const ls::event_id& _id);
-  };
+          void _assignId(const ls::std::event::event_id &_id);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/event/EventManager.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -19,32 +19,38 @@
 
 namespace ls
 {
-  class EventManager : public ls::Class, public ls::IEventSubscriber
+  namespace std
   {
-    public:
+    namespace event
+    {
+      class EventManager : public ls::Class, public ls::std::event::IEventSubscriber
+      {
+        public:
 
-      explicit EventManager();
-      ~EventManager() override = default;
+          explicit EventManager();
+          ~EventManager() override = default;
 
-      // implementation
+          // implementation
 
-      void subscribe(const ls::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener) override;
-      void unsubscribe(const ls::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener) override;
+          void subscribe(const ls::std::event::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener) override;
+          void unsubscribe(const ls::std::event::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener) override;
 
-      // additional functionality
+          // additional functionality
 
-      bool addEventHandler(const ::std::shared_ptr<ls::EventHandler> &_eventHandler);
-      void fire(ls::Event _event);
-      bool hasEventHandler(const ls::event_id &_id);
-      bool removeEventHandler(const ::std::shared_ptr<ls::EventHandler> &_eventHandler);
+          bool addEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler);
+          void fire(ls::std::event::Event _event);
+          bool hasEventHandler(const ls::std::event::event_id &_id);
+          bool removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler);
 
-    private:
+        private:
 
-      ::std::map<ls::event_id, ::std::shared_ptr<ls::EventHandler>> eventHandlers{};
+          ::std::map<ls::std::event::event_id, ::std::shared_ptr<ls::std::event::EventHandler>> eventHandlers{};
 
-      bool _hasEventHandler(const ls::event_id &_id);
-      bool _removeEventHandler(const ::std::shared_ptr<ls::EventHandler> &_eventHandler);
-  };
+          bool _hasEventHandler(const ls::std::event::event_id &_id);
+          bool _removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/event/EventTypes.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -16,11 +16,17 @@
 
 namespace ls
 {
-  using event_id = ::std::string;
-  using event_parameter_id = ::std::string;
-  using event_parameter_value = ::std::string;
-  using event_parameter = ::std::pair<::std::string, ::std::string>;
-  using event_parameter_list = ::std::map<ls::event_parameter_id, ls::event_parameter_value>;
+  namespace std
+  {
+    namespace event
+    {
+      using event_id = ::std::string;
+      using event_parameter_id = ::std::string;
+      using event_parameter_value = ::std::string;
+      using event_parameter = ::std::pair<::std::string, ::std::string>;
+      using event_parameter_list = ::std::map<ls::std::event::event_parameter_id, ls::std::event::event_parameter_value>;
+    }
+  }
 }
 
 #endif

include/ls_std/event/IEventSubscriber.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -16,16 +16,22 @@
 
 namespace ls
 {
-  class IEventSubscriber
+  namespace std
   {
-    public:
+    namespace event
+    {
+      class IEventSubscriber
+      {
+        public:
 
-      IEventSubscriber() = default;
-      ~IEventSubscriber() = default;
+          IEventSubscriber() = default;
+          ~IEventSubscriber() = default;
 
-      virtual void subscribe(const ls::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener) = 0;
-      virtual void unsubscribe(const ls::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener) = 0;
-  };
+          virtual void subscribe(const ls::std::event::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener) = 0;
+          virtual void unsubscribe(const ls::std::event::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener) = 0;
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/event/serialization/SerializableJsonEvent.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-07
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -18,33 +18,39 @@
 
 namespace ls
 {
-  class SerializableJsonEvent : public ls::Class, public ls::ISerializable
+  namespace std
   {
-    public:
+    namespace event
+    {
+      class SerializableJsonEvent : public ls::Class, public ls::ISerializable
+      {
+        public:
 
-      explicit SerializableJsonEvent(const ::std::shared_ptr<ls::Event> &_value);
-      ~SerializableJsonEvent() override = default;
+          explicit SerializableJsonEvent(const ::std::shared_ptr<ls::std::event::Event> &_value);
+          ~SerializableJsonEvent() override = default;
 
-      // implementation
+          // implementation
 
-      ls::byte_field marshal() override;
-      void unmarshal(const ls::byte_field &_data) override;
+          ls::byte_field marshal() override;
+          void unmarshal(const ls::byte_field &_data) override;
 
-      // additional functionality
+          // additional functionality
 
-      ::std::shared_ptr<ls::Event> getValue();
-      void setValue(const ::std::shared_ptr<ls::Event> &_value);
+          ::std::shared_ptr<ls::std::event::Event> getValue();
+          void setValue(const ::std::shared_ptr<ls::std::event::Event> &_value);
 
-    private:
+        private:
 
-      nlohmann::json jsonObject{};
-      ::std::shared_ptr<ls::Event> value{};
+          nlohmann::json jsonObject{};
+          ::std::shared_ptr<ls::std::event::Event> value{};
 
-      void _assignValue(const ::std::shared_ptr<ls::Event> &_value);
-      void _unmarshalParameterList();
-      void _update();
-      void _updateEventParameterList();
-  };
+          void _assignValue(const ::std::shared_ptr<ls::std::event::Event> &_value);
+          void _unmarshalParameterList();
+          void _update();
+          void _updateEventParameterList();
+      };
+    }
+  }
 }
 
 #endif

source/ls_std/event/Event.cpp

@@ -3,19 +3,19 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
 #include <ls_std/event/Event.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::Event::Event(const ls::event_id &_id) : ls::Class("Event")
+ls::std::event::Event::Event(const ls::std::event::event_id &_id) : ls::Class("Event")
 {
   this->_assignId(_id);
 }
 
-bool ls::Event::addParameter(const ls::event_parameter &_eventParameter)
+bool ls::std::event::Event::addParameter(const ls::std::event::event_parameter &_eventParameter)
 {
   bool wasAdded{};
 
@@ -27,32 +27,32 @@ bool ls::Event::addParameter(const ls::event_parameter &_eventParameter)
   return wasAdded;
 }
 
-void ls::Event::clearParameterList()
+void ls::std::event::Event::clearParameterList()
 {
   this->parameterList.clear();
 }
 
-ls::event_id ls::Event::getId()
+ls::std::event::event_id ls::std::event::Event::getId()
 {
   return this->id;
 }
 
-ls::event_parameter_list ls::Event::getParameterList()
+ls::std::event::event_parameter_list ls::std::event::Event::getParameterList()
 {
   return this->parameterList;
 }
 
-bool ls::Event::removeParameter(const ls::event_parameter_id &_id)
+bool ls::std::event::Event::removeParameter(const ls::std::event::event_parameter_id &_id)
 {
   return this->parameterList.erase(_id) == 1;
 }
 
-void ls::Event::setId(const ls::event_id &_id)
+void ls::std::event::Event::setId(const ls::std::event::event_id &_id)
 {
   this->_assignId(_id);
 }
 
-void ls::Event::_assignId(const ls::event_id &_id)
+void ls::std::event::Event::_assignId(const ls::std::event::event_id &_id)
 {
   if (_id.empty())
   {
@@ -62,7 +62,7 @@ void ls::Event::_assignId(const ls::event_id &_id)
   this->id = _id;
 }
 
-bool ls::Event::_hasParameter(const ls::event_id &_id)
+bool ls::std::event::Event::_hasParameter(const ls::std::event::event_id &_id)
 {
   return this->parameterList.find(_id) != this->parameterList.end();
 }

source/ls_std/event/EventHandler.cpp

@@ -3,24 +3,24 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
 #include <ls_std/event/EventHandler.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::EventHandler::EventHandler(const ls::event_id& _id) : ls::Narrator()
+ls::std::event::EventHandler::EventHandler(const ls::std::event::event_id& _id) : ls::Narrator()
 {
   this->_assignId(_id);
 }
 
-ls::event_id ls::EventHandler::getId()
+ls::std::event::event_id ls::std::event::EventHandler::getId()
 {
   return this->id;
 }
 
-void ls::EventHandler::_assignId(const ls::event_id &_id)
+void ls::std::event::EventHandler::_assignId(const ls::std::event::event_id &_id)
 {
   if (_id.empty())
   {

source/ls_std/event/EventManager.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -12,10 +12,10 @@
 #include <ls_std/core/exception/EventNotHandledException.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::EventManager::EventManager() : ls::Class("EventManager")
+ls::std::event::EventManager::EventManager() : ls::Class("EventManager")
 {}
 
-void ls::EventManager::subscribe(const ls::event_id &_id, const std::shared_ptr<ls::IListener> &_listener)
+void ls::std::event::EventManager::subscribe(const ls::std::event::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener)
 {
   if (_id.empty() || _listener == nullptr)
   {
@@ -32,7 +32,7 @@ void ls::EventManager::subscribe(const ls::event_id &_id, const std::shared_ptr<
   }
 }
 
-void ls::EventManager::unsubscribe(const ls::event_id &_id, const std::shared_ptr<ls::IListener> &_listener)
+void ls::std::event::EventManager::unsubscribe(const ls::std::event::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener)
 {
   if (_id.empty() || _listener == nullptr)
   {
@@ -45,7 +45,7 @@ void ls::EventManager::unsubscribe(const ls::event_id &_id, const std::shared_pt
   }
 }
 
-bool ls::EventManager::addEventHandler(const std::shared_ptr<ls::EventHandler> &_eventHandler)
+bool ls::std::event::EventManager::addEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler)
 {
   bool wasAdded{};
 
@@ -56,14 +56,14 @@ bool ls::EventManager::addEventHandler(const std::shared_ptr<ls::EventHandler> &
 
   if (!this->_hasEventHandler(_eventHandler->getId()))
   {
-    std::pair<ls::event_id, std::shared_ptr<ls::EventHandler>> element = std::make_pair(_eventHandler->getId(), _eventHandler);
+    ::std::pair<ls::std::event::event_id, ::std::shared_ptr<ls::std::event::EventHandler>> element = ::std::make_pair(_eventHandler->getId(), _eventHandler);
     wasAdded = this->eventHandlers.insert(element).second;
   }
 
   return wasAdded;
 }
 
-void ls::EventManager::fire(ls::Event _event)
+void ls::std::event::EventManager::fire(ls::std::event::Event _event)
 {
   if (this->_hasEventHandler(_event.getId()))
   {
@@ -75,7 +75,7 @@ void ls::EventManager::fire(ls::Event _event)
   }
 }
 
-bool ls::EventManager::hasEventHandler(const ls::event_id &_id)
+bool ls::std::event::EventManager::hasEventHandler(const ls::std::event::event_id &_id)
 {
   if (_id.empty())
   {
@@ -85,7 +85,7 @@ bool ls::EventManager::hasEventHandler(const ls::event_id &_id)
   return this->_hasEventHandler(_id);
 }
 
-bool ls::EventManager::removeEventHandler(const std::shared_ptr<ls::EventHandler> &_eventHandler)
+bool ls::std::event::EventManager::removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler)
 {
   if (_eventHandler == nullptr)
   {
@@ -95,12 +95,12 @@ bool ls::EventManager::removeEventHandler(const std::shared_ptr<ls::EventHandler
   return this->_removeEventHandler(_eventHandler);
 }
 
-bool ls::EventManager::_hasEventHandler(const ls::event_id &_id)
+bool ls::std::event::EventManager::_hasEventHandler(const ls::std::event::event_id &_id)
 {
   return this->eventHandlers.find(_id) != this->eventHandlers.end();
 }
 
-bool ls::EventManager::_removeEventHandler(const std::shared_ptr<ls::EventHandler> &_eventHandler)
+bool ls::std::event::EventManager::_removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler)
 {
   return this->eventHandlers.erase(_eventHandler->getId()) == 1;
 }

source/ls_std/event/serialization/SerializableJsonEvent.cpp

@@ -3,25 +3,25 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-07
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
 #include "ls_std/event/serialization/SerializableJsonEvent.hpp"
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::SerializableJsonEvent::SerializableJsonEvent(const std::shared_ptr<ls::Event> &_value) : ls::Class("SerializableJsonEvent")
+ls::std::event::SerializableJsonEvent::SerializableJsonEvent(const ::std::shared_ptr<ls::std::event::Event> &_value) : ls::Class("SerializableJsonEvent")
 {
   this->_assignValue(_value);
 }
 
-ls::byte_field ls::SerializableJsonEvent::marshal()
+ls::byte_field ls::std::event::SerializableJsonEvent::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls::SerializableJsonEvent::unmarshal(const ls::byte_field &_data)
+void ls::std::event::SerializableJsonEvent::unmarshal(const ls::byte_field &_data)
 {
   this->jsonObject = nlohmann::json::parse(_data);
 
@@ -29,17 +29,17 @@ void ls::SerializableJsonEvent::unmarshal(const ls::byte_field &_data)
   this->_unmarshalParameterList();
 }
 
-std::shared_ptr<ls::Event> ls::SerializableJsonEvent::getValue()
+std::shared_ptr<ls::std::event::Event> ls::std::event::SerializableJsonEvent::getValue()
 {
   return this->value;
 }
 
-void ls::SerializableJsonEvent::setValue(const std::shared_ptr<ls::Event> &_value)
+void ls::std::event::SerializableJsonEvent::setValue(const ::std::shared_ptr<ls::std::event::Event> &_value)
 {
   this->_assignValue(_value);
 }
 
-void ls::SerializableJsonEvent::_assignValue(const std::shared_ptr<ls::Event> &_value)
+void ls::std::event::SerializableJsonEvent::_assignValue(const ::std::shared_ptr<ls::std::event::Event> &_value)
 {
   if (_value == nullptr)
   {
@@ -49,27 +49,27 @@ void ls::SerializableJsonEvent::_assignValue(const std::shared_ptr<ls::Event> &_
   this->value = _value;
 }
 
-void ls::SerializableJsonEvent::_unmarshalParameterList()
+void ls::std::event::SerializableJsonEvent::_unmarshalParameterList()
 {
   this->value->clearParameterList();
 
   for (const auto &parameterJson : this->jsonObject["parameterList"])
   {
-    ls::event_parameter parameter = {parameterJson.at(0), parameterJson.at(1)};
+    ls::std::event::event_parameter parameter = {parameterJson.at(0), parameterJson.at(1)};
     this->value->addParameter(parameter);
   }
 }
 
-void ls::SerializableJsonEvent::_update()
+void ls::std::event::SerializableJsonEvent::_update()
 {
   this->jsonObject = {{"id", this->value->getId()}};
 
   this->_updateEventParameterList();
 }
 
-void ls::SerializableJsonEvent::_updateEventParameterList()
+void ls::std::event::SerializableJsonEvent::_updateEventParameterList()
 {
-  std::string jsonString{};
+  ::std::string jsonString{};
 
   for (const auto &eventParameter : this->value->getParameterList())
   {

test/cases/event/EventHandlerTest.cpp

@@ -3,13 +3,12 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
 #include <gtest/gtest.h>
 #include <ls_std/ls_std.hpp>
-#include <ls_std_test.hpp>
 
 namespace
 {
@@ -32,7 +31,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::EventHandler eventHandler{""};
+                     ls::std::event::EventHandler eventHandler{""};
                    }
                    catch (const ls::IllegalArgumentException &_exception)
                    {
@@ -43,7 +42,7 @@ namespace
 
   TEST_F(EventHandlerTest, getId)
   {
-    ls::EventHandler eventHandler{"EventId"};
+    ls::std::event::EventHandler eventHandler{"EventId"};
     ASSERT_STREQ("EventId", eventHandler.getId().c_str());
   }
 }

test/cases/event/EventManagerTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -29,7 +29,7 @@ namespace
 
   TEST_F(EventManagerTest, getClassName)
   {
-    ls::EventManager eventManager{};
+    ls::std::event::EventManager eventManager{};
     ASSERT_STREQ("EventManager", eventManager.getClassName().c_str());
   }
 
@@ -38,7 +38,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::EventManager eventManager{};
+                     ls::std::event::EventManager eventManager{};
                      eventManager.subscribe("", std::make_shared<ls_std_test::DailyNewsAgency>());
                    }
                    catch (const ls::IllegalArgumentException &_exception)
@@ -53,7 +53,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::EventManager eventManager{};
+                     ls::std::event::EventManager eventManager{};
                      eventManager.subscribe("TMP_ID", nullptr);
                    }
                    catch (const ls::IllegalArgumentException &_exception)
@@ -68,7 +68,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::EventManager eventManager{};
+                     ls::std::event::EventManager eventManager{};
                      eventManager.subscribe("TMP_DIR", std::make_shared<ls_std_test::DailyNewsAgency>());
                    }
                    catch (const ls::EventNotSubscribedException &_exception)
@@ -83,7 +83,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::EventManager eventManager{};
+                     ls::std::event::EventManager eventManager{};
                      eventManager.unsubscribe("", std::make_shared<ls_std_test::DailyNewsAgency>());
                    }
                    catch (const ls::IllegalArgumentException &_exception)
@@ -98,7 +98,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::EventManager eventManager{};
+                     ls::std::event::EventManager eventManager{};
                      eventManager.unsubscribe("TMP_ID", nullptr);
                    }
                    catch (const ls::IllegalArgumentException &_exception)
@@ -110,15 +110,15 @@ namespace
 
   TEST_F(EventManagerTest, addEventHandler)
   {
-    ls::EventManager eventManager{};
-    ASSERT_TRUE(eventManager.addEventHandler(std::make_shared<ls::EventHandler>("TMP_ID")));
+    ls::std::event::EventManager eventManager{};
+    ASSERT_TRUE(eventManager.addEventHandler(std::make_shared<ls::std::event::EventHandler>("TMP_ID")));
   }
 
   TEST_F(EventManagerTest, addEventHandler_event_handler_already_exists)
   {
-    ls::EventManager eventManager{};
-    ASSERT_TRUE(eventManager.addEventHandler(std::make_shared<ls::EventHandler>("TMP_ID")));
-    ASSERT_FALSE(eventManager.addEventHandler(std::make_shared<ls::EventHandler>("TMP_ID")));
+    ls::std::event::EventManager eventManager{};
+    ASSERT_TRUE(eventManager.addEventHandler(std::make_shared<ls::std::event::EventHandler>("TMP_ID")));
+    ASSERT_FALSE(eventManager.addEventHandler(std::make_shared<ls::std::event::EventHandler>("TMP_ID")));
   }
 
   TEST_F(EventManagerTest, addEventHandler_no_reference)
@@ -126,7 +126,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::EventManager eventManager{};
+                     ls::std::event::EventManager eventManager{};
                      eventManager.addEventHandler(nullptr);
                    }
                    catch (const ls::IllegalArgumentException &_exception)
@@ -141,8 +141,8 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::EventManager eventManager{};
-                     eventManager.fire(ls::Event{"TMP_ID"});
+                     ls::std::event::EventManager eventManager{};
+                     eventManager.fire(ls::std::event::Event{"TMP_ID"});
                    }
                    catch (const ls::EventNotHandledException &_exception)
                    {
@@ -153,14 +153,14 @@ namespace
 
   TEST_F(EventManagerTest, hasEventHandler)
   {
-    ls::EventManager eventManager{};
-    eventManager.addEventHandler(std::make_shared<ls::EventHandler>("TMP_ID"));
+    ls::std::event::EventManager eventManager{};
+    eventManager.addEventHandler(std::make_shared<ls::std::event::EventHandler>("TMP_ID"));
     ASSERT_TRUE(eventManager.hasEventHandler("TMP_ID"));
   }
 
   TEST_F(EventManagerTest, hasEventHandler_no_event_handler_available)
   {
-    ls::EventManager eventManager{};
+    ls::std::event::EventManager eventManager{};
     ASSERT_FALSE(eventManager.hasEventHandler("TMP_ID"));
   }
 
@@ -169,7 +169,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::EventManager eventManager{};
+                     ls::std::event::EventManager eventManager{};
                      eventManager.hasEventHandler("");
                    }
                    catch (const ls::IllegalArgumentException &_exception)
@@ -181,8 +181,8 @@ namespace
 
   TEST_F(EventManagerTest, removeEventHandler)
   {
-    ls::EventManager eventManager{};
-    std::shared_ptr<ls::EventHandler> eventHandler = std::make_shared<ls::EventHandler>("TMP_ID");
+    ls::std::event::EventManager eventManager{};
+    std::shared_ptr<ls::std::event::EventHandler> eventHandler = std::make_shared<ls::std::event::EventHandler>("TMP_ID");
     eventManager.addEventHandler(eventHandler);
 
     ASSERT_TRUE(eventManager.removeEventHandler(eventHandler));
@@ -190,8 +190,8 @@ namespace
 
   TEST_F(EventManagerTest, removeEventHandler_no_event_handler_available)
   {
-    ls::EventManager eventManager{};
-    ASSERT_FALSE(eventManager.removeEventHandler(std::make_shared<ls::EventHandler>("TMP_ID")));
+    ls::std::event::EventManager eventManager{};
+    ASSERT_FALSE(eventManager.removeEventHandler(std::make_shared<ls::std::event::EventHandler>("TMP_ID")));
   }
 
   TEST_F(EventManagerTest, removeEventHandler_no_reference)
@@ -199,7 +199,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::EventManager eventManager{};
+                     ls::std::event::EventManager eventManager{};
                      eventManager.removeEventHandler(nullptr);
                    }
                    catch (const ls::IllegalArgumentException &_exception)
@@ -212,17 +212,17 @@ namespace
   TEST_F(EventManagerTest, production_example)
   {
     std::string news, expectedNews{};
-    ls::event_id seriousNewsEventId = ls_std_test::SeriousNewsEvent{""}.getId();
-    ls::event_id gossipNewsEventId = ls_std_test::GossipNewsEvent{""}.getId();
+    ls::std::event::event_id seriousNewsEventId = ls_std_test::SeriousNewsEvent{""}.getId();
+    ls::std::event::event_id gossipNewsEventId = ls_std_test::GossipNewsEvent{""}.getId();
 
     // create event handler
 
-    std::shared_ptr<ls::EventHandler> seriousNewsEventHandler = std::make_shared<ls::EventHandler>(seriousNewsEventId);   // event id
-    std::shared_ptr<ls::EventHandler> gossipNewsEventHandler = std::make_shared<ls::EventHandler>(gossipNewsEventId);     // event id
+    std::shared_ptr<ls::std::event::EventHandler> seriousNewsEventHandler = std::make_shared<ls::std::event::EventHandler>(seriousNewsEventId);   // event id
+    std::shared_ptr<ls::std::event::EventHandler> gossipNewsEventHandler = std::make_shared<ls::std::event::EventHandler>(gossipNewsEventId);     // event id
 
     // create and fill event manager with handler
 
-    std::shared_ptr<ls::EventManager> eventManager = std::make_shared<ls::EventManager>();
+    std::shared_ptr<ls::std::event::EventManager> eventManager = std::make_shared<ls::std::event::EventManager>();
     eventManager->addEventHandler(seriousNewsEventHandler);
     eventManager->addEventHandler(gossipNewsEventHandler);
 

test/cases/event/EventTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -30,7 +30,7 @@ namespace
 
   TEST_F(EventTest, getClassName)
   {
-    ls::Event event{"TMP_ID"};
+    ls::std::event::Event event{"TMP_ID"};
     ASSERT_STREQ("Event", event.getClassName().c_str());
   }
 
@@ -39,7 +39,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::Event event{""};
+                     ls::std::event::Event event{""};
                    }
                    catch (const ls::IllegalArgumentException &_exception)
                    {
@@ -50,27 +50,27 @@ namespace
 
   TEST_F(EventTest, addParameter)
   {
-    ls::Event event{"TMP_ID"};
+    ls::std::event::Event event{"TMP_ID"};
     ASSERT_TRUE(event.getParameterList().empty());
 
-    ASSERT_TRUE(event.addParameter(ls::event_parameter("key", "yes")));
-    ASSERT_TRUE(event.addParameter(ls::event_parameter("facing_door", "yes")));
+    ASSERT_TRUE(event.addParameter(ls::std::event::event_parameter("key", "yes")));
+    ASSERT_TRUE(event.addParameter(ls::std::event::event_parameter("facing_door", "yes")));
   }
 
   TEST_F(EventTest, addParameter_element_already_exists)
   {
-    ls::Event event{"TMP_ID"};
+    ls::std::event::Event event{"TMP_ID"};
     ASSERT_TRUE(event.getParameterList().empty());
 
-    ASSERT_TRUE(event.addParameter(ls::event_parameter("key", "yes")));
-    ASSERT_FALSE(event.addParameter(ls::event_parameter("key", "yes")));
+    ASSERT_TRUE(event.addParameter(ls::std::event::event_parameter("key", "yes")));
+    ASSERT_FALSE(event.addParameter(ls::std::event::event_parameter("key", "yes")));
   }
 
   TEST_F(EventTest, clearParameterList)
   {
-    ls::Event event{"OPEN_DOOR_EVENT"};
-    event.addParameter(ls::event_parameter("key", "yes"));
-    event.addParameter(ls::event_parameter("facing_door", "yes"));
+    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
+    event.addParameter(ls::std::event::event_parameter("key", "yes"));
+    event.addParameter(ls::std::event::event_parameter("facing_door", "yes"));
     ASSERT_EQ(2, event.getParameterList().size());
 
     event.clearParameterList();
@@ -80,23 +80,23 @@ namespace
 
   TEST_F(EventTest, getId)
   {
-    ls::Event event{"OPEN_DOOR_EVENT"};
+    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
     ASSERT_STREQ("OPEN_DOOR_EVENT", event.getId().c_str());
   }
 
   TEST_F(EventTest, getParameterList)
   {
-    ls::Event event{"OPEN_DOOR_EVENT"};
+    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
     ASSERT_TRUE(event.getParameterList().empty());
   }
 
   TEST_F(EventTest, removeParameter)
   {
-    ls::Event event{"OPEN_DOOR_EVENT"};
+    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
     ASSERT_TRUE(event.getParameterList().empty());
 
-    event.addParameter(ls::event_parameter("key", "yes"));
-    event.addParameter(ls::event_parameter("facing_door", "yes"));
+    event.addParameter(ls::std::event::event_parameter("key", "yes"));
+    event.addParameter(ls::std::event::event_parameter("facing_door", "yes"));
 
     ASSERT_TRUE(event.removeParameter("key"));
     ASSERT_TRUE(event.removeParameter("facing_door"));
@@ -104,7 +104,7 @@ namespace
 
   TEST_F(EventTest, removeParameter_elenent_does_not_exist)
   {
-    ls::Event event{"OPEN_DOOR_EVENT"};
+    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
 
     ASSERT_FALSE(event.removeParameter("key"));
     ASSERT_FALSE(event.removeParameter("facing_door"));
@@ -112,7 +112,7 @@ namespace
 
   TEST_F(EventTest, setId)
   {
-    ls::Event event{"OPEN_DOOR_EVENT"};
+    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
     ASSERT_STREQ("OPEN_DOOR_EVENT", event.getId().c_str());
 
     event.setId("ANOTHER_EVENT");
@@ -124,7 +124,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::Event event{"TMP_ID"};
+                     ls::std::event::Event event{"TMP_ID"};
                      event.setId("");
                    }
                    catch (const ls::IllegalArgumentException &_exception)

test/cases/event/serialization/SerializableJsonEventTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-20
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -31,7 +31,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::SerializableJsonEvent serializable{nullptr};
+                     ls::std::event::SerializableJsonEvent serializable{nullptr};
                    }
                    catch (const ls::IllegalArgumentException &_exception)
                    {
@@ -42,11 +42,11 @@ namespace
 
   TEST_F(SerializableJsonEventTest, marshal)
   {
-    ls::Event event{"OPEN_DOOR_EVENT"};
-    event.addParameter(ls::event_parameter{"key_available", "true"});
-    event.addParameter(ls::event_parameter{"door_id", "16675"});
+    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
+    event.addParameter(ls::std::event::event_parameter{"key_available", "true"});
+    event.addParameter(ls::std::event::event_parameter{"door_id", "16675"});
 
-    ls::SerializableJsonEvent serializable{std::make_shared<ls::Event>(event)};
+    ls::std::event::SerializableJsonEvent serializable{std::make_shared<ls::std::event::Event>(event)};
 
     ls::byte_field data = serializable.marshal();
     ASSERT_FALSE(data.empty());
@@ -56,13 +56,13 @@ namespace
 
   TEST_F(SerializableJsonEventTest, unmarshal)
   {
-    ls::Event event{"TMP_EVENT"};
-    ls::SerializableJsonEvent serializable{std::make_shared<ls::Event>(event)};
+    ls::std::event::Event event{"TMP_EVENT"};
+    ls::std::event::SerializableJsonEvent serializable{std::make_shared<ls::std::event::Event>(event)};
     std::string jsonString = R"({"id":"OPEN_DOOR_EVENT","parameterList":{"door_id":["door_id","16675"],"key_available":["key_available","true"]}})";
 
     serializable.unmarshal(jsonString);
     ASSERT_STREQ("OPEN_DOOR_EVENT", serializable.getValue()->getId().c_str());
-    ls::event_parameter_list parameterList = serializable.getValue()->getParameterList();
+    ls::std::event::event_parameter_list parameterList = serializable.getValue()->getParameterList();
 
     ASSERT_FALSE(parameterList.empty());
     ASSERT_EQ(2, parameterList.size());
@@ -72,8 +72,8 @@ namespace
 
   TEST_F(SerializableJsonEventTest, setValue_parameter_not_set)
   {
-    ls::Event event{"TMP_EVENT"};
-    ls::SerializableJsonEvent serializable{std::make_shared<ls::Event>(event)};
+    ls::std::event::Event event{"TMP_EVENT"};
+    ls::std::event::SerializableJsonEvent serializable{std::make_shared<ls::std::event::Event>(event)};
 
     EXPECT_THROW({
                    try

test/classes/event/DailyNewsAgency.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -14,7 +14,7 @@ ls_std_test::DailyNewsAgency::DailyNewsAgency() : ls_std_test::NewsAgency("Daily
 
 void ls_std_test::DailyNewsAgency::listen(const ls::Class &_info)
 {
-  ls::Event event = dynamic_cast<const ls::Event &>(_info);
+  ls::std::event::Event event = dynamic_cast<const ls::std::event::Event &>(_info);
 
   if (event.getId() == "SeriousNewsEvent")
   {

test/classes/event/GossipNewsAgency.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -14,7 +14,7 @@ ls_std_test::GossipNewsAgency::GossipNewsAgency() : ls_std_test::NewsAgency("Gos
 
 void ls_std_test::GossipNewsAgency::listen(const ls::Class &_info)
 {
-  ls::Event event = dynamic_cast<const ls::Event &>(_info);
+  ls::std::event::Event event = dynamic_cast<const ls::std::event::Event &>(_info);
 
   if (event.getId() == "SeriousNewsEvent")
   {

test/classes/event/GossipNewsEvent.cpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
 #include "GossipNewsEvent.hpp"
 
-ls_std_test::GossipNewsEvent::GossipNewsEvent(const std::string &_news) : ls::Event("GossipNewsEvent")
+ls_std_test::GossipNewsEvent::GossipNewsEvent(const std::string &_news) : ls::std::event::Event("GossipNewsEvent")
 {
-  ls::event_parameter newsParameter = std::make_pair("news", _news);
+  ls::std::event::event_parameter newsParameter = std::make_pair("news", _news);
   this->addParameter(newsParameter);
 }

test/classes/event/GossipNewsEvent.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -15,7 +15,7 @@
 
 namespace ls_std_test
 {
-  class GossipNewsEvent : public ls::Event
+  class GossipNewsEvent : public ls::std::event::Event
   {
     public:
 

test/classes/event/SeriousNewsEvent.cpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
 #include "SeriousNewsEvent.hpp"
 
-ls_std_test::SeriousNewsEvent::SeriousNewsEvent(const std::string &_news) : ls::Event("SeriousNewsEvent")
+ls_std_test::SeriousNewsEvent::SeriousNewsEvent(const std::string &_news) : ls::std::event::Event("SeriousNewsEvent")
 {
-  ls::event_parameter newsParameter = std::make_pair("news", _news);
+  ls::std::event::event_parameter newsParameter = std::make_pair("news", _news);
   this->addParameter(newsParameter);
 }

test/classes/event/SeriousNewsEvent.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-05
+ * Changed:         2022-05-08
  *
  * */
 
@@ -15,7 +15,7 @@
 
 namespace ls_std_test
 {
-  class SeriousNewsEvent : public ls::Event
+  class SeriousNewsEvent : public ls::std::event::Event
   {
     public: