Merge branch 'deprecated_logic_module' of public/ls-standard-library into development

CMakeLists.txt

@@ -18,7 +18,6 @@ set(MODULE_NAME_CORE ls_std_core)
 set(MODULE_NAME_ENCODING ls_std_encoding)
 set(MODULE_NAME_EVENT ls_std_event)
 set(MODULE_NAME_IO ls_std_io)
-set(MODULE_NAME_LOGIC ls_std_logic)
 set(MODULE_NAME_TIME ls_std_time)
 
 set(GOOGLE_TEST_MODULE googletest-1.11.0)
@@ -178,14 +177,6 @@ set(SOURCE_FILES_IO
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/StandardOutputWriter.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/StorableFile.cpp)
 
-set(SOURCE_FILES_LOGIC
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/logic/serialization/SerializableJsonState.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/logic/serialization/SerializableJsonStateConnection.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/logic/serialization/SerializableJsonStateMachine.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/logic/State.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/logic/StateConnection.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/logic/StateMachine.cpp)
-
 set(SOURCE_FILES_TIME
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/time/Date.cpp)
 
@@ -262,15 +253,6 @@ if (${LS_STD_BUILD_WITH_TESTS})
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/io/xml/TestDataFactory.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/io/xml/XmlParserTestWrapper.cpp)
 
-    set(TEST_FILES_LOGIC
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/serialization/SerializableJsonStateConnectionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/serialization/SerializableJsonStateMachineTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/serialization/SerializableJsonStateTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/StateConnectionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/StateMachineTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/StateTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/logic/TestDataFactory.cpp)
-
     set(TEST_FILES_SERIALIZATION
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/JsonTest.cpp)
 
@@ -331,15 +313,6 @@ if (${LS_STD_BUILD_WITH_TESTS})
     add_executable(${MODULE_NAME_IO}_test ${TEST_FILES_IO})
 endif ()
 
-##########################################################
-# Build Tests (logic)
-##########################################################
-
-if (${LS_STD_BUILD_WITH_TESTS})
-    message("${MODULE_NAME_LOGIC}: Building tests...")
-    add_executable(${MODULE_NAME_LOGIC}_test ${TEST_FILES_LOGIC})
-endif ()
-
 ##########################################################
 # Build Tests (time)
 ##########################################################
@@ -361,7 +334,6 @@ if (${LS_STD_BUILD_WITH_TESTS})
             ${TEST_FILES_ENCODING}
             ${TEST_FILES_EVENT}
             ${TEST_FILES_IO}
-            ${TEST_FILES_LOGIC}
             ${TEST_FILES_SERIALIZATION}
             ${TEST_FILES_TIME})
 endif ()
@@ -489,28 +461,6 @@ if (${LS_STD_BUILD_MODULE})
     set_target_properties("${MODULE_NAME_IO}" PROPERTIES DEBUG_POSTFIX "_d")
 endif ()
 
-##########################################################
-# Build Library (logic)
-##########################################################
-
-message("${PROJECT_NAME}: Building ${MODULE_NAME_LOGIC} library version ${PROJECT_VERSION}...")
-
-if (${LS_STD_BUILD_STATIC})
-    add_library("${MODULE_NAME_LOGIC}" STATIC ${SOURCE_FILES_LOGIC})
-    set_target_properties("${MODULE_NAME_LOGIC}" PROPERTIES DEBUG_POSTFIX "_d")
-endif ()
-
-if (${LS_STD_BUILD_SHARED})
-    add_library("${MODULE_NAME_LOGIC}" SHARED ${SOURCE_FILES_LOGIC})
-    target_link_libraries("${MODULE_NAME_LOGIC}" ${MODULE_NAME_CORE})
-    set_target_properties("${MODULE_NAME_LOGIC}" PROPERTIES DEBUG_POSTFIX "_d")
-endif ()
-
-if (${LS_STD_BUILD_MODULE})
-    add_library("${MODULE_NAME_LOGIC}" MODULE ${SOURCE_FILES_LOGIC})
-    set_target_properties("${MODULE_NAME_LOGIC}" PROPERTIES DEBUG_POSTFIX "_d")
-endif ()
-
 ##########################################################
 # Build Library (time)
 ##########################################################
@@ -610,20 +560,6 @@ if (${LS_STD_BUILD_WITH_TESTS})
             "${MODULE_NAME_CORE}")
 endif ()
 
-##########################################################
-# Linking (logic)
-##########################################################
-
-if (${LS_STD_BUILD_WITH_TESTS})
-    message("${MODULE_NAME_LOGIC}: Linking libraries for test application...")
-    target_link_libraries(${MODULE_NAME_LOGIC}_test
-            gtest
-            gmock
-            gtest_main
-            "${MODULE_NAME_LOGIC}"
-            "${MODULE_NAME_CORE}")
-endif ()
-
 ##########################################################
 # Linking (time)
 ##########################################################
@@ -653,6 +589,5 @@ if (${LS_STD_BUILD_WITH_TESTS})
             "${MODULE_NAME_ENCODING}"
             "${MODULE_NAME_EVENT}"
             "${MODULE_NAME_IO}"
-            "${MODULE_NAME_LOGIC}"
             "${MODULE_NAME_TIME}")
 endif ()

README.md

@@ -25,10 +25,6 @@ This submodule comes with an __Event__ class, as well as with handlers and manag
 To handle file operations - or to receive information of a file - this library submodule provides an own __File__ class implementation, which can also be passed to library implemented input or output stream classes.  
 Additionally __XML__ and __KV__ parsing functionalities are provided by this submodule.
 
-#### Logic (Deprecated) ####
-
-Functionalities provided by this submodule support your project with some nice logical features. The first one being provided by it is a state machine.
-
 #### Time ####
 
 A __Date__ class comes with this submodule, which you can use to represent a date and do operations on it. 
@@ -42,7 +38,7 @@ A __Date__ class comes with this submodule, which you can use to represent a dat
 
 #### Improvements ####
 
-- none
+- __logic__ module have been removed from library and can now be found in __ls-game-tool-kit__ library
 
 #### Fixes ####
 

include/ls_std/logic/State.hpp

@@ -1,51 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-05
- * Changed:         2022-07-15
- *
- * */
-
-#ifndef LS_STD_STATE_HPP
-#define LS_STD_STATE_HPP
-
-#include <memory>
-#include <unordered_map>
-#include <ls_std/core/Class.hpp>
-#include <ls_std/core/types/StateMachineTypes.hpp>
-#include "StateConnection.hpp"
-#include <ls_std/core/interface/ISerializable.hpp>
-#include <ls_std/os/dynamic_goal.hpp>
-
-namespace ls::std::logic
-{
-  class [[deprecated("consider using ls_game_tool_kit dependency instead!")]] LS_STD_DYNAMIC_GOAL State : public ls::std::core::Class
-  {
-    public:
-
-      explicit State(const ls::std::core::type::state_id &_id);
-      ~State() override = default;
-
-      // additional functionality
-
-      bool addStateConnection(const ls::std::core::type::state_connection_id &_connectionId, const ::std::shared_ptr<ls::std::logic::State> &_connectedState);
-      bool addStateConnection(const ::std::shared_ptr<ls::std::logic::StateConnection> &_connection);
-      void clearConnections();
-      ::std::unordered_map<ls::std::core::type::state_connection_id, ::std::shared_ptr<ls::std::logic::StateConnection>> getConnectedStates();
-      ls::std::core::type::state_id getId();
-      bool hasConnection(const ls::std::core::type::state_connection_id &_connectionId);
-      void setId(const ls::std::core::type::state_id &_id);
-
-    private:
-
-      ::std::unordered_map<ls::std::core::type::state_connection_id, ::std::shared_ptr<ls::std::logic::StateConnection>> connectedStates{};
-      ls::std::core::type::state_id id{};
-
-      void _assignStateId(const ls::std::core::type::state_id &_id);
-      void _clearConnections();
-      bool _hasConnection(const ls::std::core::type::state_connection_id &_connectionId);
-  };
-}
-
-#endif

include/ls_std/logic/StateConnection.hpp

