change listeners to functions

* partial commit
* tests are not complete

CMakeLists.txt

@@ -154,9 +154,7 @@ set(SOURCE_FILES_ENCODING
 set(SOURCE_FILES_EVENT
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/serialization/SerializableJsonEvent.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/Event.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/EventHandler.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/EventManager.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/Narrator.cpp)
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/EventManager.cpp)
 
 set(SOURCE_FILES_IO
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KvDocument.cpp
@@ -218,10 +216,8 @@ if (${LS_STD_BUILD_WITH_TESTS})
 
     set(TEST_FILES_EVENT
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/event/serialization/SerializableJsonEventTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/event/EventHandlerTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/event/EventManagerTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/event/EventTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/event/NarratorTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/Colour.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/DailyNewsAgency.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/GossipNewsAgency.cpp

include/ls_std/core/exception/IllegalArgumentException.hpp

@@ -19,6 +19,7 @@ namespace ls::std::core
     public:
 
       IllegalArgumentException() = default;
+      //ToDo: possibility to pass argument name
 
       [[nodiscard]] const char *what() const noexcept override
       {

include/ls_std/core/interface/IEventSubscriber.hpp

@@ -1,31 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2022-07-02
- *
- * */
-
-#ifndef LS_STD_I_EVENT_SUBSCRIBER_HPP
-#define LS_STD_I_EVENT_SUBSCRIBER_HPP
-
-#include <ls_std/core/types/EventTypes.hpp>
-#include <memory>
-#include "IListener.hpp"
-
-namespace ls::std::core::interface_type
-{
-  class IEventSubscriber
-  {
-    public:
-
-      IEventSubscriber() = default;
-      ~IEventSubscriber() = default;
-
-      virtual void subscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener) = 0;
-      virtual void unsubscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener) = 0;
-  };
-}
-
-#endif

include/ls_std/core/interface/IListener.hpp

@@ -1,28 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-14
- * Changed:         2022-07-02
- *
- * */
-
-#ifndef LS_STD_I_LISTENER_HPP
-#define LS_STD_I_LISTENER_HPP
-
-#include <ls_std/core/Class.hpp>
-
-namespace ls::std::core::interface_type
-{
-  class IListener
-  {
-    public:
-
-      IListener() = default;
-      ~IListener() = default;
-
-      virtual void listen(const ls::std::core::Class &_info) = 0;
-  };
-}
-
-#endif

include/ls_std/event/Event.hpp

@@ -13,34 +13,36 @@
 #include <ls_std/core/Class.hpp>
 #include <ls_std/core/interface/ISerializable.hpp>
 #include <memory>
-#include <ls_std/core/types/EventTypes.hpp>
+#include <ls_std/event/types/EventTypes.hpp>
 #include <ls_std/os/dynamic_goal.hpp>
 
+using namespace ls::std::event::type;
+
 namespace ls::std::event
 {
   class LS_STD_DYNAMIC_GOAL Event : public ls::std::core::Class
   {
     public:
 
-      explicit Event(const ls::std::core::type::event_id &_id);
+      explicit Event(const event_id &_id);
       ~Event() override = default;
 
       // additional functionality
 
-      bool addParameter(const ls::std::core::type::event_parameter &_eventParameter);
+      bool addParameter(const event_parameter &_eventParameter);
       void clearParameterList();
-      ls::std::core::type::event_id getId();
-      ls::std::core::type::event_parameter_list getParameterList();
-      bool removeParameter(const ls::std::core::type::event_parameter_id &_id);
-      void setId(const ls::std::core::type::event_id &_id);
+      event_id getId();
+      event_parameter_list getParameterList();
+      bool removeParameter(const event_parameter_id &_id);
+      void setId(const event_id &_id);
 
     private:
 
-      ls::std::core::type::event_id id{};
-      ls::std::core::type::event_parameter_list parameterList{};
+      event_id id{};
+      event_parameter_list parameterList{};
 
-      void _assignId(const ls::std::core::type::event_id &_id);
-      bool _hasParameter(const ls::std::core::type::event_id &_id);
+      void _assignId(const event_id &_id);
+      bool _hasParameter(const event_id &_id);
   };
 }
 

include/ls_std/event/EventHandler.hpp

@@ -1,40 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2022-07-03
- *
- * */
-
-#ifndef LS_STD_EVENT_HANDLER_HPP
-#define LS_STD_EVENT_HANDLER_HPP
-
-#include <ls_std/core/Class.hpp>
-#include <list>
-#include <memory>
-#include <ls_std/core/interface/IListener.hpp>
-#include <ls_std/os/dynamic_goal.hpp>
-#include "Event.hpp"
-#include "Narrator.hpp"
-
-namespace ls::std::event
-{
-  class LS_STD_DYNAMIC_GOAL EventHandler : public ls::std::event::Narrator
-  {
-    public:
-
-      explicit EventHandler(const ls::std::core::type::event_id &_id);
-      ~EventHandler() override = default;
-
-      ls::std::core::type::event_id getId();
-
-    private:
-
-      ls::std::core::type::event_id id{};
-
-      void _assignId(const ls::std::core::type::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-07-03
+ * Changed:         2023-01-06
  *
  * */
 
@@ -12,15 +12,18 @@
 
 #include <ls_std/core/Class.hpp>
 #include <map>
-#include <ls_std/core/types/EventTypes.hpp>
+#include <list>
+#include <ls_std/event/types/EventTypes.hpp>
 #include <memory>
-#include "EventHandler.hpp"
-#include <ls_std/core/interface/IEventSubscriber.hpp>
+#include <ls_std/event/interface/IEventManager.hpp>
 #include <ls_std/os/dynamic_goal.hpp>
+#include <functional>
+
+using namespace ls::std::event;
 
 namespace ls::std::event
 {
-  class LS_STD_DYNAMIC_GOAL EventManager : public ls::std::core::Class, public ls::std::core::interface_type::IEventSubscriber
+  class LS_STD_DYNAMIC_GOAL EventManager : public ls::std::core::Class, public ls::std::event::interface_type::IEventManager
   {
     public:
 
@@ -29,22 +32,16 @@ namespace ls::std::event
 
       // implementation
 
-      void subscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener) override;
-      void unsubscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener) override;
+      void subscribe(const ls::std::event::type::event_id &_id, const ::std::function<void(ls::std::event::Event)>& _listener) override;
+      void unsubscribe(const ls::std::event::type::event_id &_id, const ::std::function<void(ls::std::event::Event)>& _listener) override;
 
       // additional functionality
 
-      bool addEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler);
       void fire(ls::std::event::Event _event);
-      bool hasEventHandler(const ls::std::core::type::event_id &_id);
-      bool removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler);
 
     private:
 
-      ::std::map<ls::std::core::type::event_id, ::std::shared_ptr<ls::std::event::EventHandler>> eventHandlers{};
-
-      bool _hasEventHandler(const ls::std::core::type::event_id &_id);
-      bool _removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler);
+      ::std::map<ls::std::event::type::event_id, ::std::list<::std::function<void(Event)>>> eventHandler {};
   };
 }
 

