Remove legacy Event implementation

CMakeLists.txt

@@ -209,11 +209,6 @@ set(SOURCE_FILES_EVENT
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls-std/event/reworked/Event.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls-std/event/reworked/EventListener.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls-std/event/reworked/EventManager.cpp)
-#${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)
 
 set(SOURCE_FILES_IO
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls-std/io/evaluator/FileExistenceEvaluator.cpp
@@ -349,19 +344,6 @@ if (${LS_STD_BUILD_WITH_TESTS})
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/event/reworked/EventTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/OnClickEvent.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/Button.cpp)
-    #${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
-    #${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/GossipNewsEvent.cpp
-    #${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/NewsAgency.cpp
-    #${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/SeriousNewsEvent.cpp
-    #${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/TestDataCar.cpp
-    #${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/TestDataMercedesCar.cpp)
 
     set(UNIT_TEST_FILES_IO
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/evaluator/FileExistenceEvaluatorTest.cpp

include/ls-std/event/Event.hpp

@@ -1,47 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-26
- * Changed:         2023-05-16
- *
- * */
-
-#ifndef LS_STD_EVENT_HPP
-#define LS_STD_EVENT_HPP
-
-#include <ls-std/core/Class.hpp>
-#include <ls-std/core/interface/ISerializable.hpp>
-#include <ls-std/core/type/EventTypes.hpp>
-#include <ls-std/os/dynamic-goal.hpp>
-#include <memory>
-
-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);
-      ~Event() noexcept override;
-
-      // additional functionality
-
-      bool addParameter(const ls::std::core::type::event_parameter &_eventParameter); // nodiscard is optional here
-      void clearParameterList();
-      [[nodiscard]] ls::std::core::type::event_id getId() const;
-      [[nodiscard]] ls::std::core::type::event_parameter_list getParameterList() const;
-      bool removeParameter(const ls::std::core::type::event_parameter_id &_id); // nodiscard is optional here
-      void setId(const ls::std::core::type::event_id &_id);
-
-    private:
-
-      ls::std::core::type::event_id id{};
-      ls::std::core::type::event_parameter_list parameterList{};
-
-      void _assignId(const ls::std::core::type::event_id &_id);
-      [[nodiscard]] bool _hasParameter(const ls::std::core::type::event_id &_id);
-  };
-}
-
-#endif

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:         2023-05-17
- *
- * */
-
-#ifndef LS_STD_EVENT_HANDLER_HPP
-#define LS_STD_EVENT_HANDLER_HPP
-
-#include "Event.hpp"
-#include "Narrator.hpp"
-#include <list>
-#include <ls-std/core/Class.hpp>
-#include <ls-std/core/interface/IListener.hpp>
-#include <ls-std/os/dynamic-goal.hpp>
-#include <memory>
-
-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() noexcept override;
-
-      [[nodiscard]] ls::std::core::type::event_id getId() const;
-
-    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

@@ -1,51 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-05-17
- *
- * */
-
-#ifndef LS_STD_EVENT_MANAGER_HPP
-#define LS_STD_EVENT_MANAGER_HPP
-
-#include "EventHandler.hpp"
-#include <ls-std/core/Class.hpp>
-#include <ls-std/core/interface/IEventSubscriber.hpp>
-#include <ls-std/core/type/EventTypes.hpp>
-#include <ls-std/os/dynamic-goal.hpp>
-#include <map>
-#include <memory>
-
-namespace ls::std::event
-{
-  class LS_STD_DYNAMIC_GOAL EventManager : public ls::std::core::Class, public ls::std::core::interface_type::IEventSubscriber
-  {
-    public:
-
-      explicit EventManager();
-      ~EventManager() noexcept override;
-
-      // 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;
-
-      // additional functionality
-
-      bool addEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler); // nodiscard is optional here
-      void fire(const ls::std::event::Event &_event);
-      [[nodiscard]] bool hasEventHandler(const ls::std::core::type::event_id &_id);
-      bool removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler); // nodiscard is optional here
-
-    private:
-
-      ::std::map<ls::std::core::type::event_id, ::std::shared_ptr<ls::std::event::EventHandler>, ::std::less<>> eventHandlers{};
-
-      [[nodiscard]] bool _hasEventHandler(const ls::std::core::type::event_id &_id);
-      [[nodiscard]] bool _removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler);
-  };
-}
-
-#endif

include/ls-std/event/Narrator.hpp

@@ -1,42 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-14
- * Changed:         2023-05-16
- *
- * */
-
-#ifndef LS_STD_NARRATOR_HPP
-#define LS_STD_NARRATOR_HPP
-
-#include <list>
-#include <ls-std/core/Class.hpp>
-#include <ls-std/core/interface/IListener.hpp>
-#include <ls-std/os/dynamic-goal.hpp>
-#include <memory>
-
-namespace ls::std::event
-{
-  class LS_STD_DYNAMIC_GOAL Narrator : public ls::std::core::Class
-  {
-    public:
-
-      Narrator();
-      ~Narrator() noexcept override;
-
-      bool addListener(const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener); // nodiscard is optional here
-      void clear();
-      [[nodiscard]] ::std::list<::std::shared_ptr<ls::std::core::interface_type::IListener>> getListeners() const;
-      bool removeListener(const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener); // nodiscard is optional here
-      void tell(const ls::std::core::Class &_info) const;
-
-    private:
-
-      ::std::list<::std::shared_ptr<ls::std::core::interface_type::IListener>> listeners{};
-
-      [[nodiscard]] bool _hasListener(const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener);
-  };
-}
-
-#endif

include/ls-std/event/serialization/SerializableJsonEvent.hpp