@@ -1,45 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-10
- * Changed:         2022-07-15
- *
- * */
-
-#ifndef LS_STD_STATE_CONNECTION_HPP
-#define LS_STD_STATE_CONNECTION_HPP
-
-#include <memory>
-#include <ls_std/core/Class.hpp>
-#include <ls_std/core/types/StateMachineTypes.hpp>
-#include <ls_std/os/dynamic_goal.hpp>
-
-namespace ls::std::logic
-{
-  class [[deprecated("consider using ls_game_tool_kit dependency instead!")]] LS_STD_DYNAMIC_GOAL StateConnection : public ls::std::core::Class
-  {
-    public:
-
-      explicit StateConnection(const ls::std::core::type::state_connection_id &_connectionId, const ls::std::core::type::state_id &_stateId);
-      ~StateConnection() override = default;
-
-      ls::std::core::type::state_connection_id getConnectionId();
-      ls::std::core::type::state_id getStateId();
-      [[nodiscard]] bool isPassable() const;
-      void setConnectionId(const ls::std::core::type::state_connection_id &_connectionId);
-      void setStateId(const ls::std::core::type::state_id &_stateId);
-      void updatePassCondition(bool _condition);
-
-    private:
-
-      bool condition{};
-      ls::std::core::type::state_connection_id connectionId{};
-      ls::std::core::type::state_id stateId{};
-
-      void _assignConnectionId(const ls::std::core::type::state_connection_id &_connectionId);
-      void _assignStateId(const ls::std::core::type::state_id &_stateId);
-  };
-}
-
-#endif

include/ls_std/logic/StateMachine.hpp

@@ -1,57 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-05
- * Changed:         2022-07-15
- *
- * */
-
-#ifndef LS_STD_STATE_MACHINE_HPP
-#define LS_STD_STATE_MACHINE_HPP
-
-#include <memory>
-#include <unordered_map>
-#include <string>
-#include <vector>
-#include <ls_std/core/Class.hpp>
-#include "State.hpp"
-#include <ls_std/core/types/StateMachineTypes.hpp>
-#include <ls_std/os/dynamic_goal.hpp>
-
-namespace ls::std::logic
-{
-  class [[deprecated("consider using ls_game_tool_kit dependency instead!")]] LS_STD_DYNAMIC_GOAL StateMachine : public ls::std::core::Class
-  {
-    public:
-
-      explicit StateMachine(const ::std::string &_name);
-      ~StateMachine() override = default;
-
-      bool addState(const ::std::shared_ptr<ls::std::logic::State> &_state);
-      ::std::shared_ptr<ls::std::logic::State> getCurrentState();
-      ::std::vector<ls::std::core::type::state_id> getMemory();
-      ::std::string getName();
-      ::std::unordered_map<ls::std::core::type::state_id, ::std::shared_ptr<ls::std::logic::State>> getStates();
-      bool hasState(const ls::std::core::type::state_id &_id);
-      bool proceed();
-      void setMemory(const ::std::vector<ls::std::core::type::state_id> &_memory);
-      void setName(const ::std::string &_name);
-      bool setStartState(const ls::std::core::type::state_id &_id);
-
-    private:
-
-      ::std::shared_ptr<ls::std::logic::State> currentState{};
-      ::std::vector<ls::std::core::type::state_id> memory{};
-      ::std::string name{};
-      ::std::unordered_map<ls::std::core::type::state_id, ::std::shared_ptr<ls::std::logic::State>> states{};
-
-      void _assignMemory(const ::std::vector<ls::std::core::type::state_id> &_memory);
-      void _assignName(const ::std::string &_name);
-      ::std::vector<ls::std::core::type::state_id> _getNextValidStates();
-      void _remember(const ls::std::core::type::state_id &_id);
-      bool _hasState(const ls::std::core::type::state_id &_id);
-  };
-}
-
-#endif

include/ls_std/logic/serialization/SerializableJsonState.hpp

@@ -1,52 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-15
- * Changed:         2022-07-15
- *
- * */
-
-#ifndef LS_STD_SERIALIZABLE_JSON_STATE_HPP
-#define LS_STD_SERIALIZABLE_JSON_STATE_HPP
-
-#include <memory>
-#include <ls_std/core/types/Types.hpp>
-#include <ls_std/logic/State.hpp>
-#include <ls_std/core/interface/ISerializable.hpp>
-#include <ls_std/core/Class.hpp>
-#include <ls_std/os/dynamic_goal.hpp>
-
-namespace ls::std::logic
-{
-  class [[deprecated("consider using ls_game_tool_kit dependency instead!")]] LS_STD_DYNAMIC_GOAL SerializableJsonState : public ls::std::core::Class, public ls::std::core::interface_type::ISerializable
-  {
-    public:
-
-      explicit SerializableJsonState(const ::std::shared_ptr<ls::std::logic::State> &_value);
-      ~SerializableJsonState() override = default;
-
-      // implementation
-
-      ls::std::core::type::byte_field marshal() override;
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
-
-      // additional functionality
-
-      ::std::shared_ptr<ls::std::logic::State> getValue();
-      void setValue(const ::std::shared_ptr<ls::std::logic::State> &_value);
-
-    private:
-
-      ls::std::core::type::json jsonObject{};
-      ::std::shared_ptr<ls::std::logic::State> value{};
-
-      void _assignValue(const ::std::shared_ptr<ls::std::logic::State> &_value);
-      void _clear();
-      void _unmarshalStateConnections();
-      void _update();
-      void _updateStateConnections();
-  };
-}
-
-#endif

include/ls_std/logic/serialization/SerializableJsonStateConnection.hpp

@@ -1,50 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-14
- * Changed:         2022-07-15
- *
- * */
-
-#ifndef LS_STD_SERIALIZABLE_JSON_STATE_CONNECTION_HPP
-#define LS_STD_SERIALIZABLE_JSON_STATE_CONNECTION_HPP
-
-#include <memory>
-#include <ls_std/core/types/Types.hpp>
-#include <ls_std/core/Class.hpp>
-#include <ls_std/core/interface/ISerializable.hpp>
-#include <ls_std/logic/StateConnection.hpp>
-#include <ls_std/os/dynamic_goal.hpp>
-
-namespace ls::std::logic
-{
-  class [[deprecated("consider using ls_game_tool_kit dependency instead!")]] LS_STD_DYNAMIC_GOAL SerializableJsonStateConnection : public ls::std::core::Class, public ls::std::core::interface_type::ISerializable
-  {
-    public:
-
-      explicit SerializableJsonStateConnection(const ::std::shared_ptr<ls::std::logic::StateConnection> &_value);
-      ~SerializableJsonStateConnection() override = default;
-
-      // implementation
-
-      ls::std::core::type::byte_field marshal() override;
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
-
-      // additional functionality
-
-      ::std::shared_ptr<ls::std::logic::StateConnection> getValue();
-      void setValue(const ::std::shared_ptr<ls::std::logic::StateConnection> &_value);
-
-    private:
-
-      ls::std::core::type::json jsonObject{};
-      ::std::shared_ptr<ls::std::logic::StateConnection> value{};
-
-      void _assignValue(const ::std::shared_ptr<ls::std::logic::StateConnection> &_value);
-      void _clear();
-      void _update();
-  };
-}
-
-#endif

include/ls_std/logic/serialization/SerializableJsonStateMachine.hpp

@@ -1,53 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-17
- * Changed:         2022-07-15
- *
- * */
-
-#ifndef LS_STD_SERIALIZABLE_JSON_STATE_MACHINE_HPP
-#define LS_STD_SERIALIZABLE_JSON_STATE_MACHINE_HPP
-
-#include <ls_std/core/Class.hpp>
-#include <ls_std/core/interface/ISerializable.hpp>
-#include <ls_std/logic/StateMachine.hpp>
-#include <memory>
-#include <ls_std/core/types/Types.hpp>
-#include <ls_std/os/dynamic_goal.hpp>
-
-namespace ls::std::logic
-{
-  class [[deprecated("consider using ls_game_tool_kit dependency instead!")]] LS_STD_DYNAMIC_GOAL SerializableJsonStateMachine : public ls::std::core::Class, public ls::std::core::interface_type::ISerializable
-  {
-    public:
-
-      explicit SerializableJsonStateMachine(const ::std::shared_ptr<ls::std::logic::StateMachine> &_value);
-      ~SerializableJsonStateMachine() override = default;
-
-      // implementation
-
-      ls::std::core::type::byte_field marshal() override;
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
-
-      // additional functionality
-
-      ::std::shared_ptr<ls::std::logic::StateMachine> getValue();
-      void setValue(const ::std::shared_ptr<ls::std::logic::StateMachine> &_value);
-
-    private:
-
-      ls::std::core::type::json jsonObject{};
-      ::std::shared_ptr<ls::std::logic::StateMachine> value{};
-
-      void _assignValue(const ::std::shared_ptr<ls::std::logic::StateMachine> &_value);
-      void _unmarshalCurrentState();
-      void _unmarshalStates();
-      void _update();
-      void _updateCurrentState();
-      void _updateStates();
-  };
-}
-
-#endif