include/ls_std/event/Narrator.hpp

@@ -1,40 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-14
- * Changed:         2022-07-03
- *
- * */
-
-#ifndef LS_STD_NARRATOR_HPP
-#define LS_STD_NARRATOR_HPP
-
-#include <ls_std/core/Class.hpp>
-#include <ls_std/core/interface/IListener.hpp>
-#include <ls_std/os/dynamic_goal.hpp>
-#include <list>
-#include <memory>
-
-namespace ls::std::event
-{
-  class LS_STD_DYNAMIC_GOAL Narrator : public ls::std::core::Class
-  {
-    public:
-
-      Narrator();
-      ~Narrator() override = default;
-
-      bool addListener(const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener);
-      void clear();
-      ::std::list<::std::shared_ptr<ls::std::core::interface_type::IListener>> getListeners();
-      bool removeListener(const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener);
-      void tell(const ls::std::core::Class &_info);
-
-    private:
-
-      ::std::list<::std::shared_ptr<ls::std::core::interface_type::IListener>> listeners{};
-  };
-}
-
-#endif

include/ls_std/event/interface/IEventManager.hpp

@@ -0,0 +1,31 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-11-27
+ * Changed:         2023-01-06
+ *
+ * */
+
+#ifndef LS_STD_I_EVENT_SUBSCRIBER_HPP
+#define LS_STD_I_EVENT_SUBSCRIBER_HPP
+
+#include <ls_std/event/types/EventTypes.hpp>
+#include <ls_std/event/Event.hpp>
+#include <memory>
+
+namespace ls::std::event::interface_type
+{
+  class IEventManager
+  {
+    public:
+
+      IEventManager() = default;
+      ~IEventManager() = default;
+
+      virtual void subscribe(const ls::std::event::type::event_id &_id, const ::std::function<void(ls::std::event::Event)>& listener) = 0;
+      virtual void unsubscribe(const ls::std::event::type::event_id &_id, const ::std::function<void(ls::std::event::Event)>& listener) = 0;
+  };
+}
+
+#endif

include/ls_std/core/types/EventTypes.hpp → include/ls_std/event/types/EventTypes.hpp

@@ -14,13 +14,13 @@
 #include <vector>
 #include <map>
 
-namespace ls::std::core::type
+namespace ls::std::event::type
 {
   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::core::type::event_parameter_id, ls::std::core::type::event_parameter_value>;
+  using event_parameter_list = ::std::map<event_parameter_id, event_parameter_value>;
 }
 
 #endif

include/ls_std/ls_std_core.hpp

@@ -21,14 +21,13 @@
 
 #include <ls_std/core/interface/IBoxing.hpp>
 #include <ls_std/core/interface/IEncoding.hpp>
-#include <ls_std/core/interface/IEventSubscriber.hpp>
-#include <ls_std/core/interface/IListener.hpp>
+#include <ls_std/event/interface/IEventManager.hpp>
 #include <ls_std/core/interface/IReader.hpp>
 #include <ls_std/core/interface/ISerializable.hpp>
 #include <ls_std/core/interface/IStorable.hpp>
 #include <ls_std/core/interface/IWriter.hpp>
 
-#include <ls_std/core/types/EventTypes.hpp>
+#include <ls_std/event/types/EventTypes.hpp>
 #include <ls_std/core/types/KvTypes.hpp>
 #include <ls_std/core/types/Types.hpp>
 

include/ls_std/ls_std_event.hpp

@@ -12,8 +12,6 @@
 
 #include <ls_std/event/serialization/SerializableJsonEvent.hpp>
 #include <ls_std/event/Event.hpp>
-#include <ls_std/event/EventHandler.hpp>
 #include <ls_std/event/EventManager.hpp>
-#include <ls_std/event/Narrator.hpp>
 
 #endif

source/ls_std/event/Event.cpp

@@ -10,12 +10,12 @@
 #include <ls_std/event/Event.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::event::Event::Event(const ls::std::core::type::event_id &_id) : ls::std::core::Class("Event")
+ls::std::event::Event::Event(const ls::std::event::type::event_id &_id) : ls::std::core::Class("Event")
 {
   this->_assignId(_id);
 }
 
-bool ls::std::event::Event::addParameter(const ls::std::core::type::event_parameter &_eventParameter)
+bool ls::std::event::Event::addParameter(const ls::std::event::type::event_parameter &_eventParameter)
 {
   bool wasAdded{};
 
@@ -32,27 +32,27 @@ void ls::std::event::Event::clearParameterList()
   this->parameterList.clear();
 }
 
-ls::std::core::type::event_id ls::std::event::Event::getId()
+ls::std::event::type::event_id ls::std::event::Event::getId()
 {
   return this->id;
 }
 