@@ -1,51 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-12-07
- * Changed:         2023-05-19
- *
- * */
-
-#ifndef LS_STD_SERIALIZABLE_JSON_EVENT_HPP
-#define LS_STD_SERIALIZABLE_JSON_EVENT_HPP
-
-#include <ls-std/core/Class.hpp>
-#include <ls-std/core/interface/ISerializable.hpp>
-#include <ls-std/core/type/Types.hpp>
-#include <ls-std/event/Event.hpp>
-#include <ls-std/os/dynamic-goal.hpp>
-#include <memory>
-
-namespace ls::std::event
-{
-  class LS_STD_DYNAMIC_GOAL SerializableJsonEvent : public ls::std::core::Class, public ls::std::core::interface_type::ISerializable
-  {
-    public:
-
-      explicit SerializableJsonEvent(const ::std::shared_ptr<ls::std::event::Event> &_value);
-      ~SerializableJsonEvent() noexcept override;
-
-      // implementation
-
-      [[nodiscard]] ls::std::core::type::byte_field marshal() override;
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
-
-      // additional functionality
-
-      [[nodiscard]] ::std::shared_ptr<ls::std::event::Event> getValue() const;
-      void setValue(const ::std::shared_ptr<ls::std::event::Event> &_value);
-
-    private:
-
-      ls::std::core::type::json jsonObject{};
-      ::std::shared_ptr<ls::std::event::Event> value{};
-
-      void _assignValue(const ::std::shared_ptr<ls::std::event::Event> &_value);
-      void _unmarshalParameterList();
-      void _update();
-      void _updateEventParameterList();
-  };
-}
-
-#endif

include/ls-std/ls-std-event.hpp

@@ -16,11 +16,4 @@
 #include <ls-std/event/reworked/EventListener.hpp>
 #include <ls-std/event/reworked/EventManager.hpp>
 
-//#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

@@ -1,74 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-26
- * Changed:         2023-05-16
- *
- * */
-
-#include <ls-std/core/evaluator/EmptyStringArgumentEvaluator.hpp>
-#include <ls-std/event/Event.hpp>
-
-using ls::std::core::Class;
-using ls::std::core::EmptyStringArgumentEvaluator;
-using ls::std::core::type::event_id;
-using ls::std::core::type::event_parameter;
-using ls::std::core::type::event_parameter_id;
-using ls::std::core::type::event_parameter_list;
-using ls::std::event::Event;
-
-Event::Event(const event_id &_id) : Class("Event")
-{
-  this->_assignId(_id);
-}
-
-Event::~Event() noexcept = default;
-
-bool Event::addParameter(const event_parameter &_eventParameter)
-{
-  bool wasAdded{};
-
-  if (!this->_hasParameter(_eventParameter.first))
-  {
-    wasAdded = this->parameterList.insert(_eventParameter).second;
-  }
-
-  return wasAdded;
-}
-
-void Event::clearParameterList()
-{
-  this->parameterList.clear();
-}
-
-event_id Event::getId() const
-{
-  return this->id;
-}
-
-event_parameter_list Event::getParameterList() const
-{
-  return this->parameterList;
-}
-
-bool Event::removeParameter(const event_parameter_id &_id)
-{
-  return this->parameterList.erase(_id) == 1;
-}
-
-void Event::setId(const event_id &_id)
-{
-  this->_assignId(_id);
-}
-
-void Event::_assignId(const event_id &_id)
-{
-  EmptyStringArgumentEvaluator{_id, "event id is empty!"}.evaluate();
-  this->id = _id;
-}
-
-bool Event::_hasParameter(const event_id &_id)
-{
-  return this->parameterList.find(_id) != this->parameterList.end();
-}

source/ls-std/event/EventHandler.cpp

@@ -1,34 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-05-17
- *
- * */
-
-#include <ls-std/core/evaluator/EmptyStringArgumentEvaluator.hpp>
-#include <ls-std/event/EventHandler.hpp>
-
-using ls::std::core::EmptyStringArgumentEvaluator;
-using ls::std::core::type::event_id;
-using ls::std::event::EventHandler;
-using ls::std::event::Narrator;
-
-EventHandler::EventHandler(const event_id &_id) : Narrator()
-{
-  this->_assignId(_id);
-}
-
-EventHandler::~EventHandler() noexcept = default;
-
-event_id EventHandler::getId() const
-{
-  return this->id;
-}
-
-void EventHandler::_assignId(const event_id &_id)
-{
-  EmptyStringArgumentEvaluator{_id, "event manager id is empty!"}.evaluate();
-  this->id = _id;
-}

source/ls-std/event/EventManager.cpp