include/ls_std/ls_std_logic.hpp

@@ -1,20 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2022-05-15
- * Changed:         2022-05-15
- *
- * */
-
-#ifndef LS_STD_LS_STD_LOGIC_HPP
-#define LS_STD_LS_STD_LOGIC_HPP
-
-#include <ls_std/logic/serialization/SerializableJsonState.hpp>
-#include <ls_std/logic/serialization/SerializableJsonStateConnection.hpp>
-#include <ls_std/logic/serialization/SerializableJsonStateMachine.hpp>
-#include <ls_std/logic/State.hpp>
-#include <ls_std/logic/StateConnection.hpp>
-#include <ls_std/logic/StateMachine.hpp>
-
-#endif

source/ls_std/logic/State.cpp

@@ -1,98 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-05
- * Changed:         2022-05-20
- *
- * */
-
-#include <ls_std/logic/State.hpp>
-#include <ls_std/core/exception/IllegalArgumentException.hpp>
-
-ls::std::logic::State::State(const ls::std::core::type::state_id& _id) : ls::std::core::Class("State")
-{
-  this->_assignStateId(_id);
-}
-
-bool ls::std::logic::State::addStateConnection(const ls::std::core::type::state_connection_id &_connectionId, const ::std::shared_ptr<ls::std::logic::State> &_connectedState)
-{
-  bool added{};
-  ::std::shared_ptr<ls::std::logic::StateConnection> connection{};
-
-  if (_connectionId.empty() || _connectedState == nullptr)
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-  else
-  {
-    if (!this->_hasConnection(_connectionId))
-    {
-      connection = ::std::make_shared<ls::std::logic::StateConnection>(_connectionId, _connectedState->getId());
-      added = this->connectedStates.insert({_connectionId, connection}).second;
-    }
-  }
-
-  return added;
-}
-
-bool ls::std::logic::State::addStateConnection(const ::std::shared_ptr<ls::std::logic::StateConnection> &_connection)
-{
-  bool added;
-
-  if (_connection != nullptr)
-  {
-    added = this->connectedStates.insert({_connection->getConnectionId(), _connection}).second;
-  }
-  else
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-
-  return added;
-}
-
-void ls::std::logic::State::clearConnections()
-{
-  this->_clearConnections();
-}
-
-::std::unordered_map<ls::std::core::type::state_connection_id, ::std::shared_ptr<ls::std::logic::StateConnection>> ls::std::logic::State::getConnectedStates()
-{
-  return this->connectedStates;
-}
-
-ls::std::core::type::state_id ls::std::logic::State::getId()
-{
-  return this->id;
-}
-
-bool ls::std::logic::State::hasConnection(const ls::std::core::type::state_connection_id &_connectionId)
-{
-  return this->_hasConnection(_connectionId);
-}
-
-void ls::std::logic::State::setId(const ls::std::core::type::state_id& _id)
-{
-  this->_assignStateId(_id);
-}
-
-void ls::std::logic::State::_assignStateId(const ls::std::core::type::state_id &_id)
-{
-  if (_id.empty())
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-
-  this->id = _id;
-}
-
-void ls::std::logic::State::_clearConnections()
-{
-  this->connectedStates.clear();
-}
-
-bool ls::std::logic::State::_hasConnection(const ls::std::core::type::state_connection_id &_connectionId)
-{
-  return this->connectedStates.find(_connectionId) != this->connectedStates.end();
-}

source/ls_std/logic/StateConnection.cpp

@@ -1,67 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-10
- * Changed:         2022-05-12
- *
- * */
-
-#include <ls_std/logic/StateConnection.hpp>
-#include <ls_std/core/exception/IllegalArgumentException.hpp>
-
-ls::std::logic::StateConnection::StateConnection(const ls::std::core::type::state_connection_id& _connectionId, const ls::std::core::type::state_id& _stateId) : ls::std::core::Class("StateConnection")
-{
-  this->_assignConnectionId(_connectionId);
-  this->_assignStateId(_stateId);
-}
-
-ls::std::core::type::state_connection_id ls::std::logic::StateConnection::getConnectionId()
-{
-  return this->connectionId;
-}
-
-ls::std::core::type::state_id ls::std::logic::StateConnection::getStateId()
-{
-  return this->stateId;
-}
-
-bool ls::std::logic::StateConnection::isPassable() const
-{
-  return this->condition;
-}
-
-void ls::std::logic::StateConnection::setConnectionId(const ls::std::core::type::state_connection_id& _connectionId)
-{
-  this->_assignConnectionId(_connectionId);
-}
-
-void ls::std::logic::StateConnection::setStateId(const ls::std::core::type::state_id& _stateId)
-{
-  this->_assignStateId(_stateId);
-}
-
-void ls::std::logic::StateConnection::updatePassCondition(bool _condition)
-{
-  this->condition = _condition;
-}
-
-void ls::std::logic::StateConnection::_assignConnectionId(const ls::std::core::type::state_connection_id &_connectionId)
-{
-  if (_connectionId.empty())
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-
-  this->connectionId = _connectionId;
-}
-
-void ls::std::logic::StateConnection::_assignStateId(const ls::std::core::type::state_id &_stateId)
-{
-  if (_stateId.empty())
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-
-  this->stateId = _stateId;
-}

source/ls_std/logic/StateMachine.cpp

@@ -1,150 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-05
- * Changed:         2022-05-20
- *
- * */
-
-#include <ls_std/logic/StateMachine.hpp>
-#include <ls_std/core/exception/IllegalArgumentException.hpp>
-
-ls::std::logic::StateMachine::StateMachine(const ::std::string& _name) : ls::std::core::Class("StateMachine")
-{
-  this->_assignName(_name);
-}
-
-bool ls::std::logic::StateMachine::addState(const ::std::shared_ptr<ls::std::logic::State> &_state)
-{
-  bool wasAdded{};
-
-  if (_state == nullptr)
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-  else
-  {
-    if (!this->_hasState(_state->getId()))
-    {
-      wasAdded = this->states.insert({_state->getId(), _state}).second;
-    }
-  }
-
-  return wasAdded;
-}
-
-::std::shared_ptr<ls::std::logic::State> ls::std::logic::StateMachine::getCurrentState()
-{
-  return this->currentState;
-}
-
-::std::vector<ls::std::core::type::state_id> ls::std::logic::StateMachine::getMemory()
-{
-  return this->memory;
-}
-
-::std::string ls::std::logic::StateMachine::getName()
-{
-  return this->name;
-}
-
-::std::unordered_map<ls::std::core::type::state_id, ::std::shared_ptr<ls::std::logic::State>> ls::std::logic::StateMachine::getStates()
-{
-  return this->states;
-}
-
-bool ls::std::logic::StateMachine::hasState(const ls::std::core::type::state_id &_id)
-{
-  return this->_hasState(_id);
-}
-
-bool ls::std::logic::StateMachine::proceed()
-{
-  ::std::vector<ls::std::core::type::state_id> nextValidStates = this->_getNextValidStates();
-  bool onlyOneWayToGo = nextValidStates.size() == 1;
-
-  if (onlyOneWayToGo)
-  {
-    this->currentState = this->states[nextValidStates.at(0)];
-    this->_remember(nextValidStates.at(0));
-  }
-
-  return onlyOneWayToGo;
-}
-
-void ls::std::logic::StateMachine::setMemory(const ::std::vector<ls::std::core::type::state_id>& _memory)
-{
-  this->_assignMemory(_memory);
-}
-
-void ls::std::logic::StateMachine::setName(const ::std::string& _name)
-{
-  this->_assignName(_name);
-}
-
-bool ls::std::logic::StateMachine::setStartState(const ls::std::core::type::state_id &_id)
-{
-  bool startStateSet{};
-
-  if (_id.empty())
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-  else
-  {
-    if (this->_hasState(_id))
-    {
-      this->currentState = this->states[_id];
-      this->_remember(_id);
-      startStateSet = true;
-    }
-  }
-
-  return startStateSet;
-}
-
-void ls::std::logic::StateMachine::_assignMemory(const ::std::vector<ls::std::core::type::state_id> &_memory)
-{
-  if (_memory.empty())
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-
-  this->memory = _memory;
-}
-
-void ls::std::logic::StateMachine::_assignName(const ::std::string &_name)
-{
-  if (_name.empty())
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-
-  this->name = _name;
-}
-
-::std::vector<ls::std::core::type::state_id> ls::std::logic::StateMachine::_getNextValidStates()
-{
-  ::std::vector<ls::std::core::type::state_id> validStates{};
-
-  for (const auto &state : this->currentState->getConnectedStates())
-  {
-    if (state.second->isPassable())
-    {
-      validStates.push_back(state.second->getStateId());
-    }
-  }
-
-  return validStates;
-}
-
-void ls::std::logic::StateMachine::_remember(const ls::std::core::type::state_id &_id)
-{
-  this->memory.push_back(_id);
-}
-
-bool ls::std::logic::StateMachine::_hasState(const ls::std::core::type::state_id &_id)
-{
-  return this->states.find(_id) != this->states.end();
-}