-ls::std::core::type::event_parameter_list ls::std::event::Event::getParameterList()
+ls::std::event::type::event_parameter_list ls::std::event::Event::getParameterList()
 {
   return this->parameterList;
 }
 
-bool ls::std::event::Event::removeParameter(const ls::std::core::type::event_parameter_id &_id)
+bool ls::std::event::Event::removeParameter(const ls::std::event::type::event_parameter_id &_id)
 {
   return this->parameterList.erase(_id) == 1;
 }
 
-void ls::std::event::Event::setId(const ls::std::core::type::event_id &_id)
+void ls::std::event::Event::setId(const ls::std::event::type::event_id &_id)
 {
   this->_assignId(_id);
 }
 
-void ls::std::event::Event::_assignId(const ls::std::core::type::event_id &_id)
+void ls::std::event::Event::_assignId(const ls::std::event::type::event_id &_id)
 {
   if (_id.empty())
   {
@@ -62,7 +62,7 @@ void ls::std::event::Event::_assignId(const ls::std::core::type::event_id &_id)
   this->id = _id;
 }
 
-bool ls::std::event::Event::_hasParameter(const ls::std::core::type::event_id &_id)
+bool ls::std::event::Event::_hasParameter(const ls::std::event::type::event_id &_id)
 {
   return this->parameterList.find(_id) != this->parameterList.end();
 }

source/ls_std/event/EventHandler.cpp

@@ -1,31 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2022-05-12
- *
- * */
-
-#include <ls_std/event/EventHandler.hpp>
-#include <ls_std/core/exception/IllegalArgumentException.hpp>
-
-ls::std::event::EventHandler::EventHandler(const ls::std::core::type::event_id& _id) : ls::std::event::Narrator()
-{
-  this->_assignId(_id);
-}
-
-ls::std::core::type::event_id ls::std::event::EventHandler::getId()
-{
-  return this->id;
-}
-
-void ls::std::event::EventHandler::_assignId(const ls::std::core::type::event_id &_id)
-{
-  if (_id.empty())
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-
-  this->id = _id;
-}

source/ls_std/event/EventManager.cpp

@@ -3,104 +3,54 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-19
+ * Changed:         2023-01-06
  *
  * */
 
 #include <ls_std/event/EventManager.hpp>
-#include <ls_std/core/exception/EventNotSubscribedException.hpp>
-#include <ls_std/core/exception/EventNotHandledException.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
+#include <iostream>
+#include <list>
 
 ls::std::event::EventManager::EventManager() : ls::std::core::Class("EventManager")
 {}
 
-void ls::std::event::EventManager::subscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener)
+void ls::std::event::EventManager::subscribe(const ls::std::event::type::event_id &_id,
+                                             const ::std::function<void(ls::std::event::Event)>& _listener)
 {
   if (_id.empty() || _listener == nullptr)
   {
     throw ls::std::core::IllegalArgumentException{};
   }
 
-  if (this->_hasEventHandler(_id))
+  ::std::list<::std::function<void(Event)>> listeners = this->eventHandler.at(_id);
+  if (!listeners.empty()) //null check needed?
   {
-    this->eventHandlers.at(_id)->addListener(_listener);
-  }
-  else
-  {
-    throw ls::std::core::EventNotSubscribedException{};
+    listeners.push_back(_listener);
   }
 }
 
-void ls::std::event::EventManager::unsubscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener)
+void ls::std::event::EventManager::unsubscribe(const ls::std::event::type::event_id &_id,
+                                               const ::std::function<void(ls::std::event::Event)> &_listener)
 {
   if (_id.empty() || _listener == nullptr)
   {
     throw ls::std::core::IllegalArgumentException{};
   }
 
-  if (this->_hasEventHandler(_id))
-  {
-    this->eventHandlers.at(_id)->removeListener(_listener);
-  }
-}
-
-bool ls::std::event::EventManager::addEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler)
-{
-  bool wasAdded{};
-
-  if (_eventHandler == nullptr)
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-
-  if (!this->_hasEventHandler(_eventHandler->getId()))
-  {
-    ::std::pair<ls::std::core::type::event_id, ::std::shared_ptr<ls::std::event::EventHandler>> element = ::std::make_pair(_eventHandler->getId(), _eventHandler);
-    wasAdded = this->eventHandlers.insert(element).second;
-  }
-
-  return wasAdded;
+  ::std::list<::std::function<void(Event)>> listeners = this->eventHandler.at(_id);
+  //listeners.remove(_listener);
 }
 
 void ls::std::event::EventManager::fire(ls::std::event::Event _event)
 {
-  if (this->_hasEventHandler(_event.getId()))
-  {
-    this->eventHandlers.at(_event.getId())->tell(_event);
-  }
-  else
-  {
-    throw ls::std::core::EventNotHandledException{};
-  }
-}
+  ::std::list<::std::function<void(Event)>> listeners = this->eventHandler.at(_event.getId());
 
-bool ls::std::event::EventManager::hasEventHandler(const ls::std::core::type::event_id &_id)
-{
-  if (_id.empty())
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-
-  return this->_hasEventHandler(_id);
-}
-
-bool ls::std::event::EventManager::removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler)
-{
-  if (_eventHandler == nullptr)
+  if (!listeners.empty())
   {
-    throw ls::std::core::IllegalArgumentException{};
+    for (::std::function<void(Event)> &listener : listeners)
+    {
+      listener(_event);
+    }
   }
-
-  return this->_removeEventHandler(_eventHandler);
-}
-
-bool ls::std::event::EventManager::_hasEventHandler(const ls::std::core::type::event_id &_id)
-{
-  return this->eventHandlers.find(_id) != this->eventHandlers.end();
-}
-
-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/Narrator.cpp