@@ -1,107 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-05-17
- *
- * */
-
-#include <ls-std/core/evaluator/EmptyStringArgumentEvaluator.hpp>
-#include <ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp>
-#include <ls-std/core/exception/EventNotHandledException.hpp>
-#include <ls-std/core/exception/EventNotSubscribedException.hpp>
-#include <ls-std/event/EventManager.hpp>
-
-using ls::std::core::Class;
-using ls::std::core::EmptyStringArgumentEvaluator;
-using ls::std::core::EventNotHandledException;
-using ls::std::core::EventNotSubscribedException;
-using ls::std::core::NullPointerArgumentEvaluator;
-using ls::std::core::interface_type::IListener;
-using ls::std::core::type::event_id;
-using ls::std::event::Event;
-using ls::std::event::EventHandler;
-using ls::std::event::EventManager;
-using std::make_pair;
-using std::pair;
-using std::shared_ptr;
-
-EventManager::EventManager() : Class("EventManager")
-{}
-
-EventManager::~EventManager() noexcept = default;
-
-void EventManager::subscribe(const event_id &_id, const shared_ptr<IListener> &_listener)
-{
-  EmptyStringArgumentEvaluator{_id, "event id is empty and can not be subscribed!"}.evaluate();
-  NullPointerArgumentEvaluator{_listener, "listener reference for subscribe attempt is null!"}.evaluate();
-
-  if (this->_hasEventHandler(_id))
-  {
-    this->eventHandlers.at(_id)->addListener(_listener);
-  }
-  else
-  {
-    throw EventNotSubscribedException{"id: " + _id};
-  }
-}
-
-void EventManager::unsubscribe(const event_id &_id, const shared_ptr<IListener> &_listener)
-{
-  EmptyStringArgumentEvaluator{_id, "event id is empty and can not be unsubscribed!"}.evaluate();
-  NullPointerArgumentEvaluator{_listener, "listener reference for unsubscribe attempt is null!"}.evaluate();
-
-  if (this->_hasEventHandler(_id))
-  {
-    this->eventHandlers.at(_id)->removeListener(_listener);
-  }
-}
-
-bool EventManager::addEventHandler(const shared_ptr<EventHandler> &_eventHandler)
-{
-  bool wasAdded{};
-  NullPointerArgumentEvaluator{_eventHandler, "event handler reference for add attempt is null!"}.evaluate();
-
-  if (!this->_hasEventHandler(_eventHandler->getId()))
-  {
-    pair<event_id, shared_ptr<EventHandler>> element = make_pair(_eventHandler->getId(), _eventHandler);
-    wasAdded = this->eventHandlers.insert(element).second;
-  }
-
-  return wasAdded;
-}
-
-void EventManager::fire(const Event &_event)
-{
-  if (this->_hasEventHandler(_event.getId()))
-  {
-    this->eventHandlers.at(_event.getId())->tell(_event);
-  }
-  else
-  {
-    throw EventNotHandledException{"id: " + _event.getId()};
-  }
-}
-
-bool EventManager::hasEventHandler(const event_id &_id)
-{
-  EmptyStringArgumentEvaluator{_id, "event id is empty and can not be passed!"}.evaluate();
-  return this->_hasEventHandler(_id);
-}
-
-bool EventManager::removeEventHandler(const shared_ptr<EventHandler> &_eventHandler)
-{
-  NullPointerArgumentEvaluator{_eventHandler, "event handler reference for remove attempt is null!"}.evaluate();
-  return this->_removeEventHandler(_eventHandler);
-}
-
-bool EventManager::_hasEventHandler(const event_id &_id)
-{
-  return this->eventHandlers.find(_id) != this->eventHandlers.end();
-}
-
-bool EventManager::_removeEventHandler(const shared_ptr<EventHandler> &_eventHandler)
-{
-  return this->eventHandlers.erase(_eventHandler->getId()) == 1;
-}

source/ls-std/event/Narrator.cpp

@@ -1,76 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-14
- * Changed:         2023-05-16
- *
- * */
-
-#include <algorithm>
-#include <ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp>
-#include <ls-std/event/Narrator.hpp>
-
-using ls::std::core::Class;
-using ls::std::core::NullPointerArgumentEvaluator;
-using ls::std::core::interface_type::IListener;
-using ls::std::event::Narrator;
-using std::find;
-using std::list;
-using std::shared_ptr;
-
-Narrator::Narrator() : Class("Narrator")
-{}
-
-Narrator::~Narrator() noexcept = default;
-
-bool Narrator::addListener(const shared_ptr<IListener> &_listener)
-{
-  bool wasAdded{};
-  NullPointerArgumentEvaluator{_listener, "listener reference for add attempt is null!"}.evaluate();
-
-  if (!this->_hasListener(_listener))
-  {
-    this->listeners.push_back(_listener);
-    wasAdded = true;
-  }
-
-  return wasAdded;
-}
-
-void Narrator::clear()
-{
-  this->listeners.clear();
-}
-
-list<shared_ptr<IListener>> Narrator::getListeners() const
-{
-  return this->listeners;
-}
-
-bool Narrator::removeListener(const shared_ptr<IListener> &_listener)
-{
-  bool wasRemoved{};
-  NullPointerArgumentEvaluator{_listener, "listener reference for remove attempt is null!"}.evaluate();
-
-  if (this->_hasListener(_listener))
-  {
-    this->listeners.remove(_listener);
-    wasRemoved = true;
-  }
-
-  return wasRemoved;
-}
-
-void Narrator::tell(const Class &_info) const
-{
-  for (const auto &listener : this->listeners)
-  {
-    listener->listen(_info);
-  }
-}
-
-bool Narrator::_hasListener(const shared_ptr<IListener> &_listener)
-{
-  return find(this->listeners.begin(), this->listeners.end(), _listener) != this->listeners.end();
-}

source/ls-std/event/serialization/SerializableJsonEvent.cpp