source/ls_std/logic/serialization/SerializableJsonState.cpp

@@ -1,90 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-15
- * Changed:         2022-07-14
- *
- * */
-
-#include <ls_std/logic/serialization/SerializableJsonState.hpp>
-#include <ls_std/logic/serialization/SerializableJsonStateConnection.hpp>
-#include <ls_std/core/exception/IllegalArgumentException.hpp>
-
-ls::std::logic::SerializableJsonState::SerializableJsonState(const ::std::shared_ptr<ls::std::logic::State> &_value) : ls::std::core::Class("SerializableJsonState")
-{
-  this->_assignValue(_value);
-}
-
-ls::std::core::type::byte_field ls::std::logic::SerializableJsonState::marshal()
-{
-  this->_update();
-  return this->jsonObject.dump();
-}
-
-void ls::std::logic::SerializableJsonState::unmarshal(const ls::std::core::type::byte_field &_data)
-{
-  this->jsonObject = ls::std::core::type::json::parse(_data);
-
-  this->_unmarshalStateConnections();
-  this->value->setId(this->jsonObject["id"]);
-}
-
-::std::shared_ptr<ls::std::logic::State> ls::std::logic::SerializableJsonState::getValue()
-{
-  return this->value;
-}
-
-void ls::std::logic::SerializableJsonState::setValue(const ::std::shared_ptr<ls::std::logic::State> &_value)
-{
-  this->_assignValue(_value);
-  this->_clear();
-}
-
-void ls::std::logic::SerializableJsonState::_assignValue(const ::std::shared_ptr<ls::std::logic::State> &_value)
-{
-  if (_value == nullptr)
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-
-  this->value = _value;
-}
-
-void ls::std::logic::SerializableJsonState::_clear()
-{
-  this->jsonObject.clear();
-}
-
-void ls::std::logic::SerializableJsonState::_unmarshalStateConnections()
-{
-  if (!this->jsonObject["connectedStates"].empty())
-  {
-    this->value->clearConnections();
-
-    for (const auto &connectionJson : this->jsonObject["connectedStates"])
-    {
-      ::std::shared_ptr<ls::std::logic::StateConnection> connection = ::std::make_shared<ls::std::logic::StateConnection>("TMP_ID", "TMP_ID");
-      ls::std::logic::SerializableJsonStateConnection{connection}.unmarshal(connectionJson.dump());
-      this->value->addStateConnection(connection);
-    }
-  }
-}
-
-void ls::std::logic::SerializableJsonState::_update()
-{
-  this->jsonObject = {{"id", this->value->getId()}};
-
-  this->_updateStateConnections();
-}
-
-void ls::std::logic::SerializableJsonState::_updateStateConnections()
-{
-  ::std::string jsonString{};
-
-  for (const auto &connection : this->value->getConnectedStates())
-  {
-    jsonString = ls::std::logic::SerializableJsonStateConnection{connection.second}.marshal();
-    this->jsonObject["connectedStates"][connection.first] = ls::std::core::type::json::parse(jsonString);
-  }
-}

source/ls_std/logic/serialization/SerializableJsonStateConnection.cpp

@@ -1,65 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-14
- * Changed:         2022-07-14
- *
- * */
-
-#include <ls_std/logic/serialization/SerializableJsonStateConnection.hpp>
-#include <ls_std/core/exception/IllegalArgumentException.hpp>
-
-ls::std::logic::SerializableJsonStateConnection::SerializableJsonStateConnection(const ::std::shared_ptr<ls::std::logic::StateConnection> &_value) : ls::std::core::Class("SerializableJsonStateConnection")
-{
-  this->_assignValue(_value);
-}
-
-ls::std::core::type::byte_field ls::std::logic::SerializableJsonStateConnection::marshal()
-{
-  this->_update();
-  return this->jsonObject.dump();
-}
-
-void ls::std::logic::SerializableJsonStateConnection::unmarshal(const ls::std::core::type::byte_field &_data)
-{
-  ::std::string jsonString = ::std::string(_data);
-  this->jsonObject = ls::std::core::type::json::parse(jsonString);
-
-  this->value->setConnectionId(this->jsonObject["connectionId"]);
-  this->value->setStateId(this->jsonObject["stateId"]);
-  this->value->updatePassCondition(this->jsonObject["condition"]);
-}
-
-::std::shared_ptr<ls::std::logic::StateConnection> ls::std::logic::SerializableJsonStateConnection::getValue()
-{
-  return this->value;
-}
-
-void ls::std::logic::SerializableJsonStateConnection::setValue(const ::std::shared_ptr<ls::std::logic::StateConnection> &_value)
-{
-  this->_assignValue(_value);
-  this->_clear();
-}
-
-void ls::std::logic::SerializableJsonStateConnection::_assignValue(const ::std::shared_ptr<ls::std::logic::StateConnection> &_value)
-{
-  if (_value == nullptr)
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-
-  this->value = _value;
-}
-
-void ls::std::logic::SerializableJsonStateConnection::_clear()
-{
-  this->jsonObject.clear();
-}
-
-void ls::std::logic::SerializableJsonStateConnection::_update()
-{
-  this->jsonObject = {{"condition",    this->value->isPassable()},
-                      {"connectionId", this->value->getConnectionId()},
-                      {"stateId",      this->value->getStateId()}};
-}

source/ls_std/logic/serialization/SerializableJsonStateMachine.cpp

@@ -1,99 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-17
- * Changed:         2022-07-14
- *
- * */
-
-#include <ls_std/logic/serialization/SerializableJsonStateMachine.hpp>
-#include <ls_std/logic/serialization/SerializableJsonState.hpp>
-#include <ls_std/core/exception/IllegalArgumentException.hpp>
-
-ls::std::logic::SerializableJsonStateMachine::SerializableJsonStateMachine(const ::std::shared_ptr<ls::std::logic::StateMachine> &_value) : ls::std::core::Class("SerializableJsonStateMachine")
-{
-  this->_assignValue(_value);
-}
-
-ls::std::core::type::byte_field ls::std::logic::SerializableJsonStateMachine::marshal()
-{
-  this->_update();
-  return this->jsonObject.dump();
-}
-
-void ls::std::logic::SerializableJsonStateMachine::unmarshal(const ls::std::core::type::byte_field &_data)
-{
-  this->jsonObject = ls::std::core::type::json::parse(_data);
-
-  this->_unmarshalStates();
-  this->_unmarshalCurrentState();
-  this->value->setMemory(this->jsonObject["memory"]);
-  this->value->setName(this->jsonObject["name"]);
-}
-
-::std::shared_ptr<ls::std::logic::StateMachine> ls::std::logic::SerializableJsonStateMachine::getValue()
-{
-  return this->value;
-}
-
-void ls::std::logic::SerializableJsonStateMachine::setValue(const ::std::shared_ptr<ls::std::logic::StateMachine> &_value)
-{
-  this->_assignValue(_value);
-}
-
-void ls::std::logic::SerializableJsonStateMachine::_assignValue(const ::std::shared_ptr<ls::std::logic::StateMachine> &_value)
-{
-  if (_value == nullptr)
-  {
-    throw ls::std::core::IllegalArgumentException{};
-  }
-
-  this->value = _value;
-}
-
-void ls::std::logic::SerializableJsonStateMachine::_unmarshalCurrentState()
-{
-  if (this->jsonObject.contains("currentState"))
-  {
-    this->value->setStartState(this->jsonObject["currentState"]);
-  }
-}
-
-void ls::std::logic::SerializableJsonStateMachine::_unmarshalStates()
-{
-  for (const auto &serializedState : this->jsonObject["states"])
-  {
-    ::std::shared_ptr<ls::std::logic::State> state = ::std::make_shared<ls::std::logic::State>("TMP_ID");
-    ls::std::logic::SerializableJsonState{state}.unmarshal(serializedState.dump());
-    this->value->addState(state);
-  }
-}
-
-void ls::std::logic::SerializableJsonStateMachine::_update()
-{
-  this->jsonObject = {{"memory", this->value->getMemory()},
-                      {"name",   this->value->getName()}};
-
-  this->_updateCurrentState();
-  this->_updateStates();
-}
-
-void ls::std::logic::SerializableJsonStateMachine::_updateCurrentState()
-{
-  if (this->value->getCurrentState() != nullptr)
-  {
-    this->jsonObject["currentState"] = this->value->getCurrentState()->getId();
-  }
-}
-
-void ls::std::logic::SerializableJsonStateMachine::_updateStates()
-{
-  ::std::string jsonString{};
-
-  for (const auto &state : this->value->getStates())
-  {
-    jsonString = ls::std::logic::SerializableJsonState{state.second}.marshal();
-    this->jsonObject["states"][state.first] = ls::std::core::type::json::parse(jsonString);
-  }
-}