@@ -1,73 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-14
- * Changed:         2022-05-20
- *
- * */
-
-#include <ls_std/core/utils/STLUtils.hpp>
-#include <ls_std/event/Narrator.hpp>
-#include <ls_std/core/exception/IllegalArgumentException.hpp>
-
-ls::std::event::Narrator::Narrator() : ls::std::core::Class("Narrator")
-{}
-
-bool ls::std::event::Narrator::addListener(const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener)
-{
-  bool wasAdded{};
-
-  if (_listener == nullptr)
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-  else
-  {
-    if (!ls::std::core::STLUtils::contains(this->listeners, _listener))
-    {
-      this->listeners.push_back(_listener);
-      wasAdded = true;
-    }
-  }
-
-  return wasAdded;
-}
-
-void ls::std::event::Narrator::clear()
-{
-  this->listeners.clear();
-}
-
-::std::list<::std::shared_ptr<ls::std::core::interface_type::IListener>> ls::std::event::Narrator::getListeners()
-{
-  return this->listeners;
-}
-
-bool ls::std::event::Narrator::removeListener(const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener)
-{
-  bool wasRemoved{};
-
-  if (_listener == nullptr)
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-  else
-  {
-    if (ls::std::core::STLUtils::contains(this->listeners, _listener))
-    {
-      this->listeners.remove(_listener);
-      wasRemoved = true;
-    }
-  }
-
-  return wasRemoved;
-}
-
-void ls::std::event::Narrator::tell(const ls::std::core::Class &_info)
-{
-  for (const auto &listener : this->listeners)
-  {
-    listener->listen(_info);
-  }
-}

source/ls_std/event/serialization/SerializableJsonEvent.cpp

@@ -55,7 +55,7 @@ void ls::std::event::SerializableJsonEvent::_unmarshalParameterList()
 
   for (const auto &parameterJson : this->jsonObject["parameterList"])
   {
-    ls::std::core::type::event_parameter parameter = {parameterJson.at(0), parameterJson.at(1)};
+    ls::std::event::type::event_parameter parameter = {parameterJson.at(0), parameterJson.at(1)};
     this->value->addParameter(parameter);
   }
 }

test/cases/event/EventHandlerTest.cpp

@@ -1,49 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2022-05-14
- *
- * */
-
-#include <gtest/gtest.h>
-#include <ls_std/ls_std_core.hpp>
-#include <ls_std/ls_std_event.hpp>
-
-namespace
-{
-  class EventHandlerTest : public ::testing::Test
-  {
-    protected:
-
-      EventHandlerTest() = default;
-      ~EventHandlerTest() override = default;
-
-      void SetUp() override
-      {}
-
-      void TearDown() override
-      {}
-  };
-
-  TEST_F(EventHandlerTest, constructor_empty_parameter)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::event::EventHandler eventHandler{""};
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(EventHandlerTest, getId)
-  {
-    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-20
+ * Changed:         2023-01-06
  *
  * */
 
@@ -11,6 +11,11 @@
 #include <ls_std/ls_std_event.hpp>
 #include <ls_std_event_test.hpp>
 
+using ls_std_event_test::GossipNewsAgency;
+using ls::std::event::EventManager;
+using ::std::shared_ptr;
+using ::std::make_shared;
+
 namespace
 {
   class EventManagerTest : public ::testing::Test
@@ -20,8 +25,13 @@ namespace
       EventManagerTest() = default;
       ~EventManagerTest() override = default;
 
+      shared_ptr<GossipNewsAgency> gossipNewsAgency = make_shared<GossipNewsAgency>();
+      shared_ptr<EventManager> eventManager = make_shared<EventManager>();
+
       void SetUp() override
-      {}
+      {
+
+      }
 
       void TearDown() override
       {}
@@ -35,56 +45,46 @@ namespace
 
   TEST_F(EventManagerTest, subscribe_empty_id)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::event::EventManager eventManager{};
-                     eventManager.subscribe("", ::std::make_shared<ls_std_event_test::DailyNewsAgency>());
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
+    EXPECT_THROW(
+{
+             try
+             {
+               EventManager eventManager{};
+               std::function<void(ls::std::event::Event)> listener = std::bind(&GossipNewsAgency::onGossipNews, gossipNewsAgency, ::std::placeholders::_1);
+               eventManager.subscribe("", listener);
+             }
+             catch (const ls::std::core::IllegalArgumentException &_exception)
+             {
+               throw;
+             }
+          }, ls::std::core::IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, subscribe_no_listener)
   {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::event::EventManager eventManager{};
-                     eventManager.subscribe("TMP_ID", nullptr);
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
+    EXPECT_THROW(
+{
+             try
+             {
+               EventManager eventManager{};
+               eventManager.subscribe("TMP_ID", nullptr);
+             }
+             catch (const ls::std::core::IllegalArgumentException &_exception)
+             {
+               throw;
+             }
+          }, ls::std::core::IllegalArgumentException);
   }
 
-  TEST_F(EventManagerTest, subscribe_no_event_handler_available)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::event::EventManager eventManager{};
-                     eventManager.subscribe("TMP_DIR", ::std::make_shared<ls_std_event_test::DailyNewsAgency>());
-                   }
-                   catch (const ls::std::core::EventNotSubscribedException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::EventNotSubscribedException);
-  }
 
   TEST_F(EventManagerTest, unsubscribe_empty_id)
   {
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::EventManager eventManager{};
-                     eventManager.unsubscribe("", ::std::make_shared<ls_std_event_test::DailyNewsAgency>());
+                     EventManager eventManager{};
+                     std::function<void(ls::std::event::Event)> listener = std::bind(&GossipNewsAgency::onGossipNews, gossipNewsAgency, ::std::placeholders::_1);
+                     eventManager.unsubscribe("", listener);
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -93,12 +93,13 @@ namespace
                  }, ls::std::core::IllegalArgumentException);
   }
 
+
   TEST_F(EventManagerTest, unsubscribe_no_listener)
   {
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::EventManager eventManager{};
+                     EventManager eventManager{};
                      eventManager.unsubscribe("TMP_ID", nullptr);
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
@@ -108,175 +109,92 @@ namespace
                  }, ls::std::core::IllegalArgumentException);
   }
 