@@ -1,87 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-12-07
- * Changed:         2023-05-19
- *
- * */
-
-#include <ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp>
-#include <ls-std/event/serialization/SerializableJsonEvent.hpp>
-
-using ls::std::core::Class;
-using ls::std::core::NullPointerArgumentEvaluator;
-using ls::std::core::type::byte_field;
-using ls::std::core::type::event_parameter;
-using ls::std::core::type::json;
-using ls::std::event::Event;
-using ls::std::event::SerializableJsonEvent;
-using std::shared_ptr;
-using std::string;
-
-SerializableJsonEvent::SerializableJsonEvent(const shared_ptr<Event> &_value) : Class("SerializableJsonEvent")
-{
-  this->_assignValue(_value);
-}
-
-SerializableJsonEvent::~SerializableJsonEvent() noexcept = default;
-
-byte_field SerializableJsonEvent::marshal()
-{
-  this->_update();
-  return this->jsonObject.dump();
-}
-
-void SerializableJsonEvent::unmarshal(const byte_field &_data)
-{
-  this->jsonObject = json::parse(_data);
-
-  this->value->setId(this->jsonObject["id"]);
-  this->_unmarshalParameterList();
-}
-
-shared_ptr<Event> SerializableJsonEvent::getValue() const
-{
-  return this->value;
-}
-
-void SerializableJsonEvent::setValue(const shared_ptr<Event> &_value)
-{
-  this->_assignValue(_value);
-}
-
-void SerializableJsonEvent::_assignValue(const shared_ptr<Event> &_value)
-{
-  NullPointerArgumentEvaluator{_value, "event reference for serialization attempt is null!"}.evaluate();
-  this->value = _value;
-}
-
-void SerializableJsonEvent::_unmarshalParameterList()
-{
-  this->value->clearParameterList();
-
-  for (const auto &parameterJson : this->jsonObject["parameterList"])
-  {
-    event_parameter parameter = {parameterJson.at(0), parameterJson.at(1)};
-    this->value->addParameter(parameter);
-  }
-}
-
-void SerializableJsonEvent::_update()
-{
-  this->jsonObject = {{"id", this->value->getId()}};
-
-  this->_updateEventParameterList();
-}
-
-void SerializableJsonEvent::_updateEventParameterList()
-{
-  string jsonString{};
-
-  for (const auto &[eventParameterId, eventParameter] : this->value->getParameterList())
-  {
-    json parameterJson = {eventParameterId, eventParameter};
-    this->jsonObject["parameterList"][eventParameterId] = parameterJson;
-  }
-}

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:         2023-03-25
- *
- * */
-
-#include <gtest/gtest.h>
-#include <ls-std/ls-std-core.hpp>
-#include <ls-std/ls-std-event.hpp>
-
-using ls::std::core::IllegalArgumentException;
-using ls::std::event::EventHandler;
-using testing::Test;
-
-namespace
-{
-  class EventHandlerTest : public Test
-  {
-    public:
-
-      EventHandlerTest() = default;
-      ~EventHandlerTest() override = default;
-  };
-
-  TEST_F(EventHandlerTest, constructor_empty_parameter)
-  {
-    EXPECT_THROW(
-        {
-          try
-          {
-            EventHandler eventHandler{""};
-          }
-          catch (const IllegalArgumentException &_exception)
-          {
-            throw;
-          }
-        },
-        IllegalArgumentException);
-  }
-
-  TEST_F(EventHandlerTest, getId)
-  {
-    EventHandler eventHandler{"EventId"};
-    ASSERT_STREQ("EventId", eventHandler.getId().c_str());
-  }
-}

test/cases/event/EventManagerTest.cpp