test/cases/logic/StateConnectionTest.cpp

@@ -1,138 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-10
- * Changed:         2022-05-15
- *
- * */
-
-#include <gtest/gtest.h>
-#include <ls_std/ls_std_core.hpp>
-#include <ls_std/ls_std_logic.hpp>
-
-namespace
-{
-  class StateConnectionTest : public ::testing::Test
-  {
-    protected:
-
-      StateConnectionTest() = default;
-      ~StateConnectionTest() override = default;
-
-      void SetUp() override
-      {}
-
-      void TearDown() override
-      {}
-  };
-
-  TEST_F(StateConnectionTest, getClassName)
-  {
-    ls::std::logic::StateConnection connection{"AB", "B"};
-    ASSERT_STREQ("StateConnection", connection.getClassName().c_str());
-  }
-
-  TEST_F(StateConnectionTest, constructor_empty_connection_id)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::logic::StateConnection connection = ls::std::logic::StateConnection("", "B");
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(StateConnectionTest, constructor_empty_state_id)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::logic::StateConnection connection = ls::std::logic::StateConnection("AB", "");
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(StateConnectionTest, getConnectionId)
-  {
-    ls::std::logic::StateConnection connection{"AB", "B"};
-    ASSERT_STREQ("AB", connection.getConnectionId().c_str());
-  }
-
-  TEST_F(StateConnectionTest, getStateId)
-  {
-    ls::std::logic::StateConnection connection{"AB", "B"};
-    ASSERT_STREQ("B", connection.getStateId().c_str());
-  }
-
-  TEST_F(StateConnectionTest, isPassable)
-  {
-    ls::std::logic::StateConnection connection{"AB", "B"};
-    ASSERT_FALSE(connection.isPassable());
-  }
-
-  TEST_F(StateConnectionTest, setConnectionId)
-  {
-    ls::std::logic::StateConnection connection{"AB", "B"};
-    ASSERT_STREQ("AB", connection.getConnectionId().c_str());
-
-    connection.setConnectionId("BC");
-    ASSERT_STREQ("BC", connection.getConnectionId().c_str());
-  }
-
-  TEST_F(StateConnectionTest, setConnectionId_empty_connection_id)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::logic::StateConnection connection = ls::std::logic::StateConnection("AB", "B");
-                     connection.setConnectionId("");
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(StateConnectionTest, setStateId)
-  {
-    ls::std::logic::StateConnection connection{"AB", "B"};
-    ASSERT_STREQ("B", connection.getStateId().c_str());
-
-    connection.setStateId("C");
-    ASSERT_STREQ("C", connection.getStateId().c_str());
-  }
-
-  TEST_F(StateConnectionTest, setStateId_empty_state_id)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::logic::StateConnection connection = ls::std::logic::StateConnection("AB", "B");
-                     connection.setStateId("");
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(StateConnectionTest, updatePassCondition)
-  {
-    ls::std::logic::StateConnection connection{"AB", "B"};
-
-    ASSERT_FALSE(connection.isPassable());
-    connection.updatePassCondition(true);
-    ASSERT_TRUE(connection.isPassable());
-  }
-}

test/cases/logic/StateMachineTest.cpp