-  TEST_F(EventManagerTest, addEventHandler)
-  {
-    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::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)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::event::EventManager eventManager{};
-                     eventManager.addEventHandler(nullptr);
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(EventManagerTest, fire_event_handler_not_available)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::event::EventManager eventManager{};
-                     eventManager.fire(ls::std::event::Event{"TMP_ID"});
-                   }
-                   catch (const ls::std::core::EventNotHandledException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::EventNotHandledException);
-  }
-
-  TEST_F(EventManagerTest, hasEventHandler)
-  {
-    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::std::event::EventManager eventManager{};
-    ASSERT_FALSE(eventManager.hasEventHandler("TMP_ID"));
-  }
-
-  TEST_F(EventManagerTest, hasEventHandler_empty_id)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::event::EventManager eventManager{};
-                     eventManager.hasEventHandler("");
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(EventManagerTest, removeEventHandler)
-  {
-    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));
-  }
-
-  TEST_F(EventManagerTest, removeEventHandler_no_event_handler_available)
-  {
-    ls::std::event::EventManager eventManager{};
-    ASSERT_FALSE(eventManager.removeEventHandler(::std::make_shared<ls::std::event::EventHandler>("TMP_ID")));
-  }
-
-  TEST_F(EventManagerTest, removeEventHandler_no_reference)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::event::EventManager eventManager{};
-                     eventManager.removeEventHandler(nullptr);
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
   TEST_F(EventManagerTest, production_example)
   {
-    ::std::string news, expectedNews{};
-    ls::std::core::type::event_id seriousNewsEventId = ls_std_event_test::SeriousNewsEvent{""}.getId();
-    ls::std::core::type::event_id gossipNewsEventId = ls_std_event_test::GossipNewsEvent{""}.getId();
-
-    // create event handler
-
-    ::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::std::event::EventManager> eventManager = ::std::make_shared<ls::std::event::EventManager>();
-    eventManager->addEventHandler(seriousNewsEventHandler);
-    eventManager->addEventHandler(gossipNewsEventHandler);
-
-    // create news agency (listener)
 
-    ::std::shared_ptr<ls_std_event_test::DailyNewsAgency> dailyNews = ::std::make_shared<ls_std_event_test::DailyNewsAgency>();
-    ::std::shared_ptr<ls_std_event_test::GossipNewsAgency> gossipNews = ::std::make_shared<ls_std_event_test::GossipNewsAgency>();
-
-    // fire SeriousNewsEvent event with no effect
-
-    eventManager->fire(ls_std_event_test::SeriousNewsEvent(news)); // event call
-    ASSERT_TRUE(dailyNews->getNews().empty());
-    ASSERT_TRUE(gossipNews->getNews().empty());
-
-    // now subscribe to SeriousNewsEvent and fire SeriousNewsEvent event
-
-    eventManager->subscribe(seriousNewsEventId, dailyNews);
-    eventManager->subscribe(seriousNewsEventId, gossipNews);
-    news = "COVID-19 is still going on!";
-    eventManager->fire(ls_std_event_test::SeriousNewsEvent(news)); // event call
-
-    expectedNews = "DailyNewsAgency: " + news;
-    ASSERT_STREQ(expectedNews.c_str(), dailyNews->getNews().c_str());
-    expectedNews = "GossipNewsAgency: " + news;
-    ASSERT_STREQ(expectedNews.c_str(), gossipNews->getNews().c_str());
-
-    dailyNews->clear();
-    gossipNews->clear();
-
-    // unsubscribe SeriousNewsEvent from GossipNewsAgency
-
-    eventManager->unsubscribe(seriousNewsEventId, gossipNews);
-    eventManager->fire(ls_std_event_test::SeriousNewsEvent(news)); // event call
-
-    expectedNews = "DailyNewsAgency: " + news;
-    ASSERT_STREQ(expectedNews.c_str(), dailyNews->getNews().c_str());
-    ASSERT_TRUE(gossipNews->getNews().empty());
-
-    dailyNews->clear();
-    gossipNews->clear();
-
-    // now let GossipNewsAgency subscribe to SeriousNewsEvent + GossipNewsEvent and fire both of them
-
-    eventManager->subscribe(gossipNewsEventId, gossipNews);
-    eventManager->subscribe(seriousNewsEventId, gossipNews);
-
-    news = "COVID-19 is still going on!";
-    eventManager->fire(ls_std_event_test::SeriousNewsEvent(news)); // event call
-    expectedNews = "GossipNewsAgency: " + news;
-    ASSERT_STREQ(expectedNews.c_str(), gossipNews->getNews().c_str());
-
-    news = "ape likes banana!";
-    eventManager->fire(ls_std_event_test::GossipNewsEvent(news)); // event call
-    expectedNews = "GossipNewsAgency: " + news;
-    ASSERT_STREQ(expectedNews.c_str(), gossipNews->getNews().c_str());
   }