@@ -1,311 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-05-16
- *
- * */
-
-#include <gtest/gtest.h>
-#include <ls-std-event-test.hpp>
-#include <ls-std/ls-std-event.hpp>
-
-using ls::std::core::EventNotHandledException;
-using ls::std::core::EventNotSubscribedException;
-using ls::std::core::IllegalArgumentException;
-using ls::std::core::type::event_id;
-using ls::std::event::Event;
-using ls::std::event::EventHandler;
-using ls::std::event::EventManager;
-using std::make_shared;
-using std::shared_ptr;
-using std::string;
-using test::event::DailyNewsAgency;
-using test::event::GossipNewsAgency;
-using test::event::GossipNewsEvent;
-using test::event::SeriousNewsEvent;
-using testing::Test;
-
-namespace
-{
-  class EventManagerTest : public Test
-  {
-    public:
-
-      EventManagerTest() = default;
-      ~EventManagerTest() override = default;
-  };
-
-  TEST_F(EventManagerTest, getClassName)
-  {
-    EventManager eventManager{};
-    ASSERT_STREQ("EventManager", eventManager.getClassName().c_str());
-  }
-
-  TEST_F(EventManagerTest, subscribe_empty_id)
-  {
-    EXPECT_THROW(
-        {
-          try
-          {
-            EventManager eventManager{};
-            eventManager.subscribe("", make_shared<DailyNewsAgency>());
-          }
-          catch (const IllegalArgumentException &_exception)
-          {
-            throw;
-          }
-        },
-        IllegalArgumentException);
-  }
-
-  TEST_F(EventManagerTest, subscribe_no_listener)
-  {
-    EXPECT_THROW(
-        {
-          try
-          {
-            EventManager eventManager{};
-            eventManager.subscribe("TMP_ID", nullptr);
-          }
-          catch (const IllegalArgumentException &_exception)
-          {
-            throw;
-          }
-        },
-        IllegalArgumentException);
-  }
-
-  TEST_F(EventManagerTest, subscribe_no_event_handler_available)
-  {
-    EXPECT_THROW(
-        {
-          try
-          {
-            EventManager eventManager{};
-            eventManager.subscribe("TMP_DIR", make_shared<DailyNewsAgency>());
-          }
-          catch (const EventNotSubscribedException &_exception)
-          {
-            throw;
-          }
-        },
-        EventNotSubscribedException);
-  }
-
-  TEST_F(EventManagerTest, unsubscribe_empty_id)
-  {
-    EXPECT_THROW(
-        {
-          try
-          {
-            EventManager eventManager{};
-            eventManager.unsubscribe("", make_shared<DailyNewsAgency>());
-          }
-          catch (const IllegalArgumentException &_exception)
-          {
-            throw;
-          }
-        },
-        IllegalArgumentException);
-  }
-
-  TEST_F(EventManagerTest, unsubscribe_no_listener)
-  {
-    EXPECT_THROW(
-        {
-          try
-          {
-            EventManager eventManager{};
-            eventManager.unsubscribe("TMP_ID", nullptr);
-          }
-          catch (const IllegalArgumentException &_exception)
-          {
-            throw;
-          }
-        },
-        IllegalArgumentException);
-  }
-
-  TEST_F(EventManagerTest, addEventHandler)
-  {
-    EventManager eventManager{};
-    ASSERT_TRUE(eventManager.addEventHandler(make_shared<EventHandler>("TMP_ID")));
-  }
-
-  TEST_F(EventManagerTest, addEventHandler_event_handler_already_exists)
-  {
-    EventManager eventManager{};
-    ASSERT_TRUE(eventManager.addEventHandler(make_shared<EventHandler>("TMP_ID")));
-    ASSERT_FALSE(eventManager.addEventHandler(make_shared<EventHandler>("TMP_ID")));
-  }
-
-  TEST_F(EventManagerTest, addEventHandler_no_reference)
-  {
-    EXPECT_THROW(
-        {
-          try
-          {
-            EventManager eventManager{};
-            eventManager.addEventHandler(nullptr);
-          }
-          catch (const IllegalArgumentException &_exception)
-          {
-            throw;
-          }
-        },
-        IllegalArgumentException);
-  }
-
-  TEST_F(EventManagerTest, fire_event_handler_not_available)
-  {
-    EXPECT_THROW(
-        {
-          try
-          {
-            EventManager eventManager{};
-            eventManager.fire(Event{"TMP_ID"});
-          }
-          catch (const EventNotHandledException &_exception)
-          {
-            throw;
-          }
-        },
-        EventNotHandledException);
-  }
-
-  TEST_F(EventManagerTest, hasEventHandler)
-  {
-    EventManager eventManager{};
-    eventManager.addEventHandler(make_shared<EventHandler>("TMP_ID"));
-    ASSERT_TRUE(eventManager.hasEventHandler("TMP_ID"));
-  }
-
-  TEST_F(EventManagerTest, hasEventHandler_no_event_handler_available)
-  {
-    EventManager eventManager{};
-    ASSERT_FALSE(eventManager.hasEventHandler("TMP_ID"));
-  }
-
-  TEST_F(EventManagerTest, hasEventHandler_empty_id)
-  {
-    EXPECT_THROW(
-        {
-          try
-          {
-            EventManager eventManager{};
-            bool hasHandler = eventManager.hasEventHandler("");
-          }
-          catch (const IllegalArgumentException &_exception)
-          {
-            throw;
-          }
-        },
-        IllegalArgumentException);
-  }
-
-  TEST_F(EventManagerTest, removeEventHandler)
-  {
-    EventManager eventManager{};
-    auto eventHandler = make_shared<EventHandler>("TMP_ID");
-    eventManager.addEventHandler(eventHandler);
-
-    ASSERT_TRUE(eventManager.removeEventHandler(eventHandler));
-  }
-
-  TEST_F(EventManagerTest, removeEventHandler_no_event_handler_available)
-  {
-    EventManager eventManager{};
-    ASSERT_FALSE(eventManager.removeEventHandler(make_shared<EventHandler>("TMP_ID")));
-  }
-
-  TEST_F(EventManagerTest, removeEventHandler_no_reference)
-  {
-    EXPECT_THROW(
-        {
-          try
-          {
-            EventManager eventManager{};
-            eventManager.removeEventHandler(nullptr);
-          }
-          catch (const IllegalArgumentException &_exception)
-          {
-            throw;
-          }
-        },
-        IllegalArgumentException);
-  }
-
-  TEST_F(EventManagerTest, production_example)
-  {
-    string news{};
-    string expectedNews{};
-    event_id seriousNewsEventId = SeriousNewsEvent{""}.getId();
-    event_id gossipNewsEventId = GossipNewsEvent{""}.getId();
-
-    // create event handler
-
-    auto seriousNewsEventHandler = make_shared<EventHandler>(seriousNewsEventId); // event id
-    auto gossipNewsEventHandler = make_shared<EventHandler>(gossipNewsEventId);   // event id
-
-    // create and fill event manager with handler
-
-    auto eventManager = make_shared<EventManager>();
-    eventManager->addEventHandler(seriousNewsEventHandler);
-    eventManager->addEventHandler(gossipNewsEventHandler);
-
-    // create news agency (listener)
-
-    auto dailyNews = make_shared<DailyNewsAgency>();
-    auto gossipNews = make_shared<GossipNewsAgency>();
-
-    // fire SeriousNewsEvent event with no effect
-
-    eventManager->fire(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(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(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(SeriousNewsEvent(news)); // event call
-    expectedNews = "GossipNewsAgency: " + news;
-    ASSERT_STREQ(expectedNews.c_str(), gossipNews->getNews().c_str());
-
-    news = "ape likes banana!";
-    eventManager->fire(GossipNewsEvent(news)); // event call
-    expectedNews = "GossipNewsAgency: " + news;
-    ASSERT_STREQ(expectedNews.c_str(), gossipNews->getNews().c_str());
-  }
-}

test/cases/event/EventTest.cpp

@@ -1,140 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-26
- * Changed:         2023-03-25
- *
- * */
-
-#include <gtest/gtest.h>
-#include <ls-std/ls-std-core.hpp>
-#include <ls-std/ls-std-event.hpp>
-
-using ls::std::core::IllegalArgumentException;
-using ls::std::core::type::event_parameter;
-using ls::std::event::Event;
-using testing::Test;
-
-namespace
-{
-  class EventTest : public Test
-  {
-    public:
-
-      EventTest() = default;
-      ~EventTest() override = default;
-  };
-
-  // additional functionality
-
-  TEST_F(EventTest, getClassName)
-  {
-    Event event{"TMP_ID"};
-    ASSERT_STREQ("Event", event.getClassName().c_str());
-  }
-
-  TEST_F(EventTest, constructor_empty_parameter)
-  {
-    EXPECT_THROW(
-        {
-          try
-          {
-            Event event{""};
-          }
-          catch (const IllegalArgumentException &_exception)
-          {
-            throw;
-          }
-        },
-        IllegalArgumentException);
-  }
-
-  TEST_F(EventTest, addParameter)
-  {
-    Event event{"TMP_ID"};
-    ASSERT_TRUE(event.getParameterList().empty());
-
-    ASSERT_TRUE(event.addParameter(event_parameter("key", "yes")));
-    ASSERT_TRUE(event.addParameter(event_parameter("facing_door", "yes")));
-  }
-
-  TEST_F(EventTest, addParameter_element_already_exists)
-  {
-    Event event{"TMP_ID"};
-    ASSERT_TRUE(event.getParameterList().empty());
-
-    ASSERT_TRUE(event.addParameter(event_parameter("key", "yes")));
-    ASSERT_FALSE(event.addParameter(event_parameter("key", "yes")));
-  }
-
-  TEST_F(EventTest, clearParameterList)
-  {
-    Event event{"OPEN_DOOR_EVENT"};
-    event.addParameter(event_parameter("key", "yes"));
-    event.addParameter(event_parameter("facing_door", "yes"));
-    ASSERT_EQ(2, event.getParameterList().size());
-
-    event.clearParameterList();
-    ASSERT_TRUE(event.getParameterList().empty());
-    ASSERT_EQ(0, event.getParameterList().size());
-  }
-
-  TEST_F(EventTest, getId)
-  {
-    Event event{"OPEN_DOOR_EVENT"};
-    ASSERT_STREQ("OPEN_DOOR_EVENT", event.getId().c_str());
-  }
-
-  TEST_F(EventTest, getParameterList)
-  {
-    Event event{"OPEN_DOOR_EVENT"};
-    ASSERT_TRUE(event.getParameterList().empty());
-  }
-
-  TEST_F(EventTest, removeParameter)
-  {
-    Event event{"OPEN_DOOR_EVENT"};
-    ASSERT_TRUE(event.getParameterList().empty());
-
-    event.addParameter(event_parameter("key", "yes"));
-    event.addParameter(event_parameter("facing_door", "yes"));
-
-    ASSERT_TRUE(event.removeParameter("key"));
-    ASSERT_TRUE(event.removeParameter("facing_door"));
-  }
-
-  TEST_F(EventTest, removeParameter_elenent_does_not_exist)
-  {
-    Event event{"OPEN_DOOR_EVENT"};
-
-    ASSERT_FALSE(event.removeParameter("key"));
-    ASSERT_FALSE(event.removeParameter("facing_door"));
-  }
-
-  TEST_F(EventTest, setId)
-  {
-    Event event{"OPEN_DOOR_EVENT"};
-    ASSERT_STREQ("OPEN_DOOR_EVENT", event.getId().c_str());
-
-    event.setId("ANOTHER_EVENT");
-    ASSERT_STREQ("ANOTHER_EVENT", event.getId().c_str());
-  }
-
-  TEST_F(EventTest, setId_empty_parameter)
-  {
-    EXPECT_THROW(
-        {
-          try
-          {
-            Event event{"TMP_ID"};
-            event.setId("");
-          }
-          catch (const IllegalArgumentException &_exception)
-          {
-            throw;
-          }
-        },
-        IllegalArgumentException);
-  }
-}

test/cases/event/NarratorTest.cpp

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

test/cases/event/serialization/SerializableJsonEventTest.cpp

@@ -1,96 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-12-20
- * Changed:         2023-05-19
- *
- * */
-
-#include <gtest/gtest.h>
-#include <ls-std/ls-std-core.hpp>
-#include <ls-std/ls-std-event.hpp>
-
-using ls::std::core::IllegalArgumentException;
-using ls::std::core::type::byte_field;
-using ls::std::core::type::event_parameter;
-using ls::std::core::type::event_parameter_list;
-using ls::std::event::Event;
-using ls::std::event::SerializableJsonEvent;
-using std::make_shared;
-using std::string;
-using testing::Test;
-
-namespace
-{
-  class SerializableJsonEventTest : public Test
-  {
-    public:
-
-      SerializableJsonEventTest() = default;
-      ~SerializableJsonEventTest() override = default;
-  };
-
-  TEST_F(SerializableJsonEventTest, constructor_parameter_not_set)
-  {
-    EXPECT_THROW(
-        {
-          try
-          {
-            SerializableJsonEvent serializable{nullptr};
-          }
-          catch (const IllegalArgumentException &_exception)
-          {
-            throw;
-          }
-        },
-        IllegalArgumentException);
-  }
-
-  TEST_F(SerializableJsonEventTest, marshal)
-  {
-    Event event{"OPEN_DOOR_EVENT"};
-    event.addParameter(event_parameter{"key_available", "true"});
-    event.addParameter(event_parameter{"door_id", "16675"});
-
-    SerializableJsonEvent serializable{make_shared<Event>(event)};
-
-    byte_field data = serializable.marshal();
-    ASSERT_FALSE(data.empty());
-    string expectedString = R"({"id":"OPEN_DOOR_EVENT","parameterList":{"door_id":["door_id","16675"],"key_available":["key_available","true"]}})";
-    ASSERT_STREQ(expectedString.c_str(), data.c_str());
-  }
-
-  TEST_F(SerializableJsonEventTest, unmarshal)
-  {
-    SerializableJsonEvent serializable{make_shared<Event>("TMP_EVENT")};
-    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());
-    event_parameter_list parameterList = serializable.getValue()->getParameterList();
-
-    ASSERT_FALSE(parameterList.empty());
-    ASSERT_EQ(2, parameterList.size());
-    ASSERT_STREQ("16675", parameterList.at("door_id").c_str());
-    ASSERT_STREQ("true", parameterList.at("key_available").c_str());
-  }
-
-  TEST_F(SerializableJsonEventTest, setValue_parameter_not_set)
-  {
-    SerializableJsonEvent serializable{make_shared<Event>("TMP_EVENT")};
-
-    EXPECT_THROW(
-        {
-          try
-          {
-            serializable.setValue(nullptr);
-          }
-          catch (const IllegalArgumentException &_exception)
-          {
-            throw;
-          }
-        },
-        IllegalArgumentException);
-  }
-}

test/classes/event/Colour.cpp

@@ -1,25 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2022-05-14
- * Changed:         2023-05-15
- *
- * */
-
-#include "Colour.hpp"
-
-using ls::std::core::Class;
-using std::string;
-using std::string_view;
-using test::event::Colour;
-
-Colour::Colour(string_view _value) : Class("Colour"), value(_value)
-{}
-
-Colour::~Colour() noexcept = default;
-
-string_view Colour::getValue() const
-{
-  return this->value;
-}

test/classes/event/Colour.hpp

@@ -1,33 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2022-05-14
- * Changed:         2023-05-15
- *
- * */
-
-#ifndef LS_STD_COLOUR_HPP
-#define LS_STD_COLOUR_HPP
-
-#include <ls-std/ls-std-core.hpp>
-#include <string_view>
-
-namespace test::event
-{
-  class Colour : public ls::std::core::Class
-  {
-    public:
-
-      explicit Colour(::std::string_view _value);
-      ~Colour() noexcept override;
-
-      [[nodiscard]] ::std::string_view getValue() const;
-
-    private:
-
-      ::std::string_view value{};
-  };
-}
-
-#endif

test/classes/event/DailyNewsAgency.cpp

@@ -1,42 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-05-15
- *
- * */
-
-#include "DailyNewsAgency.hpp"
-#include <ls-std/ls-std-event.hpp>
-
-using ls::std::core::Class;
-using ls::std::event::Event;
-using std::string;
-using test::event::DailyNewsAgency;
-using test::event::NewsAgency;
-
-DailyNewsAgency::DailyNewsAgency() : NewsAgency("DailyNewsAgency")
-{}
-
-DailyNewsAgency::~DailyNewsAgency() noexcept = default;
-
-void DailyNewsAgency::listen(const Class &_info)
-{
-  Event event = dynamic_cast<const Event &>(_info);
-
-  if (event.getId() == "SeriousNewsEvent")
-  {
-    this->news = this->getName() + ": " + event.getParameterList().at("news");
-  }
-}
-
-void DailyNewsAgency::clear()
-{
-  this->news.clear();
-}
-
-string DailyNewsAgency::getNews() const
-{
-  return this->news;
-}

test/classes/event/DailyNewsAgency.hpp

@@ -1,43 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-05-15
- *
- * */
-
-#ifndef LS_STD_DAILY_NEWS_AGENCY_HPP
-#define LS_STD_DAILY_NEWS_AGENCY_HPP
-
-#include "NewsAgency.hpp"
-#include <ls-std/ls-std-core.hpp>
-#include <map>
-#include <memory>
-#include <string>
-
-namespace test::event
-{
-  class DailyNewsAgency : public test::event::NewsAgency, public ls::std::core::interface_type::IListener
-  {
-    public:
-
-      DailyNewsAgency();
-      ~DailyNewsAgency() noexcept override;
-
-      // implementation
-
-      void listen(const ls::std::core::Class &_info) override;
-
-      // additional functionality
-
-      void clear();
-      [[nodiscard]] ::std::string getNews() const;
-
-    private:
-
-      ::std::string news{};
-  };
-}
-
-#endif

test/classes/event/GossipNewsAgency.cpp

@@ -1,47 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-05-16
- *
- * */
-
-#include "GossipNewsAgency.hpp"
-#include <ls-std/ls-std-event.hpp>
-
-using ls::std::core::Class;
-using ls::std::event::Event;
-using std::string;
-using test::event::GossipNewsAgency;
-using test::event::NewsAgency;
-
-GossipNewsAgency::GossipNewsAgency() : NewsAgency("GossipNewsAgency")
-{}
-
-GossipNewsAgency::~GossipNewsAgency() noexcept = default;
-
-void GossipNewsAgency::listen(const Class &_info)
-{
-  Event event = dynamic_cast<const Event &>(_info);
-
-  if (event.getId() == "SeriousNewsEvent")
-  {
-    this->news = this->getName() + ": " + event.getParameterList().at("news");
-  }
-
-  if (event.getId() == "GossipNewsEvent")
-  {
-    this->news = this->getName() + ": " + event.getParameterList().at("news");
-  }
-}
-
-void GossipNewsAgency::clear()
-{
-  this->news.clear();
-}
-
-string GossipNewsAgency::getNews() const
-{
-  return this->news;
-}

test/classes/event/GossipNewsAgency.hpp

@@ -1,43 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-05-16
- *
- * */
-
-#ifndef LS_STD_GOSSIP_NEWS_AGENCY_HPP
-#define LS_STD_GOSSIP_NEWS_AGENCY_HPP
-
-#include "NewsAgency.hpp"
-#include <ls-std/ls-std-core.hpp>
-#include <map>
-#include <memory>
-#include <string>
-
-namespace test::event
-{
-  class GossipNewsAgency : public test::event::NewsAgency, public ls::std::core::interface_type::IListener
-  {
-    public:
-
-      GossipNewsAgency();
-      ~GossipNewsAgency() noexcept override;
-
-      // implementation
-
-      void listen(const ls::std::core::Class &_info) override;
-
-      // additional functionality
-
-      void clear();
-      [[nodiscard]] ::std::string getNews() const;
-
-    private:
-
-      ::std::string news{};
-  };
-}
-
-#endif

test/classes/event/GossipNewsEvent.cpp

@@ -1,24 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-02-23
- *
- * */
-
-#include "GossipNewsEvent.hpp"
-
-using ls::std::core::type::event_parameter;
-using ls::std::event::Event;
-using std::make_pair;
-using std::string;
-using test::event::GossipNewsEvent;
-
-GossipNewsEvent::GossipNewsEvent(const string &_news) : Event("GossipNewsEvent")
-{
-  event_parameter newsParameter = make_pair("news", _news);
-  this->addParameter(newsParameter);
-}
-
-GossipNewsEvent::~GossipNewsEvent() noexcept = default;

test/classes/event/GossipNewsEvent.hpp

@@ -1,27 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-02-23
- *
- * */
-
-#ifndef LS_STD_GOSSIP_NEWS_EVENT_HPP
-#define LS_STD_GOSSIP_NEWS_EVENT_HPP
-
-#include <ls-std/ls-std-event.hpp>
-#include <string>
-
-namespace test::event
-{
-  class GossipNewsEvent : public ls::std::event::Event
-  {
-    public:
-
-      explicit GossipNewsEvent(const ::std::string &_news);
-      ~GossipNewsEvent() noexcept override;
-  };
-}
-
-#endif

test/classes/event/NewsAgency.cpp

@@ -1,24 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-05-19
- *
- * */
-
-#include "NewsAgency.hpp"
-
-using std::move;
-using std::string;
-using test::event::NewsAgency;
-
-NewsAgency::NewsAgency(string _agencyName) : agencyName(::move(_agencyName))
-{}
-
-NewsAgency::~NewsAgency() = default;
-
-string NewsAgency::getName() const
-{
-  return this->agencyName;
-}

test/classes/event/NewsAgency.hpp

@@ -1,32 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-05-19
- *
- * */
-
-#ifndef LS_STD_NEWS_AGENCY_HPP
-#define LS_STD_NEWS_AGENCY_HPP
-
-#include <string>
-
-namespace test::event
-{
-  class NewsAgency
-  {
-    public:
-
-      explicit NewsAgency(::std::string _agencyName);
-      virtual ~NewsAgency();
-
-      [[nodiscard]] ::std::string getName() const;
-
-    private:
-
-      ::std::string agencyName{};
-  };
-}
-
-#endif

test/classes/event/SeriousNewsEvent.cpp

@@ -1,24 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-02-23
- *
- * */
-
-#include "SeriousNewsEvent.hpp"
-
-using ls::std::core::type::event_parameter;
-using ls::std::event::Event;
-using std::make_pair;
-using std::string;
-using test::event::SeriousNewsEvent;
-
-SeriousNewsEvent::SeriousNewsEvent(const string &_news) : Event("SeriousNewsEvent")
-{
-  event_parameter newsParameter = make_pair("news", _news);
-  this->addParameter(newsParameter);
-}
-
-SeriousNewsEvent::~SeriousNewsEvent() noexcept = default;

test/classes/event/SeriousNewsEvent.hpp

@@ -1,27 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-27
- * Changed:         2023-02-23
- *
- * */
-
-#ifndef LS_STD_SERIOUS_NEWS_EVENT_HPP
-#define LS_STD_SERIOUS_NEWS_EVENT_HPP
-
-#include <ls-std/ls-std-event.hpp>
-#include <string>
-
-namespace test::event
-{
-  class SeriousNewsEvent : public ls::std::event::Event
-  {
-    public:
-
-      explicit SeriousNewsEvent(const ::std::string &_news);
-      ~SeriousNewsEvent() noexcept override;
-  };
-}
-
-#endif

test/classes/event/TestDataCar.cpp

@@ -1,28 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-14
- * Changed:         2023-05-18
- *
- * */
-
-#include "TestDataCar.hpp"
-
-using std::string_view;
-using test::event::TestDataCar;
-
-TestDataCar::TestDataCar() : color("white")
-{}
-
-TestDataCar::~TestDataCar() = default;
-
-string_view TestDataCar::getColor() const
-{
-  return this->color;
-}
-
-void TestDataCar::setColor(string_view _color)
-{
-  this->color = _color;
-}

test/classes/event/TestDataCar.hpp

@@ -1,34 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-14
- * Changed:         2023-05-18
- *
- * */
-
-#ifndef LS_STD_TEST_DATA_CAR_HPP
-#define LS_STD_TEST_DATA_CAR_HPP
-
-#include <string>
-#include <string_view>
-
-namespace test::event
-{
-  class TestDataCar
-  {
-    public:
-
-      TestDataCar();
-      virtual ~TestDataCar();
-
-      [[nodiscard]] ::std::string_view getColor() const;
-      void setColor(::std::string_view _color);
-
-    private:
-
-      ::std::string_view color{};
-  };
-}
-
-#endif

test/classes/event/TestDataMercedesCar.cpp

@@ -1,27 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-14
- * Changed:         2023-02-23
- *
- * */
-
-#include "TestDataMercedesCar.hpp"
-#include "Colour.hpp"
-
-using ls::std::core::Class;
-using test::event::Colour;
-using test::event::TestDataMercedesCar;
-
-TestDataMercedesCar::TestDataMercedesCar() : TestDataCar()
-{
-  this->setColor("blue");
-}
-
-TestDataMercedesCar::~TestDataMercedesCar() noexcept = default;
-
-void TestDataMercedesCar::listen(const Class &_info)
-{
-  this->setColor(dynamic_cast<const Colour &>(_info).getValue());
-}

test/classes/event/TestDataMercedesCar.hpp

@@ -1,29 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-14
- * Changed:         2023-02-23
- *
- * */
-
-#ifndef LS_STD_TEST_DATA_MERCEDES_CAR_HPP
-#define LS_STD_TEST_DATA_MERCEDES_CAR_HPP
-
-#include "TestDataCar.hpp"
-#include <ls-std/ls-std-core.hpp>
-
-namespace test::event
-{
-  class TestDataMercedesCar : public test::event::TestDataCar, public ls::std::core::interface_type::IListener
-  {
-    public:
-
-      TestDataMercedesCar();
-      ~TestDataMercedesCar() noexcept override;
-
-      void listen(const ls::std::core::Class &_info) override;
-  };
-}
-
-#endif

test/ls-std-event-test.hpp

@@ -11,14 +11,6 @@
 #define LS_STD_LS_STD_EVENT_TEST_HPP
 
 #include <classes/event/Button.hpp>
-//#include <classes/event/Colour.hpp>
-//#include <classes/event/DailyNewsAgency.hpp>
-//#include <classes/event/GossipNewsAgency.hpp>
-//#include <classes/event/GossipNewsEvent.hpp>
-//#include <classes/event/NewsAgency.hpp>
 #include <classes/event/OnClickEvent.hpp>
-//#include <classes/event/SeriousNewsEvent.hpp>
-//#include <classes/event/TestDataCar.hpp>
-//#include <classes/event/TestDataMercedesCar.hpp>
 
 #endif