@@ -1,245 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-09
- * Changed:         2022-05-20
- *
- * */
-
-#include <gtest/gtest.h>
-#include <ls_std/ls_std_core.hpp>
-#include <ls_std/ls_std_logic.hpp>
-#include <ls_std_logic_test.hpp>
-
-namespace
-{
-  class StateMachineTest : public ::testing::Test
-  {
-    protected:
-
-      StateMachineTest() = default;
-      ~StateMachineTest() override = default;
-
-      void SetUp() override
-      {}
-
-      void TearDown() override
-      {}
-  };
-
-  TEST_F(StateMachineTest, getClassName)
-  {
-    ls::std::logic::StateMachine stateMachine {"machine"};
-    ASSERT_STREQ("StateMachine", stateMachine.getClassName().c_str());
-  }
-
-  TEST_F(StateMachineTest, constructor_empty_name)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::logic::StateMachine stateMachine {""};
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(StateMachineTest, addState)
-  {
-    ls::std::logic::StateMachine stateMachine{"test_machine"};
-    ASSERT_TRUE(stateMachine.addState(::std::make_shared<ls::std::logic::State>("A")));
-  }
-
-  TEST_F(StateMachineTest, addState_state_already_exists)
-  {
-    ls::std::logic::StateMachine stateMachine{"test_machine"};
-    ASSERT_TRUE(stateMachine.addState(::std::make_shared<ls::std::logic::State>("A")));
-    ASSERT_FALSE(stateMachine.addState(::std::make_shared<ls::std::logic::State>("A")));
-  }
-
-  TEST_F(StateMachineTest, addState_no_reference)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::logic::StateMachine stateMachine{"test_machine"};
-                     stateMachine.addState(nullptr);
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(StateMachineTest, getCurrentState)
-  {
-    ls::std::logic::StateMachine stateMachine{"test_machine"};
-    ASSERT_TRUE(stateMachine.addState(::std::make_shared<ls::std::logic::State>("A")));
-
-    ASSERT_TRUE(stateMachine.getCurrentState() == nullptr);
-  }
-
-  TEST_F(StateMachineTest, getMemory)
-  {
-    ls::std::logic::StateMachine stateMachine {"machine"};
-    ASSERT_TRUE(stateMachine.getMemory().empty());
-  }
-
-  TEST_F(StateMachineTest, getName)
-  {
-    ls::std::logic::StateMachine stateMachine{"test_machine"};
-    ASSERT_STREQ("test_machine", stateMachine.getName().c_str());
-  }
-
-  TEST_F(StateMachineTest, getStates)
-  {
-    ls::std::logic::StateMachine stateMachine {"machine"};
-    ASSERT_TRUE(stateMachine.getStates().empty());
-  }
-
-  TEST_F(StateMachineTest, hasState)
-  {
-    ls::std::logic::StateMachine stateMachine = ls_std_logic_test::TestDataFactory::createStateMachine();
-
-    ASSERT_TRUE(stateMachine.hasState("A"));
-    ASSERT_TRUE(stateMachine.hasState("B"));
-    ASSERT_TRUE(stateMachine.hasState("C"));
-    ASSERT_TRUE(stateMachine.hasState("D"));
-    ASSERT_TRUE(stateMachine.hasState("E"));
-  }
-
-  TEST_F(StateMachineTest, hasState_no_state_available)
-  {
-    ls::std::logic::StateMachine stateMachine {"machine"};
-    ASSERT_FALSE(stateMachine.hasState("F"));
-  }
-
-  TEST_F(StateMachineTest, proceed)
-  {
-    ls::std::logic::StateMachine stateMachine = ls_std_logic_test::TestDataFactory::createStateMachine();
-    ASSERT_STREQ("test_machine", stateMachine.getName().c_str());
-    ASSERT_TRUE(stateMachine.setStartState("A"));
-
-    ASSERT_FALSE(stateMachine.proceed());
-
-    // activate AB
-
-    stateMachine.getCurrentState()->getConnectedStates().at("AB")->updatePassCondition(true);
-    ASSERT_TRUE(stateMachine.proceed());
-    ASSERT_STREQ("B", stateMachine.getCurrentState()->getId().c_str());
-
-    // activate BC and BD
-
-    stateMachine.getCurrentState()->getConnectedStates().at("BC")->updatePassCondition(true);
-    stateMachine.getCurrentState()->getConnectedStates().at("BD")->updatePassCondition(true);
-    ASSERT_FALSE(stateMachine.proceed());
-
-    // BC only!
-
-    stateMachine.getCurrentState()->getConnectedStates().at("BD")->updatePassCondition(false);
-    ASSERT_TRUE(stateMachine.proceed());
-    ASSERT_STREQ("C", stateMachine.getCurrentState()->getId().c_str());
-
-    // activate CB
-
-    stateMachine.getCurrentState()->getConnectedStates().at("CB")->updatePassCondition(true);
-    ASSERT_TRUE(stateMachine.proceed());
-    ASSERT_STREQ("B", stateMachine.getCurrentState()->getId().c_str());
-
-    // BD only!
-
-    stateMachine.getCurrentState()->getConnectedStates().at("BD")->updatePassCondition(true);
-    stateMachine.getCurrentState()->getConnectedStates().at("BC")->updatePassCondition(false);
-    ASSERT_TRUE(stateMachine.proceed());
-    ASSERT_STREQ("D", stateMachine.getCurrentState()->getId().c_str());
-
-    // activate DE
-
-    stateMachine.getCurrentState()->getConnectedStates().at("DE")->updatePassCondition(true);
-    ASSERT_TRUE(stateMachine.proceed());
-    ASSERT_STREQ("E", stateMachine.getCurrentState()->getId().c_str());
-
-    // end reached
-
-    ASSERT_FALSE(stateMachine.proceed());
-    ASSERT_STREQ("E", stateMachine.getCurrentState()->getId().c_str());
-  }
-
-  TEST_F(StateMachineTest, setMemory_no_memory)
-  {
-    ls::std::logic::StateMachine stateMachine{"test_machine"};
-    ::std::vector<ls::std::core::type::state_id> memory{};
-
-    EXPECT_THROW({
-                   try
-                   {
-                     stateMachine.setMemory(memory);
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(StateMachineTest, setName)
-  {
-    ls::std::logic::StateMachine stateMachine{"test_machine"};
-    ASSERT_STREQ("test_machine", stateMachine.getName().c_str());
-
-    stateMachine.setName("bla");
-    ASSERT_STREQ("bla", stateMachine.getName().c_str());
-  }
-
-  TEST_F(StateMachineTest, setName_empty_name)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::logic::StateMachine stateMachine {"machine"};
-                     stateMachine.setName("");
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(StateMachineTest, setStartState)
-  {
-    ls::std::logic::StateMachine stateMachine{"test_machine"};
-    ASSERT_TRUE(stateMachine.getCurrentState() == nullptr);
-    stateMachine.addState(::std::make_shared<ls::std::logic::State>("A"));
-
-    ASSERT_TRUE(stateMachine.setStartState("A"));
-    ASSERT_FALSE(stateMachine.getCurrentState() == nullptr);
-  }
-
-  TEST_F(StateMachineTest, setStartState_state_does_not_exist)
-  {
-    ls::std::logic::StateMachine stateMachine{"test_machine"};
-    ASSERT_FALSE(stateMachine.setStartState("A"));
-  }
-
-  TEST_F(StateMachineTest, setStartState_empty_id)
-  {
-    ls::std::logic::StateMachine stateMachine{"test_machine"};
-
-    EXPECT_THROW({
-                   try
-                   {
-                     stateMachine.setStartState("");
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-}

test/cases/logic/StateTest.cpp

@@ -1,191 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-05
- * Changed:         2022-05-20
- *
- * */
-
-#include <gtest/gtest.h>
-#include <memory>
-#include <ls_std/ls_std_core.hpp>
-#include <ls_std/ls_std_logic.hpp>
-
-namespace
-{
-  class StateTest : public ::testing::Test
-  {
-    protected:
-
-      StateTest() = default;
-      ~StateTest() override = default;
-
-      void SetUp() override
-      {}
-
-      void TearDown() override
-      {}
-  };
-
-  TEST_F(StateTest, getClassName)
-  {
-    ls::std::logic::State state{"A"};
-    ASSERT_STREQ("State", state.getClassName().c_str());
-  }
-
-  TEST_F(StateTest, constructor_empty_id)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::logic::State state = ls::std::logic::State("");
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  // additional functionality
-
-  TEST_F(StateTest, addStateConnection_v1)
-  {
-    ls::std::logic::State stateA{"A"};
-    ls::std::logic::State stateB{"B"};
-
-    ASSERT_TRUE(stateA.addStateConnection("AB", ::std::make_shared<ls::std::logic::State>(stateB)));
-  }
-
-  TEST_F(StateTest, addStateConnection_v1_connection_already_exists)
-  {
-    ls::std::logic::State stateA{"A"};
-    ls::std::logic::State stateB{"B"};
-
-    ASSERT_TRUE(stateA.addStateConnection("AB", ::std::make_shared<ls::std::logic::State>(stateB)));
-    ASSERT_FALSE(stateA.addStateConnection("AB", ::std::make_shared<ls::std::logic::State>(stateB)));
-  }
-
-  TEST_F(StateTest, addStateConnection_v1_empty_connection_id)
-  {
-    ls::std::logic::State state{"A"};
-
-    EXPECT_THROW({
-                   try
-                   {
-                     state.addStateConnection("", ::std::make_shared<ls::std::logic::State>("B"));
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(StateTest, addStateConnection_v1_no_reference)
-  {
-    ls::std::logic::State state{"A"};
-
-    EXPECT_THROW({
-                   try
-                   {
-                     state.addStateConnection("AB", nullptr);
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(StateTest, addStateConnection_v2)
-  {
-    ls::std::logic::State stateA{"A"};
-    ls::std::logic::State stateB{"B"};
-
-    ASSERT_TRUE(stateA.addStateConnection(::std::make_shared<ls::std::logic::StateConnection>("AB", stateB.getId())));
-  }
-
-  TEST_F(StateTest, addStateConnection_v2_no_reference)
-  {
-    ls::std::logic::State stateA{"A"};
-
-    EXPECT_THROW({
-                   try
-                   {
-                     stateA.addStateConnection(nullptr);
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(StateTest, clearConnections)
-  {
-    ls::std::logic::State stateA{"A"};
-    stateA.addStateConnection(::std::make_shared<ls::std::logic::StateConnection>("AB", "B"));
-    stateA.addStateConnection(::std::make_shared<ls::std::logic::StateConnection>("AC", "C"));
-
-    ASSERT_FALSE(stateA.getConnectedStates().empty());
-    stateA.clearConnections();
-    ASSERT_TRUE(stateA.getConnectedStates().empty());
-  }
-
-  TEST_F(StateTest, getConnectedStates)
-  {
-    ls::std::logic::State stateA{"A"};
-    ASSERT_TRUE(stateA.getConnectedStates().empty());
-  }
-
-  TEST_F(StateTest, getId)
-  {
-    ls::std::logic::State stateA{"A"};
-    ASSERT_STREQ("A", stateA.getId().c_str());
-  }
-
-  TEST_F(StateTest, setId)
-  {
-    ls::std::logic::State stateA{"A"};
-    ASSERT_STREQ("A", stateA.getId().c_str());
-
-    stateA.setId("B");
-    ASSERT_STREQ("B", stateA.getId().c_str());
-  }
-
-  TEST_F(StateTest, setId_empty_id)
-  {
-    ls::std::logic::State stateA{"A"};
-
-    EXPECT_THROW({
-                   try
-                   {
-                     stateA.setId("");
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(StateTest, hasConnection)
-  {
-    ls::std::logic::State stateA{"A"};
-    ls::std::logic::State stateB{"B"};
-    ls::std::logic::State stateC{"C"};
-
-    ASSERT_TRUE(stateA.addStateConnection("AB", ::std::make_shared<ls::std::logic::State>(stateB)));
-    ASSERT_TRUE(stateA.hasConnection("AB"));
-    ASSERT_TRUE(stateA.addStateConnection("AC", ::std::make_shared<ls::std::logic::State>(stateC)));
-    ASSERT_TRUE(stateA.hasConnection("AC"));
-  }
-
-  TEST_F(StateTest, hasConnection_no_connections_available)
-  {
-    ls::std::logic::State stateA{"A"};
-    ASSERT_FALSE(stateA.hasConnection("AB"));
-  }
-}

test/cases/logic/serialization/SerializableJsonStateConnectionTest.cpp

@@ -1,111 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-14
- * Changed:         2022-05-20
- *
- * */
-
-#include <gtest/gtest.h>
-#include <ls_std/ls_std_core.hpp>
-#include <ls_std/ls_std_logic.hpp>
-
-namespace
-{
-  class SerializableJsonStateConnectionTest : public ::testing::Test
-  {
-    protected:
-
-      SerializableJsonStateConnectionTest() = default;
-      ~SerializableJsonStateConnectionTest() override = default;
-
-      void SetUp() override
-      {}
-
-      void TearDown() override
-      {}
-  };
-
-  TEST_F(SerializableJsonStateConnectionTest, constructor_no_parameter_set)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::logic::SerializableJsonStateConnection serializable{nullptr};
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  // implementation
-
-  TEST_F(SerializableJsonStateConnectionTest, marshal)
-  {
-    ls::std::logic::StateConnection x{"AB", "B"};
-    ls::std::logic::SerializableJsonStateConnection serializable{::std::make_shared<ls::std::logic::StateConnection>(x)};
-    ::std::string jsonString{serializable.marshal()};
-
-    ASSERT_STREQ(R"({"condition":false,"connectionId":"AB","stateId":"B"})", jsonString.c_str());
-  }
-
-  TEST_F(SerializableJsonStateConnectionTest, unmarshal)
-  {
-    ::std::shared_ptr<ls::std::logic::StateConnection> x = ::std::make_shared<ls::std::logic::StateConnection>("AB", "B");
-    ASSERT_STREQ("AB", x->getConnectionId().c_str());
-    ASSERT_STREQ("B", x->getStateId().c_str());
-    ASSERT_FALSE(x->isPassable());
-
-    ls::std::logic::SerializableJsonStateConnection serializable{x};
-    serializable.unmarshal(R"({"condition":true,"connectionId":"BC","stateId":"C"})");
-
-    ASSERT_STREQ("BC", x->getConnectionId().c_str());
-    ASSERT_STREQ("C", x->getStateId().c_str());
-    ASSERT_TRUE(x->isPassable());
-  }
-
-  TEST_F(SerializableJsonStateConnectionTest, getValue)
-  {
-    ::std::shared_ptr<ls::std::logic::StateConnection> x = ::std::make_shared<ls::std::logic::StateConnection>("AB", "B");
-    ls::std::logic::SerializableJsonStateConnection serializable{x};
-    ASSERT_TRUE(serializable.getValue() == x);
-  }
-
-  TEST_F(SerializableJsonStateConnectionTest, setValue)
-  {
-    ls::std::logic::StateConnection x{"AB", "B"};
-    ls::std::logic::SerializableJsonStateConnection serializable{::std::make_shared<ls::std::logic::StateConnection>(x)};
-    ::std::string jsonString{serializable.marshal()};
-
-    ASSERT_STREQ(R"({"condition":false,"connectionId":"AB","stateId":"B"})", jsonString.c_str());
-
-    // set value should now reset json
-
-    ls::std::logic::StateConnection y{"BC", "C"};
-    serializable.setValue(::std::make_shared<ls::std::logic::StateConnection>(y));
-    jsonString = serializable.marshal();
-
-    ASSERT_STREQ(R"({"condition":false,"connectionId":"BC","stateId":"C"})", jsonString.c_str());
-    //I love YOU
-  }
-
-  TEST_F(SerializableJsonStateConnectionTest, setValue_no_parameter_set)
-  {
-    ls::std::logic::StateConnection stateConnection{"AB", "B"};
-    ls::std::logic::SerializableJsonStateConnection serializable{::std::make_shared<ls::std::logic::StateConnection>(stateConnection)};
-
-    EXPECT_THROW({
-                   try
-                   {
-                     serializable.setValue(nullptr);
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-}

test/cases/logic/serialization/SerializableJsonStateMachineTest.cpp

@@ -1,156 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-17
- * Changed:         2022-05-20
- *
- * */
-
-#include <gtest/gtest.h>
-#include <ls_std/ls_std_core.hpp>
-#include <ls_std/ls_std_logic.hpp>
-#include <ls_std_logic_test.hpp>
-#include "TestHelper.hpp"
-
-namespace
-{
-  class SerializableJsonStateMachineTest : public ::testing::Test
-  {
-    protected:
-
-      SerializableJsonStateMachineTest() = default;
-      ~SerializableJsonStateMachineTest() override = default;
-
-      void SetUp() override
-      {}
-
-      void TearDown() override
-      {}
-  };
-
-  TEST_F(SerializableJsonStateMachineTest, constructor_no_parameter_set)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::logic::SerializableJsonStateMachine serializable{nullptr};
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  // implementation
-
-  TEST_F(SerializableJsonStateMachineTest, marshal)
-  {
-    ls::std::logic::StateMachine stateMachine = ls_std_logic_test::TestDataFactory::createStateMachine();
-    stateMachine.setStartState("A");
-    stateMachine.setMemory({"A", "B", "C"});
-    ls::std::logic::SerializableJsonStateMachine serializable{::std::make_shared<ls::std::logic::StateMachine>(stateMachine)};
-
-    ::std::string jsonString = serializable.marshal();
-    ASSERT_TRUE(!jsonString.empty());
-
-    ::std::string path = ls_std_test::TestHelper::getResourcesFolderLocation() + "/state_machine_test.json";
-    path = ls_std_test::TestHelper::normalize(path);
-    ::std::string content = ls_std_test::TestHelper::readFile(path);
-
-    ASSERT_TRUE(content.find(jsonString) != ::std::string::npos);
-  }
-
-  TEST_F(SerializableJsonStateMachineTest, unmarshal)
-  {
-    ::std::string path = ls_std_test::TestHelper::getResourcesFolderLocation() + "/state_machine_test.json";
-    path = ls_std_test::TestHelper::normalize(path);
-
-    ::std::shared_ptr<ls::std::logic::StateMachine> machine = ::std::make_shared<ls::std::logic::StateMachine>("bla");
-    ls::std::logic::SerializableJsonStateMachine serializable{machine};
-
-    serializable.unmarshal(ls_std_test::TestHelper::readFile(path));
-
-    ASSERT_STREQ("test_machine", machine->getName().c_str());
-
-    // check memory
-
-    ASSERT_FALSE(machine->getMemory().empty());
-    ASSERT_EQ(3, machine->getMemory().size());
-    ASSERT_STREQ("A", machine->getMemory().at(0).c_str());
-    ASSERT_STREQ("B", machine->getMemory().at(1).c_str());
-    ASSERT_STREQ("C", machine->getMemory().at(2).c_str());
-
-    // check current state
-
-    ASSERT_TRUE(machine->getCurrentState() != nullptr);
-    ASSERT_STREQ("A", machine->getCurrentState()->getId().c_str());
-
-    // check states
-
-    ASSERT_TRUE(!machine->getStates().empty());
-    ASSERT_EQ(5, machine->getStates().size());
-
-    ::std::shared_ptr<ls::std::logic::State> state = machine->getStates().at("A");
-    ASSERT_STREQ("A", state->getId().c_str());
-    ASSERT_EQ(1, state->getConnectedStates().size());
-    ASSERT_STREQ("AB", state->getConnectedStates().at("AB")->getConnectionId().c_str());
-
-    state = machine->getStates().at("B");
-    ASSERT_STREQ("B", state->getId().c_str());
-    ASSERT_EQ(2, state->getConnectedStates().size());
-    ASSERT_STREQ("BC", state->getConnectedStates().at("BC")->getConnectionId().c_str());
-    ASSERT_STREQ("BD", state->getConnectedStates().at("BD")->getConnectionId().c_str());
-
-    state = machine->getStates().at("C");
-    ASSERT_STREQ("C", state->getId().c_str());
-    ASSERT_EQ(2, state->getConnectedStates().size());
-    ASSERT_STREQ("CB", state->getConnectedStates().at("CB")->getConnectionId().c_str());
-    ASSERT_STREQ("CE", state->getConnectedStates().at("CE")->getConnectionId().c_str());
-
-    state = machine->getStates().at("D");
-    ASSERT_STREQ("D", state->getId().c_str());
-    ASSERT_EQ(1, state->getConnectedStates().size());
-    ASSERT_STREQ("DE", state->getConnectedStates().at("DE")->getConnectionId().c_str());
-
-    state = machine->getStates().at("E");
-    ASSERT_STREQ("E", state->getId().c_str());
-    ASSERT_TRUE(state->getConnectedStates().empty());
-  }
-
-  TEST_F(SerializableJsonStateMachineTest, getValue)
-  {
-    ::std::shared_ptr<ls::std::logic::StateMachine> x = ::std::make_shared<ls::std::logic::StateMachine>("bla");
-    ls::std::logic::SerializableJsonStateMachine serializable{x};
-    ASSERT_TRUE(serializable.getValue() == x);
-  }
-
-  TEST_F(SerializableJsonStateMachineTest, setValue)
-  {
-    ::std::shared_ptr<ls::std::logic::StateMachine> x = ::std::make_shared<ls::std::logic::StateMachine>("bla");
-    ls::std::logic::SerializableJsonStateMachine serializable{x};
-    ASSERT_TRUE(serializable.getValue() == x);
-
-    x = ::std::make_shared<ls::std::logic::StateMachine>("bla2");
-    serializable.setValue(x);
-    ASSERT_TRUE(serializable.getValue() == x);
-  }
-
-  TEST_F(SerializableJsonStateMachineTest, setValue_no_parameter_set)
-  {
-    ::std::shared_ptr<ls::std::logic::StateMachine> stateMachine = ::std::make_shared<ls::std::logic::StateMachine>("bla");
-    ls::std::logic::SerializableJsonStateMachine serializable{stateMachine};
-
-    EXPECT_THROW({
-                   try
-                   {
-                     serializable.setValue(nullptr);
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-}

test/cases/logic/serialization/SerializableJsonStateTest.cpp

@@ -1,124 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-15
- * Changed:         2022-05-20
- *
- * */
-
-#include <gtest/gtest.h>
-#include <ls_std/ls_std_core.hpp>
-#include <ls_std/ls_std_logic.hpp>
-
-namespace
-{
-  class SerializableJsonStateTest : public ::testing::Test
-  {
-    protected:
-
-      SerializableJsonStateTest() = default;
-      ~SerializableJsonStateTest() override = default;
-
-      void SetUp() override
-      {}
-
-      void TearDown() override
-      {}
-  };
-
-  TEST_F(SerializableJsonStateTest, constructor_no_parameter_set)
-  {
-    EXPECT_THROW({
-                   try
-                   {
-                     ls::std::logic::SerializableJsonState serializable{nullptr};
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-
-  TEST_F(SerializableJsonStateTest, marshal)
-  {
-    ::std::shared_ptr<ls::std::logic::State> x = ::std::make_shared<ls::std::logic::State>("A");
-    x->addStateConnection(::std::make_shared<ls::std::logic::StateConnection>("AB", "B"));
-    x->addStateConnection(::std::make_shared<ls::std::logic::StateConnection>("AC", "C"));
-
-    ls::std::logic::SerializableJsonState serializable{x};
-    ls::std::core::type::byte_field jsonString = serializable.marshal();
-
-    ASSERT_TRUE(!jsonString.empty());
-    ::std::string expectedJson = R"({"connectedStates":{"AB":{"condition":false,"connectionId":"AB","stateId":"B"},"AC":{"condition":false,"connectionId":"AC","stateId":"C"}},"id":"A"})";
-    ASSERT_STREQ(expectedJson.c_str(), jsonString.c_str());
-  }
-
-  TEST_F(SerializableJsonStateTest, unmarshal)
-  {
-    ::std::shared_ptr<ls::std::logic::State> x = ::std::make_shared<ls::std::logic::State>("A");
-    ls::std::logic::SerializableJsonState serializable{x};
-
-    // before
-
-    ASSERT_STREQ("A", x->getId().c_str());
-    ASSERT_TRUE(x->getConnectedStates().empty());
-
-    // after
-
-    ::std::string jsonString = R"({"id":"A","connectedStates":{"AB":{"condition":false,"connectionId":"AB","stateId":"B"}}})";
-    serializable.unmarshal(jsonString);
-
-    ASSERT_STREQ("A", x->getId().c_str());
-    ASSERT_EQ(1, x->getConnectedStates().size());
-    ASSERT_STREQ("AB", x->getConnectedStates().at("AB")->getConnectionId().c_str());
-    ASSERT_FALSE(x->getConnectedStates().at("AB")->isPassable());
-    ASSERT_STREQ("B", x->getConnectedStates().at("AB")->getStateId().c_str());
-  }
-
-  TEST_F(SerializableJsonStateTest, getValue)
-  {
-    ::std::shared_ptr<ls::std::logic::State> x = ::std::make_shared<ls::std::logic::State>("A");
-    ls::std::logic::SerializableJsonState serializable{x};
-    ASSERT_TRUE(serializable.getValue() == x);
-  }
-
-  TEST_F(SerializableJsonStateTest, setValue)
-  {
-    ::std::shared_ptr<ls::std::logic::State> x = ::std::make_shared<ls::std::logic::State>("A");
-    x->addStateConnection(::std::make_shared<ls::std::logic::StateConnection>("AB", "B"));
-    x->addStateConnection(::std::make_shared<ls::std::logic::StateConnection>("AC", "C"));
-
-    ls::std::logic::SerializableJsonState serializable{x};
-    ls::std::core::type::byte_field jsonString = serializable.marshal();
-
-    ::std::string expectedJson = R"({"connectedStates":{"AB":{"condition":false,"connectionId":"AB","stateId":"B"},"AC":{"condition":false,"connectionId":"AC","stateId":"C"}},"id":"A"})";
-    ASSERT_STREQ(expectedJson.c_str(), jsonString.c_str());
-
-    // setValue should now clear json
-
-    ::std::shared_ptr<ls::std::logic::State> y = ::std::make_shared<ls::std::logic::State>("B");
-    serializable.setValue(y);
-    jsonString = serializable.marshal();
-
-    ASSERT_STREQ(R"({"id":"B"})", jsonString.c_str());
-  }
-
-  TEST_F(SerializableJsonStateTest, setValue_parameter_not_set)
-  {
-    ::std::shared_ptr<ls::std::logic::State> state = ::std::make_shared<ls::std::logic::State>("A");
-    ls::std::logic::SerializableJsonState serializable{state};
-
-    EXPECT_THROW({
-                   try
-                   {
-                     serializable.setValue(nullptr);
-                   }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
-                   {
-                     throw;
-                   }
-                 }, ls::std::core::IllegalArgumentException);
-  }
-}

test/classes/logic/TestDataFactory.cpp

@@ -1,40 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-16
- * Changed:         2022-05-20
- *
- * */
-
-#include "TestDataFactory.hpp"
-
-ls::std::logic::StateMachine ls_std_logic_test::TestDataFactory::createStateMachine()
-{
-  ls::std::logic::StateMachine stateMachine{"test_machine"};
-
-  ::std::shared_ptr<ls::std::logic::State> stateA = ::std::make_shared<ls::std::logic::State>("A");
-  ::std::shared_ptr<ls::std::logic::State> stateB = ::std::make_shared<ls::std::logic::State>("B");
-  ::std::shared_ptr<ls::std::logic::State> stateC = ::std::make_shared<ls::std::logic::State>("C");
-  ::std::shared_ptr<ls::std::logic::State> stateD = ::std::make_shared<ls::std::logic::State>("D");
-  ::std::shared_ptr<ls::std::logic::State> stateE = ::std::make_shared<ls::std::logic::State>("E");
-
-  // add states
-
-  stateMachine.addState(stateA);
-  stateMachine.addState(stateB);
-  stateMachine.addState(stateC);
-  stateMachine.addState(stateD);
-  stateMachine.addState(stateE);
-
-  // add connections / see state_machine_test.png
-
-  stateA->addStateConnection("AB", stateB);
-  stateB->addStateConnection("BC", stateC);
-  stateB->addStateConnection("BD", stateD);
-  stateC->addStateConnection("CB", stateB);
-  stateC->addStateConnection("CE", stateE);
-  stateD->addStateConnection("DE", stateE);
-
-  return stateMachine;
-}

test/classes/logic/TestDataFactory.hpp

@@ -1,28 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-16
- * Changed:         2022-05-15
- *
- * */
-
-#ifndef LS_STD_TEST_DATA_FACTORY_HPP
-#define LS_STD_TEST_DATA_FACTORY_HPP
-
-#include <ls_std/ls_std_logic.hpp>
-
-namespace ls_std_logic_test
-{
-  class TestDataFactory
-  {
-    public:
-
-      TestDataFactory() = default;
-      ~TestDataFactory() = default;
-
-      static ls::std::logic::StateMachine createStateMachine();
-  };
-}
-
-#endif

test/ls_std_logic_test.hpp

@@ -1,15 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2022-05-15
- * Changed:         2022-05-15
- *
- * */
-
-#ifndef LS_STD_LS_STD_LOGIC_TEST_HPP
-#define LS_STD_LS_STD_LOGIC_TEST_HPP
-
-#include <classes/logic/TestDataFactory.hpp>
-
-#endif