+
+//  TEST_F(EventManagerTest, production_example)
+//  {
+//    ::std::string news, expectedNews{};
+//    ls::std::core::type::event_id seriousNewsEventId = ls_std_event_test::SeriousNewsEvent{""}.getId();
+//    ls::std::core::type::event_id gossipNewsEventId = ls_std_event_test::GossipNewsEvent{""}.getId();
+//
+//    // create event handler
+//
+//    ::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::std::event::EventManager> eventManager = ::std::make_shared<ls::std::event::EventManager>();
+//    eventManager->addEventHandler(seriousNewsEventHandler);
+//    eventManager->addEventHandler(gossipNewsEventHandler);
+//
+//    // create news agency (listener)
+//
+//    ::std::shared_ptr<ls_std_event_test::DailyNewsAgency> dailyNews = ::std::make_shared<ls_std_event_test::DailyNewsAgency>();
+//    ::std::shared_ptr<ls_std_event_test::GossipNewsAgency> gossipNews = ::std::make_shared<ls_std_event_test::GossipNewsAgency>();
+//
+//    // fire SeriousNewsEvent event with no effect
+//
+//    eventManager->fire(ls_std_event_test::SeriousNewsEvent(news)); // event call
+//    ASSERT_TRUE(dailyNews->getNews().empty());
+//    ASSERT_TRUE(gossipNews->getNews().empty());
+//
+//    // now subscribe to SeriousNewsEvent and fire SeriousNewsEvent event
+//
+//    //eventManager->subscribe(seriousNewsEventId, dailyNews->onSeriousNews);
+//    //eventManager->subscribe(seriousNewsEventId, gossipNews->onSeriousNews);
+//    news = "COVID-19 is still going on!";
+//    eventManager->fire(ls_std_event_test::SeriousNewsEvent(news)); // event call
+//
+//    expectedNews = "DailyNewsAgency: " + news;
+//    ASSERT_STREQ(expectedNews.c_str(), dailyNews->getNews().c_str());
+//    expectedNews = "GossipNewsAgency: " + news;
+//    ASSERT_STREQ(expectedNews.c_str(), gossipNews->getNews().c_str());
+//
+//    dailyNews->clear();
+//    gossipNews->clear();
+//
+//    // unsubscribe SeriousNewsEvent from GossipNewsAgency
+//
+//    //eventManager->unsubscribe(seriousNewsEventId, gossipNews->onSeriousNews);
+//    eventManager->fire(ls_std_event_test::SeriousNewsEvent(news)); // event call
+//
+//    expectedNews = "DailyNewsAgency: " + news;
+//    ASSERT_STREQ(expectedNews.c_str(), dailyNews->getNews().c_str());
+//    ASSERT_TRUE(gossipNews->getNews().empty());
+//
+//    dailyNews->clear();
+//    gossipNews->clear();
+//
+//    // now let GossipNewsAgency subscribe to SeriousNewsEvent + GossipNewsEvent and fire both of them
+//
+//    std::function<void(ls::std::event::Event)> listener = ::std::bind(&ls_std_event_test::GossipNewsAgency::onGossipNews, gossipNews, ::std::placeholders::_1);
+//    eventManager->subscribe(gossipNewsEventId, listener);
+//    //eventManager->subscribe(seriousNewsEventId, gossipNews->onSeriousNews);
+//
+//    news = "COVID-19 is still going on!";
+//    eventManager->fire(ls_std_event_test::SeriousNewsEvent(news)); // event call
+//    expectedNews = "GossipNewsAgency: " + news;
+//    ASSERT_STREQ(expectedNews.c_str(), gossipNews->getNews().c_str());
+//
+//    news = "ape likes banana!";
+//    eventManager->fire(ls_std_event_test::GossipNewsEvent(news)); // event call
+//    expectedNews = "GossipNewsAgency: " + news;
+//    ASSERT_STREQ(expectedNews.c_str(), gossipNews->getNews().c_str());
+//  }
+//
+//
+//  TEST_F(EventManagerTest, ListenerTest)
+//  {
+//    ::std::shared_ptr<ls_std_event_test::GossipNewsAgency> gossipNews = ::std::make_shared<ls_std_event_test::GossipNewsAgency>();
+//    ls::std::core::type::event_id gossipNewsEventId = ls_std_event_test::GossipNewsEvent{""}.getId();
+//    ::std::shared_ptr<ls::std::event::EventManager> eventManager = ::std::make_shared<ls::std::event::EventManager>();
+//    std::function<void(ls::std::event::Event)> listener = ::std::bind(&ls_std_event_test::GossipNewsAgency::onGossipNews, gossipNews, ::std::placeholders::_1);
+//    eventManager->subscribe(gossipNewsEventId, listener);
+//    ::std::string news = "ape likes banana!";
+//    eventManager->fire(ls_std_event_test::GossipNewsEvent(news)); // event call
+//  }
 }

test/cases/event/EventTest.cpp

@@ -54,8 +54,8 @@ namespace
     ls::std::event::Event event{"TMP_ID"};
     ASSERT_TRUE(event.getParameterList().empty());
 
-    ASSERT_TRUE(event.addParameter(ls::std::core::type::event_parameter("key", "yes")));
-    ASSERT_TRUE(event.addParameter(ls::std::core::type::event_parameter("facing_door", "yes")));
+    ASSERT_TRUE(event.addParameter(ls::std::event::type::event_parameter("key", "yes")));
+    ASSERT_TRUE(event.addParameter(ls::std::event::type::event_parameter("facing_door", "yes")));
   }
 
   TEST_F(EventTest, addParameter_element_already_exists)
@@ -63,15 +63,15 @@ namespace
     ls::std::event::Event event{"TMP_ID"};
     ASSERT_TRUE(event.getParameterList().empty());
 
-    ASSERT_TRUE(event.addParameter(ls::std::core::type::event_parameter("key", "yes")));
-    ASSERT_FALSE(event.addParameter(ls::std::core::type::event_parameter("key", "yes")));
+    ASSERT_TRUE(event.addParameter(ls::std::event::type::event_parameter("key", "yes")));
+    ASSERT_FALSE(event.addParameter(ls::std::event::type::event_parameter("key", "yes")));
   }
 
   TEST_F(EventTest, clearParameterList)
   {
     ls::std::event::Event event{"OPEN_DOOR_EVENT"};
-    event.addParameter(ls::std::core::type::event_parameter("key", "yes"));
-    event.addParameter(ls::std::core::type::event_parameter("facing_door", "yes"));
+    event.addParameter(ls::std::event::type::event_parameter("key", "yes"));
+    event.addParameter(ls::std::event::type::event_parameter("facing_door", "yes"));
     ASSERT_EQ(2, event.getParameterList().size());
 
     event.clearParameterList();
@@ -96,8 +96,8 @@ namespace
     ls::std::event::Event event{"OPEN_DOOR_EVENT"};
     ASSERT_TRUE(event.getParameterList().empty());
 
-    event.addParameter(ls::std::core::type::event_parameter("key", "yes"));
-    event.addParameter(ls::std::core::type::event_parameter("facing_door", "yes"));
+    event.addParameter(ls::std::event::type::event_parameter("key", "yes"));
+    event.addParameter(ls::std::event::type::event_parameter("facing_door", "yes"));
 
     ASSERT_TRUE(event.removeParameter("key"));
     ASSERT_TRUE(event.removeParameter("facing_door"));

test/cases/event/NarratorTest.cpp

@@ -1,153 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-14
- * Changed:         2022-05-20
- *
- * */
-
-#include <gtest/gtest.h>
-#include <ls_std/ls_std_core.hpp>
-#include <ls_std/ls_std_event.hpp>
-#include <ls_std_event_test.hpp>
-
-namespace
-{
-  class NarratorTest : public ::testing::Test
-  {
-    protected:
-
-      NarratorTest() = default;
-      ~NarratorTest() override = default;
-
-      void SetUp() override
-      {}
-
-      void TearDown() override
-      {}
-
-      ::std::shared_ptr<ls_std_event_test::TestDataMercedesCar> mercedes1{};
-      ::std::shared_ptr<ls_std_event_test::TestDataMercedesCar> mercedes2{};
-      ::std::shared_ptr<ls_std_event_test::TestDataMercedesCar> mercedes3{};
-
-      void createCars()
-      {
-        this->mercedes1 = ::std::make_shared<ls_std_event_test::TestDataMercedesCar>();
-        this->mercedes1->setColor("pink");
-        this->mercedes2 = ::std::make_shared<ls_std_event_test::TestDataMercedesCar>();
-        this->mercedes2->setColor("blue");
-        this->mercedes3 = ::std::make_shared<ls_std_event_test::TestDataMercedesCar>();
-        this->mercedes3->setColor("red");
-      }
-  };
-
-  TEST_F(NarratorTest, addListener)
-  {
-    this->createCars();
-    ls::std::event::Narrator paintingMachine{};
-
-    ASSERT_TRUE(paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes1)));
-    ASSERT_TRUE(paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes2)));
-    ASSERT_TRUE(paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes3)));
-  }
-
-  TEST_F(NarratorTest, addListener_listener_already_exists)
-  {
-    this->createCars();
-    ls::std::event::Narrator paintingMachine{};
-
-    ASSERT_TRUE(paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes1)));
-    ASSERT_FALSE(paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes1)));
-  }
-
-  TEST_F(NarratorTest, addListener_no_reference)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::event::Narrator paintingMachine{};
-                     paintingMachine.addListener(nullptr);
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(NarratorTest, clear)
-  {
-    this->createCars();
-    ls::std::event::Narrator paintingMachine{};
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes1));
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes2));
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes3));
-
-    ASSERT_FALSE(paintingMachine.getListeners().empty());
-    paintingMachine.clear();
-    ASSERT_TRUE(paintingMachine.getListeners().empty());
-  }
-
-  TEST_F(NarratorTest, getListeners)
-  {
-    ls::std::event::Narrator narrator{};
-    ASSERT_TRUE(narrator.getListeners().empty());
-  }
-
-  TEST_F(NarratorTest, removeListener)
-  {
-    this->createCars();
-    ls::std::event::Narrator paintingMachine{};
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes1));
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes2));
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes3));
-
-    ASSERT_TRUE(paintingMachine.removeListener(this->mercedes2));
-    ASSERT_TRUE(paintingMachine.removeListener(this->mercedes1));
-    ASSERT_TRUE(paintingMachine.removeListener(this->mercedes3));
-    ASSERT_TRUE(paintingMachine.getListeners().empty());
-  }
-
-  TEST_F(NarratorTest, removeListener_no_listener_available)
-  {
-    this->createCars();
-    ls::std::event::Narrator paintingMachine{};
-    ASSERT_FALSE(paintingMachine.removeListener(this->mercedes2));
-  }
-
-  TEST_F(NarratorTest, removeListener_no_reference)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::event::Narrator paintingMachine{};
-                     paintingMachine.removeListener(nullptr);
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(NarratorTest, tell)
-  {
-    this->createCars();
-    ls::std::event::Narrator paintingMachine{};
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes1));
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes2));
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes3));
-
-    ASSERT_STREQ("pink", this->mercedes1->getColor().c_str());
-    ASSERT_STREQ("blue", this->mercedes2->getColor().c_str());
-    ASSERT_STREQ("red", this->mercedes3->getColor().c_str());
-
-    ls_std_event_test::Colour newColor{"black"};
-    paintingMachine.tell(static_cast<const ls::std::core::Class &>(newColor));
-
-    ASSERT_STREQ("black", this->mercedes1->getColor().c_str());
-    ASSERT_STREQ("black", this->mercedes2->getColor().c_str());
-    ASSERT_STREQ("black", this->mercedes3->getColor().c_str());
-  }
-}

test/cases/event/serialization/SerializableJsonEventTest.cpp

@@ -44,8 +44,8 @@ namespace
   TEST_F(SerializableJsonEventTest, marshal)
   {
     ls::std::event::Event event{"OPEN_DOOR_EVENT"};
-    event.addParameter(ls::std::core::type::event_parameter{"key_available", "true"});
-    event.addParameter(ls::std::core::type::event_parameter{"door_id", "16675"});
+    event.addParameter(ls::std::event::type::event_parameter{"key_available", "true"});
+    event.addParameter(ls::std::event::type::event_parameter{"door_id", "16675"});
 
     ls::std::event::SerializableJsonEvent serializable{::std::make_shared<ls::std::event::Event>(event)};
 
@@ -63,7 +63,7 @@ namespace
 
     serializable.unmarshal(jsonString);
     ASSERT_STREQ("OPEN_DOOR_EVENT", serializable.getValue()->getId().c_str());
-    ls::std::core::type::event_parameter_list parameterList = serializable.getValue()->getParameterList();
+    ls::std::event::type::event_parameter_list parameterList = serializable.getValue()->getParameterList();
 
     ASSERT_FALSE(parameterList.empty());
     ASSERT_EQ(2, parameterList.size());

test/classes/event/DailyNewsAgency.hpp

@@ -18,7 +18,7 @@
 
 namespace ls_std_event_test
 {
-  class DailyNewsAgency : public ls_std_event_test::NewsAgency, public ls::std::core::interface_type::IListener
+  class DailyNewsAgency : public ls_std_event_test::NewsAgency
   {
     public:
 
@@ -27,7 +27,7 @@ namespace ls_std_event_test
 
       // implementation
 
-      void listen(const ls::std::core::Class &_info) override;
+      void listen(const ls::std::core::Class &_info);
 
       // additional functionality
 

test/classes/event/GossipNewsAgency.cpp

@@ -8,26 +8,17 @@
  * */
 
 #include "GossipNewsAgency.hpp"
+#include "GossipNewsEvent.hpp"
 #include <ls_std/ls_std_event.hpp>
+#include <iostream>
 
-ls_std_event_test::GossipNewsAgency::GossipNewsAgency() : ls_std_event_test::NewsAgency("GossipNewsAgency")
-{}
-
-void ls_std_event_test::GossipNewsAgency::listen(const ls::std::core::Class &_info)
-{
-  ls::std::event::Event event = dynamic_cast<const ls::std::event::Event &>(_info);
-
-  if (event.getId() == "SeriousNewsEvent")
+ls_std_event_test::GossipNewsAgency::GossipNewsAgency(::std::string agencyName, EventManager eventManager)
+  : NewsAgency(agencyName),
+  m_eventManager(eventManager)
   {
-    this->news = this->getName() + ": " + event.getParameterList().at("news");
+    m_eventManager.subscribe(ls_std_event_test::GossipNewsEvent::EVENT_ID, )
   }
 
-  if (event.getId() == "GossipNewsEvent")
-  {
-    this->news = this->getName() + ": " + event.getParameterList().at("news");
-  }
-}
-
 void ls_std_event_test::GossipNewsAgency::clear()
 {
   this->news.clear();
@@ -37,3 +28,13 @@ void ls_std_event_test::GossipNewsAgency::clear()
 {
   return this->news;
 }
+
+void ls_std_event_test::GossipNewsAgency::onGossipNews(ls_std_event_test::GossipNewsEvent event)
+{
+  ::std::cout << event.getParameterList().at("news");
+}
+
+ls_std_event_test::GossipNewsAgency::~GossipNewsAgency()
+{
+
+}

test/classes/event/GossipNewsAgency.hpp

@@ -14,20 +14,24 @@
 #include <memory>
 #include <map>
 #include <ls_std/ls_std_core.hpp>
+#include <ls_std/ls_std_event.hpp>
 #include "NewsAgency.hpp"
+#include "GossipNewsEvent.hpp"
+
+using ls::std::event::interface_type::IEventManager;
 
 namespace ls_std_event_test
 {
-  class GossipNewsAgency : public ls_std_event_test::NewsAgency, public ls::std::core::interface_type::IListener
+  class GossipNewsAgency : public ls_std_event_test::NewsAgency
   {
     public:
 
-      GossipNewsAgency();
-      ~GossipNewsAgency() = default;
+      GossipNewsAgency(::std::string agencyName, EventManager eventManager);
+      ~GossipNewsAgency();
 
       // implementation
 
-      void listen(const ls::std::core::Class &_info) override;
+      void onGossipNews(ls_std_event_test::GossipNewsEvent event);
 
       // additional functionality
 
@@ -36,6 +40,7 @@ namespace ls_std_event_test
 
     private:
 
+      EventManager m_eventManager;
       ::std::string news{};
   };
 }

test/classes/event/GossipNewsEvent.cpp

@@ -9,8 +9,10 @@
 
 #include "GossipNewsEvent.hpp"
 
-ls_std_event_test::GossipNewsEvent::GossipNewsEvent(const ::std::string &_news) : ls::std::event::Event("GossipNewsEvent")
+const std::string ls_std_event_test::GossipNewsEvent::EVENT_ID = std::string("GossipNewsEvent");
+
+ls_std_event_test::GossipNewsEvent::GossipNewsEvent(const ::std::string &_news) : ls::std::event::Event(EVENT_ID)
 {
-  ls::std::core::type::event_parameter newsParameter = ::std::make_pair("news", _news);
+  ls::std::event::type::event_parameter newsParameter = ::std::make_pair("news", _news);
   this->addParameter(newsParameter);
 }

test/classes/event/GossipNewsEvent.hpp

@@ -21,6 +21,7 @@ namespace ls_std_event_test
 
       explicit GossipNewsEvent(const ::std::string &_news);
       ~GossipNewsEvent() override = default;
+      static const std::string EVENT_ID;
   };
 }
 

test/classes/event/SeriousNewsEvent.cpp

@@ -11,6 +11,6 @@
 
 ls_std_event_test::SeriousNewsEvent::SeriousNewsEvent(const ::std::string &_news) : ls::std::event::Event("SeriousNewsEvent")
 {
-  ls::std::core::type::event_parameter newsParameter = ::std::make_pair("news", _news);
+  ls::std::event::type::event_parameter newsParameter = ::std::make_pair("news", _news);
   this->addParameter(newsParameter);
 }

test/classes/event/TestDataMercedesCar.hpp

@@ -15,14 +15,14 @@
 
 namespace ls_std_event_test
 {
-  class TestDataMercedesCar : public ls_std_event_test::TestDataCar, public ls::std::core::interface_type::IListener
+  class TestDataMercedesCar : public ls_std_event_test::TestDataCar
   {
     public:
 
       TestDataMercedesCar();
       ~TestDataMercedesCar() = default;
 
-      void listen(const ls::std::core::Class &_info) override;
+      void listen(const ls::std::core::Class &_info);
   };
 }