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

CMakeLists.txt

@@ -5,6 +5,13 @@
 cmake_minimum_required(VERSION 3.17)
 project(ls_std VERSION 2022.1.0)
 
+set(MODULE_NAME_BOXING ls_std_boxing)
+set(MODULE_NAME_CORE ls_std_core)
+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)
+
 ##########################################################
 # Options
 ##########################################################
@@ -51,110 +58,186 @@ endif ()
 # Source Files
 ##########################################################
 
-set(SOURCE_FILES
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/base/Class.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/boxing/Integer.cpp
+set(SOURCE_FILES_BOXING
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/boxing/Boolean.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/boxing/Float.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/boxing/Double.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/boxing/String.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/time/Date.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/File.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/boxing/Float.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/boxing/Integer.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/boxing/Long.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/FileWriter.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/FileReader.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/StorableFile.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/FileOutputStream.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/boxing/String.cpp)
+
+set(SOURCE_FILES_CORE
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/core/Class.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/core/Version.cpp)
+
+set(SOURCE_FILES_EVENT
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/serialization/SerializableJsonEvent.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/Event.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/EventHandler.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/EventManager.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/Narrator.cpp)
+
+set(SOURCE_FILES_IO
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KvDocument.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KvFileReader.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KvPair.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KvParser.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/logging/Logger.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/logging/LogLevel.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/logic/StateMachine.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/serialization/json/logic/SerializableJsonStateConnection.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/logic/SerializableJsonState.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/logic/SerializableJsonStateMachine.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlAttribute.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlNode.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/base/Version.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlDeclaration.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlDocument.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlNode.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlParser.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlReader.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/File.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/FileOutputStream.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/FileReader.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/FileWriter.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/StandardOutputWriter.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/logic/Narrator.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlParser.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/serialization/json/event/SerializableJsonEvent.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KvPair.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KvDocument.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KvParser.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KvFileReader.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)
 
 if (${LS_STD_BUILD_WITH_TESTS})
-    set(TEST_FILES
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/boxing/IntegerTest.cpp
+    set(TEST_FILES_BOXING
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/boxing/BooleanTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/boxing/FloatTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/boxing/DoubleTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/boxing/StringTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/time/DateTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/FileTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/TestHelper.hpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/base/ClassTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/utils/STLUtilsTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/boxing/FloatTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/boxing/IntegerTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/boxing/LongTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/FileWriterTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/FileReaderTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/utils/RegexUtilsTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/StorableFileTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/FileOutputStreamTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/logging/LoggerTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/JsonTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/StateTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/StateMachineTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/StateConnectionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/logic/SerializableJsonStateConnectionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/logic/SerializableJsonStateTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/logic/SerializableJsonStateMachineTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/TestDataFactory.hpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/TestDataFactory.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlAttributeTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlNodeTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/base/VersionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlDeclarationTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlDocumentTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlReaderTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlParserTestWrapperTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/observer/TestDataCar.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/observer/TestDataMercedesCar.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/NarratorTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlParserTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/boxing/StringTest.cpp)
+
+    set(TEST_FILES_CORE
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/exception/EventNotHandledExceptionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/exception/EventNotSubscribedExceptionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/exception/FileNotFoundExceptionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/exception/FileOperationExceptionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/exception/IllegalArgumentExceptionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/exception/IllegalArithmeticOperationExceptionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/exception/IncompleteJsonExceptionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/exception/NullPointerExceptionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/utils/RegexUtilsTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/utils/STLUtilsTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/ClassTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/LibraryVersionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/VersionTest.cpp)
+
+    set(TEST_FILES_EVENT
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/event/serialization/SerializableJsonEventTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/event/EventHandlerTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/event/EventManagerTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/event/EventTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/NewsAgency.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/SeriousNewsEvent.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/GossipNewsEvent.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/GossipNewsAgency.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/serialization/json/event/SerializableJsonEventTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KvPairTest.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(TEST_FILES_IO
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KvDocumentTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KvParserTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KvFileReaderTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/EventNotHandledExceptionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/EventNotSubscribedExceptionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/FileNotFoundExceptionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/FileOperationExceptionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/IllegalArgumentExceptionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/IllegalArithmeticOperationExceptionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/IncompleteJsonExceptionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/NullPointerExceptionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/io/xml/XmlParserTestWrapper.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/base/LibraryVersionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KvPairTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KvParserTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/logging/LoggerTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/logging/LogLevelTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/StandardOutputWriterTest.cpp)
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlAttributeTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlDeclarationTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlDocumentTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlNodeTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlParserTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlParserTestWrapperTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlReaderTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/FileOutputStreamTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/FileReaderTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/FileTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/FileWriterTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/StandardOutputWriterTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/StorableFileTest.cpp
+            ${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)
+
+    set(TEST_FILES_TIME
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/time/DateTest.cpp)
+endif ()
+
+##########################################################
+# Build Tests (boxing)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS})
+    message("${MODULE_NAME_BOXING}: Building tests...")
+    add_executable(${MODULE_NAME_BOXING}_test ${TEST_FILES_BOXING})
+endif ()
+
+##########################################################
+# Build Tests (core)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS})
+    message("${MODULE_NAME_CORE}: Building tests...")
+    add_executable(${MODULE_NAME_CORE}_test ${TEST_FILES_CORE})
+endif ()
+
+##########################################################
+# Build Tests (event)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS})
+    message("${MODULE_NAME_EVENT}: Building tests...")
+    add_executable(${MODULE_NAME_EVENT}_test ${TEST_FILES_EVENT})
+endif ()
+
+##########################################################
+# Build Tests (io)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS})
+    message("${MODULE_NAME_IO}: Building 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)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS})
+    message("${MODULE_NAME_TIME}: Building tests...")
+    add_executable(${MODULE_NAME_TIME}_test ${TEST_FILES_TIME})
 endif ()
 
 ##########################################################
@@ -163,28 +246,173 @@ endif ()
 
 if (${LS_STD_BUILD_WITH_TESTS})
     message("${PROJECT_NAME}: Building tests...")
-    add_executable(${PROJECT_NAME}_test ${TEST_FILES})
+    add_executable(${PROJECT_NAME}_test
+            ${TEST_FILES_BOXING}
+            ${TEST_FILES_CORE}
+            ${TEST_FILES_EVENT}
+            ${TEST_FILES_IO}
+            ${TEST_FILES_LOGIC}
+            ${TEST_FILES_SERIALIZATION}
+            ${TEST_FILES_TIME})
 endif ()
 
 ##########################################################
-# Build Library
+# Build Library (boxing)
 ##########################################################
 
-message("${PROJECT_NAME}: Building library version ${PROJECT_VERSION}...")
+message("${PROJECT_NAME}: Building ${MODULE_NAME_BOXING} library version ${PROJECT_VERSION}...")
 
 if (${LS_STD_BUILD_STATIC})
-    add_library("${PROJECT_NAME}_${PROJECT_VERSION}_static" STATIC ${SOURCE_FILES})
-    set_target_properties("${PROJECT_NAME}_${PROJECT_VERSION}_static" PROPERTIES DEBUG_POSTFIX "_d")
+    add_library("${MODULE_NAME_BOXING}" STATIC ${SOURCE_FILES_BOXING})
+    set_target_properties("${MODULE_NAME_BOXING}" PROPERTIES DEBUG_POSTFIX "_d")
 endif ()
 
 if (${LS_STD_BUILD_SHARED})
-    add_library("${PROJECT_NAME}_${PROJECT_VERSION}_shared" SHARED ${SOURCE_FILES})
-    set_target_properties("${PROJECT_NAME}_${PROJECT_VERSION}_shared" PROPERTIES DEBUG_POSTFIX "_d")
+    add_library("${MODULE_NAME_BOXING}" SHARED ${SOURCE_FILES_BOXING})
+    set_target_properties("${MODULE_NAME_BOXING}" PROPERTIES DEBUG_POSTFIX "_d")
 endif ()
 
 if (${LS_STD_BUILD_MODULE})
-    add_library("${PROJECT_NAME}_${PROJECT_VERSION}_module" MODULE ${SOURCE_FILES})
-    set_target_properties("${PROJECT_NAME}_${PROJECT_VERSION}_module" PROPERTIES DEBUG_POSTFIX "_d")
+    add_library("${MODULE_NAME_BOXING}" MODULE ${SOURCE_FILES_BOXING})
+    set_target_properties("${MODULE_NAME_BOXING}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+##########################################################
+# Build Library (core)
+##########################################################
+
+message("${PROJECT_NAME}: Building ${MODULE_NAME_CORE} library version ${PROJECT_VERSION}...")
+
+if (${LS_STD_BUILD_STATIC})
+    add_library("${MODULE_NAME_CORE}" STATIC ${SOURCE_FILES_CORE})
+    set_target_properties("${MODULE_NAME_CORE}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+##########################################################
+# Build Library (event)
+##########################################################
+
+message("${PROJECT_NAME}: Building ${MODULE_NAME_EVENT} library version ${PROJECT_VERSION}...")
+
+if (${LS_STD_BUILD_STATIC})
+    add_library("${MODULE_NAME_EVENT}" STATIC ${SOURCE_FILES_EVENT})
+    set_target_properties("${MODULE_NAME_EVENT}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+##########################################################
+# Build Library (io)
+##########################################################
+
+message("${PROJECT_NAME}: Building ${MODULE_NAME_IO} library version ${PROJECT_VERSION}...")
+
+if (${LS_STD_BUILD_STATIC})
+    add_library("${MODULE_NAME_IO}" STATIC ${SOURCE_FILES_IO})
+    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 ()
+
+##########################################################
+# Build Library (time)
+##########################################################
+
+message("${PROJECT_NAME}: Building ${MODULE_NAME_TIME} library version ${PROJECT_VERSION}...")
+
+if (${LS_STD_BUILD_STATIC})
+    add_library("${MODULE_NAME_TIME}" STATIC ${SOURCE_FILES_TIME})
+    set_target_properties("${MODULE_NAME_TIME}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+##########################################################
+# Linking (boxing)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS})
+    message("${MODULE_NAME_BOXING}: Linking libraries for test application...")
+    target_link_libraries(${MODULE_NAME_BOXING}_test
+            gtest
+            gmock
+            gtest_main
+            "${MODULE_NAME_BOXING}"
+            "${MODULE_NAME_CORE}")
+endif ()
+
+##########################################################
+# Linking (core)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS})
+    message("${MODULE_NAME_CORE}: Linking libraries for test application...")
+    target_link_libraries(${MODULE_NAME_CORE}_test
+            gtest
+            gmock
+            gtest_main
+            "${MODULE_NAME_CORE}")
+endif ()
+
+##########################################################
+# Linking (event)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS})
+    message("${MODULE_NAME_EVENT}: Linking libraries for test application...")
+    target_link_libraries(${MODULE_NAME_EVENT}_test
+            gtest
+            gmock
+            gtest_main
+            "${MODULE_NAME_EVENT}"
+            "${MODULE_NAME_CORE}")
+endif ()
+
+##########################################################
+# Linking (io)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS})
+    message("${MODULE_NAME_IO}: Linking libraries for test application...")
+    target_link_libraries(${MODULE_NAME_IO}_test
+            gtest
+            gmock
+            gtest_main
+            "${MODULE_NAME_IO}"
+            "${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)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS})
+    message("${MODULE_NAME_TIME}: Linking libraries for test application...")
+    target_link_libraries(${MODULE_NAME_TIME}_test
+            gtest
+            gmock
+            gtest_main
+            "${MODULE_NAME_TIME}"
+            "${MODULE_NAME_CORE}")
 endif ()
 
 ##########################################################
@@ -193,5 +421,14 @@ endif ()
 
 if (${LS_STD_BUILD_WITH_TESTS})
     message("${PROJECT_NAME}: Linking libraries for test application...")
-    target_link_libraries(${PROJECT_NAME}_test gtest gmock gtest_main "${PROJECT_NAME}_${PROJECT_VERSION}_static")
+    target_link_libraries(${PROJECT_NAME}_test
+            gtest
+            gmock
+            gtest_main
+            "${MODULE_NAME_CORE}"
+            "${MODULE_NAME_BOXING}"
+            "${MODULE_NAME_EVENT}"
+            "${MODULE_NAME_IO}"
+            "${MODULE_NAME_LOGIC}"
+            "${MODULE_NAME_TIME}")
 endif ()

include/ls_std/base/Class.hpp

@@ -1,34 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-08-07
- * Changed:         2021-04-24
- *
- * */
-
-#ifndef LS_STD_CLASS_HPP
-#define LS_STD_CLASS_HPP
-
-#include <string>
-
-namespace ls_std
-{
-  class Class
-  {
-    public:
-
-      explicit Class(const std::string &_name);
-      virtual ~Class() = default;
-
-      std::string getClassName();
-
-    private:
-
-      std::string name{};
-
-      void _assignClassName(const std::string &_name);
-  };
-}
-
-#endif

include/ls_std/base/Types.hpp

@@ -1,23 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-08-07
- * Changed:         2021-04-23
- *
- * */
-
-#ifndef LS_STD_TYPES_HPP
-#define LS_STD_TYPES_HPP
-
-#include <string>
-
-namespace ls_std
-{
-  using byte = char;
-  using byte_field = std::string;
-  using long_type = long long int;
-  using version_type = uint16_t;
-}
-
-#endif

include/ls_std/base/Version.hpp

@@ -1,51 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-27
- * Changed:         2021-04-24
- *
- * */
-
-#ifndef LS_STD_VERSION_HPP
-#define LS_STD_VERSION_HPP
-
-#include "Class.hpp"
-#include <ls_std/serialization/ISerializable.hpp>
-#include "Types.hpp"
-
-namespace ls_std
-{
-  class Version : public ls_std::ISerializable
-  {
-    public:
-
-      explicit Version(ls_std::version_type _majorVersion, ls_std::version_type _minorVersion, ls_std::version_type _patchVersion);
-      ~Version() = default;
-
-      // implementation
-
-      ls_std::byte_field marshal() override;
-      void unmarshal(const ls_std::byte_field &_data) override;
-
-      // other functionality
-
-      ls_std::version_type getMajorVersion() const;
-      ls_std::version_type getMinorVersion() const;
-      ls_std::version_type getPatchVersion() const;
-      static bool isValid(const std::string &_versionString);
-      void setMajorVersion(ls_std::version_type _major);
-      void setMinorVersion(ls_std::version_type _minor);
-      void setPatchVersion(ls_std::version_type _patch);
-
-    private:
-
-      ls_std::version_type majorVersion{};
-      ls_std::version_type minorVersion{};
-      ls_std::version_type patchVersion{};
-
-      static bool _isValid(const std::string &_versionString);
-  };
-}
-
-#endif

include/ls_std/boxing/Boolean.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2021-07-08
+ * Changed:         2022-05-16
  *
  * */
 
@@ -11,73 +11,79 @@
 #define LS_STD_BOOLEAN_HPP
 
 #include <memory>
-#include <ls_std/base/Class.hpp>
-#include "IBoxing.hpp"
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/interface/IBoxing.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class Boolean : public ls_std::Class, public ls_std::IBoxing
+  namespace std
   {
-    public:
+    namespace boxing
+    {
+      class Boolean : public ls::std::core::Class, public ls::std::core::interface::IBoxing
+      {
+        public:
 
-      explicit Boolean(bool _value);
-      Boolean();
-      ~Boolean() override = default;
+          explicit Boolean(bool _value);
+          Boolean();
+          ~Boolean() override = default;
 
-      // conversion operator
+          // conversion operator
 
-      operator bool() const;
+          operator bool() const;
 
-      // assignment operators
+          // assignment operators
 
-      ls_std::Boolean &operator=(int _value);
-      ls_std::Boolean &operator=(bool _value);
+          ls::std::boxing::Boolean &operator=(int _value);
+          ls::std::boxing::Boolean &operator=(bool _value);
 
-      // stream operators
+          // stream operators
 
-      friend std::ostream &operator<<(std::ostream &_outputStream, const ls_std::Boolean &_boolean)
-      {
-        _outputStream << _boolean._toString();
-        return _outputStream;
-      }
+          friend ::std::ostream &operator<<(::std::ostream &_outputStream, const ls::std::boxing::Boolean &_boolean)
+          {
+            _outputStream << _boolean._toString();
+            return _outputStream;
+          }
 
-      // logical operators
+          // logical operators
 
-      friend bool operator!(const ls_std::Boolean &_boolean)
-      {
-        return !_boolean.value;
-      }
+          friend bool operator!(const ls::std::boxing::Boolean &_boolean)
+          {
+            return !_boolean.value;
+          }
 
-      bool operator&&(const ls_std::Boolean &_boolean) const;
-      bool operator&&(bool _value) const;
-      bool operator&&(int _value) const;
-      bool operator||(const ls_std::Boolean &_boolean) const;
-      bool operator||(bool _value) const;
-      bool operator||(int _value) const;
-      // INFO: operator ^ can not be taken for XOR, since it's not possible to implement it respecting commutative law
+          bool operator&&(const ls::std::boxing::Boolean &_boolean) const;
+          bool operator&&(bool _value) const;
+          bool operator&&(int _value) const;
+          bool operator||(const ls::std::boxing::Boolean &_boolean) const;
+          bool operator||(bool _value) const;
+          bool operator||(int _value) const;
+          // INFO: operator ^ can not be taken for XOR, since it's not possible to implement it respecting commutative law
 
-      // implementation
+          // implementation
 
-      void parse(std::string _parseText) override;
-      std::string toString() override;
+          void parse(::std::string _parseText) override;
+          ::std::string toString() override;
 
-      // additional functionality
+          // additional functionality
 
-      bool getValue() const;
-      static bool XOR(const ls_std::Boolean &_leftExpression, const ls_std::Boolean &_rightExpression);
-      static bool XOR(const ls_std::Boolean &_leftExpression, bool _rightExpression);
-      static bool XOR(bool _leftExpression, const ls_std::Boolean &_rightExpression);
-      static bool XOR(bool _leftExpression, bool _rightExpression);
+          bool getValue() const;
+          static bool XOR(const ls::std::boxing::Boolean &_leftExpression, const ls::std::boxing::Boolean &_rightExpression);
+          static bool XOR(const ls::std::boxing::Boolean &_leftExpression, bool _rightExpression);
+          static bool XOR(bool _leftExpression, const ls::std::boxing::Boolean &_rightExpression);
+          static bool XOR(bool _leftExpression, bool _rightExpression);
 
-    private:
+        private:
 
-      bool value{};
+          bool value{};
 
-      const std::string FALSE_STRING = "false";
-      const std::string TRUE_STRING = "true";
+          const ::std::string FALSE_STRING = "false";
+          const ::std::string TRUE_STRING = "true";
 
-      std::string _toString() const;
-  };
+          ::std::string _toString() const;
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/boxing/Double.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2021-07-12
+ * Changed:         2022-05-16
  *
  * */
 
@@ -11,88 +11,94 @@
 #define LS_STD_DOUBLE_HPP
 
 #include <memory>
-#include <ls_std/base/Class.hpp>
-#include "IBoxing.hpp"
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/interface/IBoxing.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class Double : public ls_std::Class, public ls_std::IBoxing
+  namespace std
   {
-    public:
+    namespace boxing
+    {
+      class Double : public ls::std::core::Class, public ls::std::core::interface::IBoxing
+      {
+        public:
 
-      Double();
-      explicit Double(double _value);
-      ~Double() override = default;
+          Double();
+          explicit Double(double _value);
+          ~Double() override = default;
 
-      // conversion operator
+          // conversion operator
 
-      operator double() const; // do not make explicit!
+          operator double() const; // do not make explicit!
 
-      // assignment operators
+          // assignment operators
 
-      ls_std::Double &operator=(double _value);
+          ls::std::boxing::Double &operator=(double _value);
 
-      // arithmetic operators
+          // arithmetic operators
 
-      double operator-() const;
-      double operator+(const ls_std::Double &_double) const;
-      double operator+(double _value) const;
-      double operator*(const ls_std::Double &_double) const;
-      double operator*(double _value) const;
-      double operator-(const ls_std::Double &_double) const;
-      double operator-(double _value) const;
-      double operator/(const ls_std::Double &_double) const;
-      double operator/(double _value) const;
+          double operator-() const;
+          double operator+(const ls::std::boxing::Double &_double) const;
+          double operator+(double _value) const;
+          double operator*(const ls::std::boxing::Double &_double) const;
+          double operator*(double _value) const;
+          double operator-(const ls::std::boxing::Double &_double) const;
+          double operator-(double _value) const;
+          double operator/(const ls::std::boxing::Double &_double) const;
+          double operator/(double _value) const;
 
-      // compound operators
+          // compound operators
 
-      ls_std::Double &operator+=(const ls_std::Double &_double);
-      ls_std::Double &operator+=(double _value);
-      ls_std::Double &operator-=(const ls_std::Double &_double);
-      ls_std::Double &operator-=(double _value);
-      ls_std::Double &operator*=(const ls_std::Double &_double);
-      ls_std::Double &operator*=(double _value);
-      ls_std::Double &operator/=(const ls_std::Double &_double);
-      ls_std::Double &operator/=(double _value);
+          ls::std::boxing::Double &operator+=(const ls::std::boxing::Double &_double);
+          ls::std::boxing::Double &operator+=(double _value);
+          ls::std::boxing::Double &operator-=(const ls::std::boxing::Double &_double);
+          ls::std::boxing::Double &operator-=(double _value);
+          ls::std::boxing::Double &operator*=(const ls::std::boxing::Double &_double);
+          ls::std::boxing::Double &operator*=(double _value);
+          ls::std::boxing::Double &operator/=(const ls::std::boxing::Double &_double);
+          ls::std::boxing::Double &operator/=(double _value);
 
-      // comparison operators
+          // comparison operators
 
-      bool operator==(const ls_std::Double &_double) const;
-      bool operator==(double _value) const;
-      bool operator!=(const ls_std::Double &_double) const;
-      bool operator!=(double _value) const;
-      bool operator>(const ls_std::Double &_double) const;
-      bool operator>(double _value) const;
-      bool operator>=(const ls_std::Double &_double) const;
-      bool operator>=(double _value) const;
-      bool operator<(const ls_std::Double &_double) const;
-      bool operator<(double _value) const;
-      bool operator<=(const ls_std::Double &_double) const;
-      bool operator<=(double _value) const;
+          bool operator==(const ls::std::boxing::Double &_double) const;
+          bool operator==(double _value) const;
+          bool operator!=(const ls::std::boxing::Double &_double) const;
+          bool operator!=(double _value) const;
+          bool operator>(const ls::std::boxing::Double &_double) const;
+          bool operator>(double _value) const;
+          bool operator>=(const ls::std::boxing::Double &_double) const;
+          bool operator>=(double _value) const;
+          bool operator<(const ls::std::boxing::Double &_double) const;
+          bool operator<(double _value) const;
+          bool operator<=(const ls::std::boxing::Double &_double) const;
+          bool operator<=(double _value) const;
 
-      // increment / decrement operator
+          // increment / decrement operator
 
-      void operator++();
-      void operator--();
+          void operator++();
+          void operator--();
 
-      // implementation
+          // implementation
 
-      void parse(std::string _parseText) override;
-      std::string toString() override;
+          void parse(::std::string _parseText) override;
+          ::std::string toString() override;
 
-      // additional functionality
+          // additional functionality
 
-      double getEpsilon();
-      double getValue();
-      void setEpsilon(double _epsilon);
+          double getEpsilon();
+          double getValue();
+          void setEpsilon(double _epsilon);
 
-    private:
+        private:
 
-      double epsilon{};
-      double value{};
+          double epsilon{};
+          double value{};
 
-      void _assignEpsilon(double _epsilon);
-  };
+          void _assignEpsilon(double _epsilon);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/boxing/Float.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2021-07-12
+ * Changed:         2022-05-16
  *
  * */
 
@@ -11,88 +11,94 @@
 #define LS_STD_FLOAT_HPP
 
 #include <memory>
-#include <ls_std/base/Class.hpp>
-#include "IBoxing.hpp"
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/interface/IBoxing.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class Float : public ls_std::Class, public ls_std::IBoxing
+  namespace std
   {
-    public:
+    namespace boxing
+    {
+      class Float : public ls::std::core::Class, public ls::std::core::interface::IBoxing
+      {
+        public:
 
-      Float();
-      explicit Float(float _value);
-      ~Float() override = default;
+          Float();
+          explicit Float(float _value);
+          ~Float() override = default;
 
-      // conversion operator
+          // conversion operator
 
-      operator float() const; // do not make explicit!
+          operator float() const; // do not make explicit!
 
-      // assignment operators
+          // assignment operators
 
-      ls_std::Float &operator=(float _value);
+          ls::std::boxing::Float &operator=(float _value);
 
-      // arithmetic operators
+          // arithmetic operators
 
-      float operator-() const;
-      float operator+(const ls_std::Float &_float) const;
-      float operator+(float _value) const;
-      float operator*(const ls_std::Float &_float) const;
-      float operator*(float _value) const;
-      float operator-(const ls_std::Float &_float) const;
-      float operator-(float _value) const;
-      float operator/(const ls_std::Float &_float) const;
-      float operator/(float _value) const;
+          float operator-() const;
+          float operator+(const ls::std::boxing::Float &_float) const;
+          float operator+(float _value) const;
+          float operator*(const ls::std::boxing::Float &_float) const;
+          float operator*(float _value) const;
+          float operator-(const ls::std::boxing::Float &_float) const;
+          float operator-(float _value) const;
+          float operator/(const ls::std::boxing::Float &_float) const;
+          float operator/(float _value) const;
 
-      // compound operators
+          // compound operators
 
-      ls_std::Float &operator+=(const ls_std::Float &_float);
-      ls_std::Float &operator+=(float _value);
-      ls_std::Float &operator-=(const ls_std::Float &_float);
-      ls_std::Float &operator-=(float _value);
-      ls_std::Float &operator*=(const ls_std::Float &_float);
-      ls_std::Float &operator*=(float _value);
-      ls_std::Float &operator/=(const ls_std::Float &_float);
-      ls_std::Float &operator/=(float _value);
+          ls::std::boxing::Float &operator+=(const ls::std::boxing::Float &_float);
+          ls::std::boxing::Float &operator+=(float _value);
+          ls::std::boxing::Float &operator-=(const ls::std::boxing::Float &_float);
+          ls::std::boxing::Float &operator-=(float _value);
+          ls::std::boxing::Float &operator*=(const ls::std::boxing::Float &_float);
+          ls::std::boxing::Float &operator*=(float _value);
+          ls::std::boxing::Float &operator/=(const ls::std::boxing::Float &_float);
+          ls::std::boxing::Float &operator/=(float _value);
 
-      // comparison operators
+          // comparison operators
 
-      bool operator==(const ls_std::Float &_float) const;
-      bool operator==(float _value) const;
-      bool operator!=(const ls_std::Float &_float) const;
-      bool operator!=(float _value) const;
-      bool operator>(const ls_std::Float &_float) const;
-      bool operator>(float _value) const;
-      bool operator>=(const ls_std::Float &_float) const;
-      bool operator>=(float _value) const;
-      bool operator<(const ls_std::Float &_float) const;
-      bool operator<(float _value) const;
-      bool operator<=(const ls_std::Float &_float) const;
-      bool operator<=(float _value) const;
+          bool operator==(const ls::std::boxing::Float &_float) const;
+          bool operator==(float _value) const;
+          bool operator!=(const ls::std::boxing::Float &_float) const;
+          bool operator!=(float _value) const;
+          bool operator>(const ls::std::boxing::Float &_float) const;
+          bool operator>(float _value) const;
+          bool operator>=(const ls::std::boxing::Float &_float) const;
+          bool operator>=(float _value) const;
+          bool operator<(const ls::std::boxing::Float &_float) const;
+          bool operator<(float _value) const;
+          bool operator<=(const ls::std::boxing::Float &_float) const;
+          bool operator<=(float _value) const;
 
-      // increment / decrement operator
+          // increment / decrement operator
 
-      void operator++();
-      void operator--();
+          void operator++();
+          void operator--();
 
-      // implementation
+          // implementation
 
-      void parse(std::string _parseText) override;
-      std::string toString() override;
+          void parse(::std::string _parseText) override;
+          ::std::string toString() override;
 
-      // additional functionality
+          // additional functionality
 
-      float getEpsilon();
-      float getValue();
-      void setEpsilon(float _epsilon);
+          float getEpsilon();
+          float getValue();
+          void setEpsilon(float _epsilon);
 
-    private:
+        private:
 
-      float epsilon{};
-      float value{};
+          float epsilon{};
+          float value{};
 
-      void _assignEpsilon(float _epsilon);
-  };
+          void _assignEpsilon(float _epsilon);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/boxing/IBoxing.hpp

@@ -1,29 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-08-07
- * Changed:         2021-04-23
- *
- * */
-
-#ifndef LS_STD_I_BOXING_HPP
-#define LS_STD_I_BOXING_HPP
-
-#include <string>
-
-namespace ls_std
-{
-  class IBoxing
-  {
-    public:
-
-      IBoxing() = default;
-      ~IBoxing() = default;
-
-      virtual void parse(std::string _parseText) = 0;
-      virtual std::string toString() = 0;
-  };
-}
-
-#endif

include/ls_std/boxing/Integer.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2021-07-14
+ * Changed:         2022-05-16
  *
  * */
 
@@ -11,101 +11,105 @@
 #define LS_STD_INTEGER_HPP
 
 #include <memory>
-#include <ls_std/base/Class.hpp>
-#include "IBoxing.hpp"
-#include <ls_std/serialization/ISerializable.hpp>
-#include <ls_std/io/IStorable.hpp>
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/interface/IBoxing.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class Integer : public ls_std::Class, public ls_std::IBoxing
+  namespace std
   {
-    public:
-
-      explicit Integer(int _value);
-      Integer();
-      ~Integer() override = default;
-
-      // conversion operator
-
-      operator int() const;
-
-      // assignment operators
-
-      ls_std::Integer &operator=(int _value);
-
-      // arithmetic operators
-
-      int operator-() const;
-      int operator+(const ls_std::Integer &_integer) const;
-      int operator+(int _value) const;
-      int operator*(const ls_std::Integer &_integer) const;
-      int operator*(int _value) const;
-      int operator-(const ls_std::Integer &_integer) const;
-      int operator-(int _value) const;
-      int operator/(const ls_std::Integer &_integer) const;
-      int operator/(int _value) const;
-      int operator%(const ls_std::Integer &_integer) const;
-      int operator%(int _value) const;
-
-      // compound operators
-
-      ls_std::Integer &operator+=(const ls_std::Integer &_integer);
-      ls_std::Integer &operator+=(int _value);
-      ls_std::Integer &operator-=(const ls_std::Integer &_integer);
-      ls_std::Integer &operator-=(int _value);
-      ls_std::Integer &operator*=(const ls_std::Integer &_integer);
-      ls_std::Integer &operator*=(int _value);
-      ls_std::Integer &operator/=(const ls_std::Integer &_integer);
-      ls_std::Integer &operator/=(int _value);
-
-      // comparison operators
-
-      bool operator==(const ls_std::Integer &_integer) const;
-      bool operator==(int _value) const;
-      bool operator!=(const ls_std::Integer &_integer) const;
-      bool operator!=(int _value) const;
-      bool operator>(const ls_std::Integer &_integer) const;
-      bool operator>(int _value) const;
-      bool operator>=(const ls_std::Integer &_integer) const;
-      bool operator>=(int _value) const;
-      bool operator<(const ls_std::Integer &_integer) const;
-      bool operator<(int _value) const;
-      bool operator<=(const ls_std::Integer &_integer) const;
-      bool operator<=(int _value) const;
-
-      // logical operators
-
-      friend bool operator!(const ls_std::Integer &_integer)
+    namespace boxing
+    {
+      class Integer : public ls::std::core::Class, public ls::std::core::interface::IBoxing
       {
-        return !_integer.value;
-      }
+        public:
 
-      bool operator&&(const ls_std::Integer &_integer) const;
-      bool operator&&(int _value) const;
-      bool operator&&(bool _expression) const;
-      bool operator||(const ls_std::Integer &_integer) const;
-      bool operator||(int _value) const;
-      bool operator||(bool _expression) const;
+          explicit Integer(int _value);
+          Integer();
+          ~Integer() override = default;
 
-      // increment / decrement operator
+          // conversion operator
 
-      void operator++();
-      void operator--();
+          operator int() const;
 
-      // implementation
+          // assignment operators
 
-      void parse(std::string _parseText) override;
-      std::string toString() override;
+          ls::std::boxing::Integer &operator=(int _value);
 
-      // additional functionality
+          // arithmetic operators
 
-      int getValue() const;
+          int operator-() const;
+          int operator+(const ls::std::boxing::Integer &_integer) const;
+          int operator+(int _value) const;
+          int operator*(const ls::std::boxing::Integer &_integer) const;
+          int operator*(int _value) const;
+          int operator-(const ls::std::boxing::Integer &_integer) const;
+          int operator-(int _value) const;
+          int operator/(const ls::std::boxing::Integer &_integer) const;
+          int operator/(int _value) const;
+          int operator%(const ls::std::boxing::Integer &_integer) const;
+          int operator%(int _value) const;
 
-    private:
+          // compound operators
 
-      int value{};
-  };
+          ls::std::boxing::Integer &operator+=(const ls::std::boxing::Integer &_integer);
+          ls::std::boxing::Integer &operator+=(int _value);
+          ls::std::boxing::Integer &operator-=(const ls::std::boxing::Integer &_integer);
+          ls::std::boxing::Integer &operator-=(int _value);
+          ls::std::boxing::Integer &operator*=(const ls::std::boxing::Integer &_integer);
+          ls::std::boxing::Integer &operator*=(int _value);
+          ls::std::boxing::Integer &operator/=(const ls::std::boxing::Integer &_integer);
+          ls::std::boxing::Integer &operator/=(int _value);
+
+          // comparison operators
+
+          bool operator==(const ls::std::boxing::Integer &_integer) const;
+          bool operator==(int _value) const;
+          bool operator!=(const ls::std::boxing::Integer &_integer) const;
+          bool operator!=(int _value) const;
+          bool operator>(const ls::std::boxing::Integer &_integer) const;
+          bool operator>(int _value) const;
+          bool operator>=(const ls::std::boxing::Integer &_integer) const;
+          bool operator>=(int _value) const;
+          bool operator<(const ls::std::boxing::Integer &_integer) const;
+          bool operator<(int _value) const;
+          bool operator<=(const ls::std::boxing::Integer &_integer) const;
+          bool operator<=(int _value) const;
+
+          // logical operators
+
+          friend bool operator!(const ls::std::boxing::Integer &_integer)
+          {
+            return !_integer.value;
+          }
+
+          bool operator&&(const ls::std::boxing::Integer &_integer) const;
+          bool operator&&(int _value) const;
+          bool operator&&(bool _expression) const;
+          bool operator||(const ls::std::boxing::Integer &_integer) const;
+          bool operator||(int _value) const;
+          bool operator||(bool _expression) const;
+
+          // increment / decrement operator
+
+          void operator++();
+          void operator--();
+
+          // implementation
+
+          void parse(::std::string _parseText) override;
+          ::std::string toString() override;
+
+          // additional functionality
+
+          int getValue() const;
+
+        private:
+
+          int value{};
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/boxing/Long.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2021-07-14
+ * Changed:         2022-05-16
  *
  * */
 
@@ -11,102 +11,106 @@
 #define LS_STD_LONG_HPP
 
 #include <memory>
-#include <ls_std/base/Class.hpp>
-#include "IBoxing.hpp"
-#include <ls_std/base/Types.hpp>
-#include <ls_std/serialization/ISerializable.hpp>
-#include <ls_std/io/IStorable.hpp>
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/interface/IBoxing.hpp>
+#include <ls_std/core/types/Types.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class Long : public ls_std::Class, public ls_std::IBoxing
+  namespace std
   {
-    public:
-
-      explicit Long(ls_std::long_type _value);
-      Long();
-      ~Long() override = default;
-
-      // conversion operator
-
-      operator ls_std::long_type() const;
-
-      // assignment operators
-
-      ls_std::Long &operator=(ls_std::long_type _value);
-
-      // arithmetic operators
-
-      ls_std::long_type operator-() const;
-      ls_std::long_type operator+(const ls_std::Long &_long) const;
-      ls_std::long_type operator+(ls_std::long_type _value) const;
-      ls_std::long_type operator*(const ls_std::Long &_long) const;
-      ls_std::long_type operator*(ls_std::long_type _value) const;
-      ls_std::long_type operator-(const ls_std::Long &_long) const;
-      ls_std::long_type operator-(ls_std::long_type _value) const;
-      ls_std::long_type operator/(const ls_std::Long &_long) const;
-      ls_std::long_type operator/(ls_std::long_type _value) const;
-      ls_std::long_type operator%(const ls_std::Long &_long) const;
-      ls_std::long_type operator%(ls_std::long_type _value) const;
-
-      // compound operators
-
-      ls_std::Long &operator+=(const ls_std::Long &_long);
-      ls_std::Long &operator+=(ls_std::long_type _value);
-      ls_std::Long &operator-=(const ls_std::Long &_long);
-      ls_std::Long &operator-=(ls_std::long_type _value);
-      ls_std::Long &operator*=(const ls_std::Long &_long);
-      ls_std::Long &operator*=(ls_std::long_type _value);
-      ls_std::Long &operator/=(const ls_std::Long &_long);
-      ls_std::Long &operator/=(ls_std::long_type _value);
-
-      // comparison operators
-
-      bool operator==(const ls_std::Long &_long) const;
-      bool operator==(ls_std::long_type _value) const;
-      bool operator!=(const ls_std::Long &_long) const;
-      bool operator!=(ls_std::long_type _value) const;
-      bool operator>(const ls_std::Long &_long) const;
-      bool operator>(ls_std::long_type _value) const;
-      bool operator>=(const ls_std::Long &_long) const;
-      bool operator>=(ls_std::long_type _value) const;
-      bool operator<(const ls_std::Long &_long) const;
-      bool operator<(ls_std::long_type _value) const;
-      bool operator<=(const ls_std::Long &_long) const;
-      bool operator<=(ls_std::long_type _value) const;
-
-      // logical operators
-
-      friend bool operator!(const ls_std::Long &_long)
+    namespace boxing
+    {
+      class Long : public ls::std::core::Class, public ls::std::core::interface::IBoxing
       {
-        return !_long.value;
-      }
+        public:
 
-      bool operator&&(const ls_std::Long &_long) const;
-      bool operator&&(ls_std::long_type _value) const;
-      bool operator&&(bool _expression) const;
-      bool operator||(const ls_std::Long &_long) const;
-      bool operator||(ls_std::long_type _value) const;
-      bool operator||(bool _expression) const;
+          explicit Long(ls::std::core::type::long_type _value);
+          Long();
+          ~Long() override = default;
 
-      // increment / decrement operator
+          // conversion operator
 
-      void operator++();
-      void operator--();
+          operator ls::std::core::type::long_type() const;
 
-      // implementation
+          // assignment operators
 
-      void parse(std::string _parseText) override;
-      std::string toString() override;
+          ls::std::boxing::Long &operator=(ls::std::core::type::long_type _value);
 
-      // additional functionality
+          // arithmetic operators
 
-      ls_std::long_type getValue() const;
+          ls::std::core::type::long_type operator-() const;
+          ls::std::core::type::long_type operator+(const ls::std::boxing::Long &_long) const;
+          ls::std::core::type::long_type operator+(ls::std::core::type::long_type _value) const;
+          ls::std::core::type::long_type operator*(const ls::std::boxing::Long &_long) const;
+          ls::std::core::type::long_type operator*(ls::std::core::type::long_type _value) const;
+          ls::std::core::type::long_type operator-(const ls::std::boxing::Long &_long) const;
+          ls::std::core::type::long_type operator-(ls::std::core::type::long_type _value) const;
+          ls::std::core::type::long_type operator/(const ls::std::boxing::Long &_long) const;
+          ls::std::core::type::long_type operator/(ls::std::core::type::long_type _value) const;
+          ls::std::core::type::long_type operator%(const ls::std::boxing::Long &_long) const;
+          ls::std::core::type::long_type operator%(ls::std::core::type::long_type _value) const;
 
-    private:
+          // compound operators
 
-      ls_std::long_type value{};
-  };
+          ls::std::boxing::Long &operator+=(const ls::std::boxing::Long &_long);
+          ls::std::boxing::Long &operator+=(ls::std::core::type::long_type _value);
+          ls::std::boxing::Long &operator-=(const ls::std::boxing::Long &_long);
+          ls::std::boxing::Long &operator-=(ls::std::core::type::long_type _value);
+          ls::std::boxing::Long &operator*=(const ls::std::boxing::Long &_long);
+          ls::std::boxing::Long &operator*=(ls::std::core::type::long_type _value);
+          ls::std::boxing::Long &operator/=(const ls::std::boxing::Long &_long);
+          ls::std::boxing::Long &operator/=(ls::std::core::type::long_type _value);
+
+          // comparison operators
+
+          bool operator==(const ls::std::boxing::Long &_long) const;
+          bool operator==(ls::std::core::type::long_type _value) const;
+          bool operator!=(const ls::std::boxing::Long &_long) const;
+          bool operator!=(ls::std::core::type::long_type _value) const;
+          bool operator>(const ls::std::boxing::Long &_long) const;
+          bool operator>(ls::std::core::type::long_type _value) const;
+          bool operator>=(const ls::std::boxing::Long &_long) const;
+          bool operator>=(ls::std::core::type::long_type _value) const;
+          bool operator<(const ls::std::boxing::Long &_long) const;
+          bool operator<(ls::std::core::type::long_type _value) const;
+          bool operator<=(const ls::std::boxing::Long &_long) const;
+          bool operator<=(ls::std::core::type::long_type _value) const;
+
+          // logical operators
+
+          friend bool operator!(const ls::std::boxing::Long &_long)
+          {
+            return !_long.value;
+          }
+
+          bool operator&&(const ls::std::boxing::Long &_long) const;
+          bool operator&&(ls::std::core::type::long_type _value) const;
+          bool operator&&(bool _expression) const;
+          bool operator||(const ls::std::boxing::Long &_long) const;
+          bool operator||(ls::std::core::type::long_type _value) const;
+          bool operator||(bool _expression) const;
+
+          // increment / decrement operator
+
+          void operator++();
+          void operator--();
+
+          // implementation
+
+          void parse(::std::string _parseText) override;
+          ::std::string toString() override;
+
+          // additional functionality
+
+          ls::std::core::type::long_type getValue() const;
+
+        private:
+
+          ls::std::core::type::long_type value{};
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/boxing/String.hpp

@@ -3,86 +3,92 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2021-07-12
+ * Changed:         2022-05-16
  *
  * */
 
 #ifndef LS_STD_STRING_HPP
 #define LS_STD_STRING_HPP
 
-#include "IBoxing.hpp"
-#include <ls_std/base/Class.hpp>
-#include <ls_std/base/Types.hpp>
+#include <ls_std/core/interface/IBoxing.hpp>
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/types/Types.hpp>
 #include <string>
 #include <memory>
 #include <vector>
 
-namespace ls_std
+namespace ls
 {
-  class String : public ls_std::Class, public ls_std::IBoxing
+  namespace std
   {
-    public:
+    namespace boxing
+    {
+      class String : public ls::std::core::Class, public ls::std::core::interface::IBoxing
+      {
+        public:
 
-      String();
-      explicit String(std::string _value);
-      ~String() override = default;
+          String();
+          explicit String(::std::string _value);
+          ~String() override = default;
 
-      // conversion operator
+          // conversion operator
 
-      operator const char *() const; // do not make explicit!
-      operator std::string() const; // do not make explicit!
+          operator const char *() const; // do not make explicit!
+          operator ::std::string() const; // do not make explicit!
 
-      // assignment operators
+          // assignment operators
 
-      ls_std::String &operator=(std::string _value);
+          ls::std::boxing::String &operator=(::std::string _value);
 
-      // arithmetic operators
+          // arithmetic operators
 
-      std::string operator+(ls_std::String _string) const;
-      std::string operator+(const std::string &_string) const;
-      std::string operator+(const char *_string) const;
-      std::string operator-(int _number);
+          ::std::string operator+(ls::std::boxing::String _string) const;
+          ::std::string operator+(const ::std::string &_string) const;
+          ::std::string operator+(const char *_string) const;
+          ::std::string operator-(int _number);
 
-      // compound operators
+          // compound operators
 
-      ls_std::String &operator+=(ls_std::String _string);
-      ls_std::String &operator+=(const std::string &_text);
+          ls::std::boxing::String &operator+=(ls::std::boxing::String _string);
+          ls::std::boxing::String &operator+=(const ::std::string &_text);
 
-      // comparison operators
+          // comparison operators
 
-      bool operator==(ls_std::String _string);
-      bool operator==(const std::string &_value);
-      bool operator==(const char *_value);
-      bool operator!=(ls_std::String _string);
-      bool operator!=(const std::string &_value);
-      bool operator!=(const char *_value);
+          bool operator==(ls::std::boxing::String _string);
+          bool operator==(const ::std::string &_value);
+          bool operator==(const char *_value);
+          bool operator!=(ls::std::boxing::String _string);
+          bool operator!=(const ::std::string &_value);
+          bool operator!=(const char *_value);
 
-      // implementation
+          // implementation
 
-      void parse(std::string _parseText) override;
-      std::string toString() override;
+          void parse(::std::string _parseText) override;
+          ::std::string toString() override;
 
-      // additional functionality
+          // additional functionality
 
-      bool contains(const std::string &_text);
-      bool endsWith(const std::string &_text);
-      bool equalsIgnoreCase(ls_std::String _string);
-      bool equalsIgnoreCase(std::string _text);
-      std::vector<ls_std::byte> getByteData();
-      std::string padLeft(size_t _width, char _fillCharacter);
-      std::string padRight(size_t _width, char _fillCharacter);
-      std::string reverse();
-      bool startsWith(const std::string &_text);
-      std::string toLowerCase();
-      std::string toUpperCase();
+          bool contains(const ::std::string &_text);
+          bool endsWith(const ::std::string &_text);
+          bool equalsIgnoreCase(ls::std::boxing::String _string);
+          bool equalsIgnoreCase(::std::string _text);
+          ::std::vector<ls::std::core::type::byte> getByteData();
+          ::std::string padLeft(size_t _width, char _fillCharacter);
+          ::std::string padRight(size_t _width, char _fillCharacter);
+          ::std::string reverse();
+          bool startsWith(const ::std::string &_text);
+          ::std::string toLowerCase();
+          ::std::string toUpperCase();
 
-    private:
+        private:
 
-      std::string value{};
+          ::std::string value{};
 
-      static std::string _buildCharacterChain(size_t _amount, char _fillCharacter);
-      static std::string _createFillContent(const std::string &_text, size_t _width, char _fillCharacter);
-  };
+          static ::std::string _buildCharacterChain(size_t _amount, char _fillCharacter);
+          static ::std::string _createFillContent(const ::std::string &_text, size_t _width, char _fillCharacter);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/core/Class.hpp

@@ -0,0 +1,40 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-08-07
+ * Changed:         2022-05-09
+ *
+ * */
+
+#ifndef LS_STD_CLASS_HPP
+#define LS_STD_CLASS_HPP
+
+#include <string>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      class Class
+      {
+        public:
+
+          explicit Class(const ::std::string &_name);
+          virtual ~Class() = default;
+
+          ::std::string getClassName();
+
+        private:
+
+          ::std::string name{};
+
+          void _assignClassName(const ::std::string &_name);
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/base/LibraryVersion.hpp → include/ls_std/core/LibraryVersion.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-02
- * Changed:         2022-04-26
+ * Changed:         2022-05-09
  *
  * */
 
@@ -12,11 +12,17 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
-  static std::string getVersion()
+  namespace std
   {
-    return "2022.1.0";
+    namespace core
+    {
+      static ::std::string getVersion()
+      {
+        return "2022.1.0";
+      }
+    }
   }
 }
 

include/ls_std/core/Version.hpp

@@ -0,0 +1,57 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-09-27
+ * Changed:         2022-05-16
+ *
+ * */
+
+#ifndef LS_STD_VERSION_HPP
+#define LS_STD_VERSION_HPP
+
+#include "Class.hpp"
+#include <ls_std/core/interface/ISerializable.hpp>
+#include <ls_std/core/types/Types.hpp>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      class Version : public ls::std::core::interface::ISerializable
+      {
+        public:
+
+          explicit Version(ls::std::core::type::version_type _majorVersion, ls::std::core::type::version_type _minorVersion, ls::std::core::type::version_type _patchVersion);
+          ~Version() = default;
+
+          // implementation
+
+          ls::std::core::type::byte_field marshal() override;
+          void unmarshal(const ls::std::core::type::byte_field &_data) override;
+
+          // other functionality
+
+          ls::std::core::type::version_type getMajorVersion() const;
+          ls::std::core::type::version_type getMinorVersion() const;
+          ls::std::core::type::version_type getPatchVersion() const;
+          static bool isValid(const ::std::string &_versionString);
+          void setMajorVersion(ls::std::core::type::version_type _major);
+          void setMinorVersion(ls::std::core::type::version_type _minor);
+          void setPatchVersion(ls::std::core::type::version_type _patch);
+
+        private:
+
+          ls::std::core::type::version_type majorVersion{};
+          ls::std::core::type::version_type minorVersion{};
+          ls::std::core::type::version_type patchVersion{};
+
+          static bool _isValid(const ::std::string &_versionString);
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/core/exception/EventNotHandledException.hpp

@@ -0,0 +1,36 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-05-27
+ * Changed:         2022-05-09
+ *
+ * */
+
+#ifndef LS_STD_EVENT_NOT_HANDLED_EXCEPTION_HPP
+#define LS_STD_EVENT_NOT_HANDLED_EXCEPTION_HPP
+
+#include <exception>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      class EventNotHandledException : public ::std::exception
+      {
+        public:
+
+          EventNotHandledException() = default;
+
+          const char *what() const noexcept override
+          {
+            return "EventNotHandledException thrown - event was not handled - nothing happened!";
+          };
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/core/exception/EventNotSubscribedException.hpp

@@ -0,0 +1,36 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-05-27
+ * Changed:         2022-05-09
+ *
+ * */
+
+#ifndef LS_STD_EVENT_NOT_SUBSCRIBED_EXCEPTION_HPP
+#define LS_STD_EVENT_NOT_SUBSCRIBED_EXCEPTION_HPP
+
+#include <exception>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      class EventNotSubscribedException : public ::std::exception
+      {
+        public:
+
+          EventNotSubscribedException() = default;
+
+          const char *what() const noexcept override
+          {
+            return "EventNotSubscribedException thrown - event was not subscribed!";
+          };
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/core/exception/FileNotFoundException.hpp

@@ -0,0 +1,39 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-08-17
+ * Changed:         2022-05-16
+ *
+ * */
+
+#ifndef LS_STD_FILE_NOT_FOUND_EXCEPTION_HPP
+#define LS_STD_FILE_NOT_FOUND_EXCEPTION_HPP
+
+#include <exception>
+#include <string>
+#include <cstring>
+
+//TODO: pass parameters, use class, show class name
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      class FileNotFoundException : public ::std::exception
+      {
+        public:
+
+          FileNotFoundException() = default;
+
+          const char *what() const noexcept override
+          {
+            return "FileNotFoundException thrown - file not found!";
+          };
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/core/exception/FileOperationException.hpp

@@ -0,0 +1,37 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-08-15
+ * Changed:         2022-05-09
+ *
+ * */
+
+#ifndef LS_STD_FILE_OPERATION_EXCEPTION_HPP
+#define LS_STD_FILE_OPERATION_EXCEPTION_HPP
+
+#include <exception>
+#include <string>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      class FileOperationException : public ::std::exception
+      {
+        public:
+
+          explicit FileOperationException() = default;
+
+          const char *what() const noexcept override
+          {
+            return "FileOperationException thrown - file operation failed!";
+          }
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/core/exception/IllegalArgumentException.hpp

@@ -0,0 +1,36 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-08-09
+ * Changed:         2022-05-09
+ *
+ * */
+
+#ifndef LS_STD_ILLEGAL_ARGUMENT_EXCEPTION_HPP
+#define LS_STD_ILLEGAL_ARGUMENT_EXCEPTION_HPP
+
+#include <exception>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      class IllegalArgumentException : public ::std::exception
+      {
+        public:
+
+          IllegalArgumentException() = default;
+
+          const char *what() const noexcept override
+          {
+            return "IllegalArgumentException thrown - passed argument is not valid!";
+          }
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/core/exception/IllegalArithmeticOperationException.hpp

@@ -0,0 +1,36 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-08-07
+ * Changed:         2022-05-09
+ *
+ * */
+
+#ifndef LS_STD_ILLEGAL_OPERATION_EXCEPTION_HPP
+#define LS_STD_ILLEGAL_OPERATION_EXCEPTION_HPP
+
+#include <exception>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      class IllegalArithmeticOperationException : public ::std::exception
+      {
+        public:
+
+          IllegalArithmeticOperationException() = default;
+
+          const char *what() const noexcept override
+          {
+            return "IllegalArithmeticOperationException thrown - arithmetic operation is not allowed!";
+          }
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/core/exception/IncompleteJsonException.hpp

@@ -0,0 +1,36 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-30
+ * Changed:         2022-05-09
+ *
+ * */
+
+#ifndef LS_STD_INCOMPLETE_JSON_EXCEPTION_HPP
+#define LS_STD_INCOMPLETE_JSON_EXCEPTION_HPP
+
+#include <exception>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      class IncompleteJsonException : public ::std::exception
+      {
+        public:
+
+          explicit IncompleteJsonException() = default;
+
+          const char *what() const noexcept override
+          {
+            return "IncompleteJsonException thrown - this JSON string is incomplete.";
+          }
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/core/exception/NullPointerException.hpp

@@ -0,0 +1,36 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-11-06
+ * Changed:         2022-05-09
+ *
+ * */
+
+#ifndef LS_STD_NULL_POINTER_EXCEPTION_HPP
+#define LS_STD_NULL_POINTER_EXCEPTION_HPP
+
+#include <exception>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      class NullPointerException : public ::std::exception
+      {
+        public:
+
+          explicit NullPointerException() = default;
+
+          const char *what() const noexcept override
+          {
+            return "NullPointerException thrown - reference is null!";
+          }
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/core/interface/IBoxing.hpp

@@ -0,0 +1,38 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-08-07
+ * Changed:         2022-05-16
+ *
+ * */
+
+#ifndef LS_STD_I_BOXING_HPP
+#define LS_STD_I_BOXING_HPP
+
+#include <string>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      namespace interface
+      {
+        class IBoxing
+        {
+          public:
+
+            IBoxing() = default;
+            ~IBoxing() = default;
+
+            virtual void parse(::std::string _parseText) = 0;
+            virtual ::std::string toString() = 0;
+        };
+      }
+    }
+  }
+}
+
+#endif

include/ls_std/core/interface/IEventSubscriber.hpp

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

include/ls_std/core/interface/IListener.hpp

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

include/ls_std/core/interface/IReader.hpp

@@ -0,0 +1,37 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-08-17
+ * Changed:         2022-05-16
+ *
+ * */
+
+#ifndef LS_STD_I_READER_HPP
+#define LS_STD_I_READER_HPP
+
+#include <ls_std/core/types/Types.hpp>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      namespace interface
+      {
+        class IReader
+        {
+          public:
+
+            IReader() = default;
+            ~IReader() = default;
+
+            virtual ls::std::core::type::byte_field read() = 0;
+        };
+      }
+    }
+  }
+}
+
+#endif

include/ls_std/core/interface/ISerializable.hpp

@@ -0,0 +1,38 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-08-21
+ * Changed:         2022-05-16
+ *
+ * */
+
+#ifndef LS_STD_SERIALIZABLE_HPP
+#define LS_STD_SERIALIZABLE_HPP
+
+#include <ls_std/core/types/Types.hpp>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      namespace interface
+      {
+        class ISerializable
+        {
+          public:
+
+            ISerializable() = default;
+            ~ISerializable() = default;
+
+            virtual ls::std::core::type::byte_field marshal() = 0;
+            virtual void unmarshal(const ls::std::core::type::byte_field &_data) = 0;
+        };
+      }
+    }
+  }
+}
+
+#endif

include/ls_std/core/interface/IStorable.hpp

@@ -0,0 +1,38 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-08-19
+ * Changed:         2022-05-16
+ *
+ * */
+
+#ifndef LS_STD_I_STORABLE_HPP
+#define LS_STD_I_STORABLE_HPP
+
+#include <ls_std/core/types/Types.hpp>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      namespace interface
+      {
+        class IStorable
+        {
+          public:
+
+            IStorable() = default;
+            ~IStorable() = default;
+
+            virtual ls::std::core::type::byte_field load() = 0;
+            virtual void save(const ls::std::core::type::byte_field &_data) = 0;
+        };
+      }
+    }
+  }
+}
+
+#endif

include/ls_std/core/interface/IWriter.hpp

@@ -0,0 +1,38 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-08-17
+ * Changed:         2022-05-16
+ *
+ * */
+
+#ifndef LS_STD_I_WRITER_HPP
+#define LS_STD_I_WRITER_HPP
+
+#include <vector>
+#include <ls_std/core/types/Types.hpp>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      namespace interface
+      {
+        class IWriter
+        {
+          public:
+
+            IWriter() = default;
+            ~IWriter() = default;
+
+            virtual bool write(const ls::std::core::type::byte_field &_data) = 0;
+        };
+      }
+    }
+  }
+}
+
+#endif

include/ls_std/core/types/EventTypes.hpp

@@ -0,0 +1,35 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-11-26
+ * Changed:         2022-05-12
+ *
+ * */
+
+#ifndef LS_STD_EVENT_TYPES_HPP
+#define LS_STD_EVENT_TYPES_HPP
+
+#include <string>
+#include <vector>
+#include <map>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      namespace type
+      {
+        using event_id = ::std::string;
+        using event_parameter_id = ::std::string;
+        using event_parameter_value = ::std::string;
+        using event_parameter = ::std::pair<::std::string, ::std::string>;
+        using event_parameter_list = ::std::map<ls::std::core::type::event_parameter_id, ls::std::core::type::event_parameter_value>;
+      }
+    }
+  }
+}
+
+#endif

include/ls_std/io/kv/KvTypes.hpp → include/ls_std/core/types/KvTypes.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-04-23
+ * Changed:         2022-05-12
  *
  * */
 
@@ -12,10 +12,19 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
-  using kv_key = std::string;
-  using kv_value = std::string;
+  namespace std
+  {
+    namespace core
+    {
+      namespace type
+      {
+        using kv_key = ::std::string;
+        using kv_value = ::std::string;
+      }
+    }
+  }
 }
 
 #endif

include/ls_std/logic/StateMachineTypes.hpp → include/ls_std/core/types/StateMachineTypes.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-10
- * Changed:         2021-04-23
+ * Changed:         2022-05-12
  *
  * */
 
@@ -12,10 +12,19 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
-  using StateConnectionId = std::string;
-  using StateId = std::string;
+  namespace std
+  {
+    namespace core
+    {
+      namespace type
+      {
+        using state_connection_id = ::std::string;
+        using state_id = ::std::string;
+      }
+    }
+  }
 }
 
 #endif

include/ls_std/core/types/Types.hpp

@@ -0,0 +1,32 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-08-07
+ * Changed:         2022-05-12
+ *
+ * */
+
+#ifndef LS_STD_TYPES_HPP
+#define LS_STD_TYPES_HPP
+
+#include <string>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      namespace type
+      {
+        using byte = char;
+        using byte_field = ::std::string;
+        using long_type = long long int;
+        using version_type = uint16_t;
+      }
+    }
+  }
+}
+
+#endif

include/ls_std/core/utils/RegexUtils.hpp

@@ -0,0 +1,39 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-08-18
+ * Changed:         2022-05-09
+ *
+ * */
+
+#ifndef LS_STD_REGEX_UTILS_HPP
+#define LS_STD_REGEX_UTILS_HPP
+
+#include <string>
+#include <regex>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      class RegexUtils
+      {
+        public:
+
+          RegexUtils() = default;
+          ~RegexUtils() = default;
+
+          static ::std::string escapeString(const ::std::string &_text)
+          {
+            static ::std::regex regexMetaEscape(R"(([\^\$\\\.\*\+\?\(\)\[\]\{\}\|]))");
+            return ::std::regex_replace(_text, regexMetaEscape, R"(\$1)");
+          }
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/core/utils/STLUtils.hpp

@@ -0,0 +1,62 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-08-17
+ * Changed:         2022-05-09
+ *
+ * */
+
+#ifndef LS_STD_STL_UTILS_HPP
+#define LS_STD_STL_UTILS_HPP
+
+#include <algorithm>
+#include <list>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      class STLUtils
+      {
+        public:
+
+          STLUtils() = default;
+          ~STLUtils() = default;
+
+          template<class container, class dataType>
+          static bool contains(container _container, const dataType &_value)
+          {
+            return ::std::find(_container.begin(), _container.end(), _value) != _container.end();
+          }
+
+          template<class dataType>
+          static dataType getListElementAt(const ::std::list<dataType> &_list, size_t _index)
+          {
+            dataType value{};
+            size_t counter{};
+
+            if (_index < _list.size())
+            {
+              for (const auto &_value: _list)
+              {
+                if (counter == _index)
+                {
+                  value = _value;
+                  break;
+                }
+
+                counter++;
+              }
+            }
+
+            return value;
+          }
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/core/utils/WindowsUtils.hpp

@@ -0,0 +1,42 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-12-06
+ * Changed:         2022-05-12
+ *
+ * */
+
+#ifndef LS_STD_WINDOWS_UTILS_HPP
+#define LS_STD_WINDOWS_UTILS_HPP
+
+#include <ls_std/core/types/Types.hpp>
+#include <string>
+#include <windows.h>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      class WindowsUtils
+      {
+        public:
+
+          WindowsUtils() = default;
+          ~WindowsUtils() = default;
+
+          static ::std::string getMessageFromErrorCode(const int &_errorCode)
+          {
+            ls::std::core::type::byte messageBuffer[256 + 1];
+            FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, _errorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), messageBuffer, sizeof(messageBuffer), nullptr);
+
+            return ::std::string{messageBuffer};
+          }
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/event/Event.hpp

@@ -3,44 +3,50 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2021-07-14
+ * Changed:         2022-05-12
  *
  * */
 
 #ifndef LS_STD_EVENT_HPP
 #define LS_STD_EVENT_HPP
 
-#include <ls_std/base/Class.hpp>
-#include <ls_std/serialization/ISerializable.hpp>
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/interface/ISerializable.hpp>
 #include <memory>
-#include "EventTypes.hpp"
+#include <ls_std/core/types/EventTypes.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class Event : public ls_std::Class
+  namespace std
   {
-    public:
-
-      explicit Event(const ls_std::event_id &_id);
-      ~Event() override = default;
-
-      // additional functionality
-
-      bool addParameter(const ls_std::event_parameter &_eventParameter);
-      void clearParameterList();
-      ls_std::event_id getId();
-      ls_std::event_parameter_list getParameterList();
-      bool removeParameter(const ls_std::event_parameter_id &_id);
-      void setId(const ls_std::event_id &_id);
-
-    private:
-
-      ls_std::event_id id{};
-      ls_std::event_parameter_list parameterList{};
-
-      void _assignId(const ls_std::event_id &_id);
-      bool _hasParameter(const ls_std::event_id &_id);
-  };
+    namespace event
+    {
+      class Event : public ls::std::core::Class
+      {
+        public:
+
+          explicit Event(const ls::std::core::type::event_id &_id);
+          ~Event() override = default;
+
+          // additional functionality
+
+          bool addParameter(const ls::std::core::type::event_parameter &_eventParameter);
+          void clearParameterList();
+          ls::std::core::type::event_id getId();
+          ls::std::core::type::event_parameter_list getParameterList();
+          bool removeParameter(const ls::std::core::type::event_parameter_id &_id);
+          void setId(const ls::std::core::type::event_id &_id);
+
+        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);
+          bool _hasParameter(const ls::std::core::type::event_id &_id);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/event/EventHandler.hpp

@@ -3,37 +3,43 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2021-05-27
+ * Changed:         2022-05-12
  *
  * */
 
 #ifndef LS_STD_EVENT_HANDLER_HPP
 #define LS_STD_EVENT_HANDLER_HPP
 
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include <list>
 #include <memory>
-#include <ls_std/logic/IListener.hpp>
+#include <ls_std/core/interface/IListener.hpp>
 #include "Event.hpp"
-#include <ls_std/logic/Narrator.hpp>
+#include "Narrator.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class EventHandler : public ls_std::Narrator
+  namespace std
   {
-    public:
+    namespace event
+    {
+      class EventHandler : public ls::std::event::Narrator
+      {
+        public:
 
-      explicit EventHandler(const ls_std::event_id& _id);
-      ~EventHandler() override = default;
+          explicit EventHandler(const ls::std::core::type::event_id &_id);
+          ~EventHandler() override = default;
 
-      ls_std::event_id getId();
+          ls::std::core::type::event_id getId();
 
-    private:
+        private:
 
-      ls_std::event_id id{};
+          ls::std::core::type::event_id id{};
 
-      void _assignId(const ls_std::event_id& _id);
-  };
+          void _assignId(const ls::std::core::type::event_id &_id);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/event/EventManager.hpp

@@ -3,48 +3,54 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2021-05-27
+ * Changed:         2022-05-16
  *
  * */
 
 #ifndef LS_STD_EVENT_MANAGER_HPP
 #define LS_STD_EVENT_MANAGER_HPP
 
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include <map>
-#include <ls_std/event/EventTypes.hpp>
+#include <ls_std/core/types/EventTypes.hpp>
 #include <memory>
 #include "EventHandler.hpp"
-#include "IEventSubscriber.hpp"
+#include <ls_std/core/interface/IEventSubscriber.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class EventManager : public ls_std::Class, public ls_std::IEventSubscriber
+  namespace std
   {
-    public:
+    namespace event
+    {
+      class EventManager : public ls::std::core::Class, public ls::std::core::interface::IEventSubscriber
+      {
+        public:
 
-      explicit EventManager();
-      ~EventManager() override = default;
+          explicit EventManager();
+          ~EventManager() override = default;
 
-      // implementation
+          // implementation
 
-      void subscribe(const ls_std::event_id &_id, const std::shared_ptr<ls_std::IListener> &_listener) override;
-      void unsubscribe(const ls_std::event_id &_id, const std::shared_ptr<ls_std::IListener> &_listener) override;
+          void subscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::interface::IListener> &_listener) override;
+          void unsubscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::interface::IListener> &_listener) override;
 
-      // additional functionality
+          // additional functionality
 
-      bool addEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
-      void fire(ls_std::Event _event);
-      bool hasEventHandler(const ls_std::event_id &_id);
-      bool removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
+          bool addEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler);
+          void fire(ls::std::event::Event _event);
+          bool hasEventHandler(const ls::std::core::type::event_id &_id);
+          bool removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler);
 
-    private:
+        private:
 
-      std::map<ls_std::event_id, std::shared_ptr<ls_std::EventHandler>> eventHandlers{};
+          ::std::map<ls::std::core::type::event_id, ::std::shared_ptr<ls::std::event::EventHandler>> eventHandlers{};
 
-      bool _hasEventHandler(const ls_std::event_id &_id);
-      bool _removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
-  };
+          bool _hasEventHandler(const ls::std::core::type::event_id &_id);
+          bool _removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/event/EventTypes.hpp

@@ -1,26 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-26
- * Changed:         2021-05-01
- *
- * */
-
-#ifndef LS_STD_EVENT_TYPES_HPP
-#define LS_STD_EVENT_TYPES_HPP
-
-#include <string>
-#include <vector>
-#include <map>
-
-namespace ls_std
-{
-  using event_id = std::string;
-  using event_parameter_id = std::string;
-  using event_parameter_value = std::string;
-  using event_parameter = std::pair<std::string, std::string>;
-  using event_parameter_list = std::map<ls_std::event_parameter_id, ls_std::event_parameter_value>;
-}
-
-#endif

include/ls_std/event/IEventSubscriber.hpp

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

include/ls_std/event/Narrator.hpp

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

include/ls_std/event/serialization/SerializableJsonEvent.hpp

@@ -0,0 +1,56 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-12-07
+ * Changed:         2022-05-16
+ *
+ * */
+
+#ifndef LS_STD_SERIALIZABLE_JSON_EVENT_HPP
+#define LS_STD_SERIALIZABLE_JSON_EVENT_HPP
+
+#include <ls_std/core/interface/ISerializable.hpp>
+#include <ls_std/core/Class.hpp>
+#include <ls_std/event/Event.hpp>
+#include <memory>
+#include <ls_std/lib/nlohmann_json/include/nlohmann/json.hpp>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace event
+    {
+      class SerializableJsonEvent : public ls::std::core::Class, public ls::std::core::interface::ISerializable
+      {
+        public:
+
+          explicit SerializableJsonEvent(const ::std::shared_ptr<ls::std::event::Event> &_value);
+          ~SerializableJsonEvent() 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::event::Event> getValue();
+          void setValue(const ::std::shared_ptr<ls::std::event::Event> &_value);
+
+        private:
+
+          nlohmann::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/exception/EventNotHandledException.hpp

@@ -1,30 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2021-05-27
- * Changed:         2021-05-27
- *
- * */
-
-#ifndef LS_STD_EVENT_NOT_HANDLED_EXCEPTION_HPP
-#define LS_STD_EVENT_NOT_HANDLED_EXCEPTION_HPP
-
-#include <exception>
-
-namespace ls_std
-{
-  class EventNotHandledException : public std::exception
-  {
-    public:
-
-      EventNotHandledException() = default;
-
-      const char *what() const noexcept override
-      {
-        return "EventNotHandledException thrown - event was not handled - nothing happened!";
-      };
-  };
-}
-
-#endif

include/ls_std/exception/EventNotSubscribedException.hpp

@@ -1,30 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2021-05-27
- * Changed:         2021-05-27
- *
- * */
-
-#ifndef LS_STD_EVENT_NOT_SUBSCRIBED_EXCEPTION_HPP
-#define LS_STD_EVENT_NOT_SUBSCRIBED_EXCEPTION_HPP
-
-#include <exception>
-
-namespace ls_std
-{
-  class EventNotSubscribedException : public std::exception
-  {
-    public:
-
-      EventNotSubscribedException() = default;
-
-      const char *what() const noexcept override
-      {
-        return "EventNotSubscribedException thrown - event was not subscribed!";
-      };
-  };
-}
-
-#endif

include/ls_std/exception/FileNotFoundException.hpp

@@ -1,33 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-08-17
- * Changed:         2021-04-23
- *
- * */
-
-#ifndef LS_STD_FILE_NOT_FOUND_EXCEPTION_HPP
-#define LS_STD_FILE_NOT_FOUND_EXCEPTION_HPP
-
-#include <exception>
-#include <string>
-#include <cstring>
-
-// TODO: pass parameters, use class, show class name
-namespace ls_std
-{
-  class FileNotFoundException : public std::exception
-  {
-    public:
-
-      FileNotFoundException() = default;
-
-      const char *what() const noexcept override
-      {
-        return "FileNotFoundException thrown - file not found!";
-      };
-  };
-}
-
-#endif

include/ls_std/exception/FileOperationException.hpp

@@ -1,31 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-08-15
- * Changed:         2021-04-23
- *
- * */
-
-#ifndef LS_STD_FILE_OPERATION_EXCEPTION_HPP
-#define LS_STD_FILE_OPERATION_EXCEPTION_HPP
-
-#include <exception>
-#include <string>
-
-namespace ls_std
-{
-  class FileOperationException : public std::exception
-  {
-    public:
-
-      explicit FileOperationException() = default;
-
-      const char *what() const noexcept override
-      {
-        return "FileOperationException thrown - file operation failed!";
-      }
-  };
-}
-
-#endif

include/ls_std/exception/IllegalArgumentException.hpp

@@ -1,30 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-08-09
- * Changed:         2021-04-23
- *
- * */
-
-#ifndef LS_STD_ILLEGAL_ARGUMENT_EXCEPTION_HPP
-#define LS_STD_ILLEGAL_ARGUMENT_EXCEPTION_HPP
-
-#include <exception>
-
-namespace ls_std
-{
-  class IllegalArgumentException : public std::exception
-  {
-    public:
-
-      IllegalArgumentException() = default;
-
-      const char *what() const noexcept override
-      {
-        return "IllegalArgumentException thrown - passed argument is not valid!";
-      }
-  };
-}
-
-#endif

include/ls_std/exception/IllegalArithmeticOperationException.hpp

@@ -1,30 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-08-07
- * Changed:         2021-05-01
- *
- * */
-
-#ifndef LS_STD_ILLEGAL_OPERATION_EXCEPTION_HPP
-#define LS_STD_ILLEGAL_OPERATION_EXCEPTION_HPP
-
-#include <exception>
-
-namespace ls_std
-{
-  class IllegalArithmeticOperationException : public std::exception
-  {
-    public:
-
-      IllegalArithmeticOperationException() = default;
-
-      const char *what() const noexcept override
-      {
-        return "IllegalArithmeticOperationException thrown - arithmetic operation is not allowed!";
-      }
-  };
-}
-
-#endif

include/ls_std/exception/IncompleteJsonException.hpp

@@ -1,30 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2021-04-30
- * Changed:         2021-05-01
- *
- * */
-
-#ifndef LS_STD_INCOMPLETE_JSON_EXCEPTION_HPP
-#define LS_STD_INCOMPLETE_JSON_EXCEPTION_HPP
-
-#include <exception>
-
-namespace ls_std
-{
-  class IncompleteJsonException : public std::exception
-  {
-    public:
-
-      explicit IncompleteJsonException() = default;
-
-      const char *what() const noexcept override
-      {
-        return "IncompleteJsonException thrown - this JSON string is incomplete.";
-      }
-  };
-}
-
-#endif

include/ls_std/exception/NullPointerException.hpp

@@ -1,30 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-06
- * Changed:         2021-04-23
- *
- * */
-
-#ifndef LS_STD_NULL_POINTER_EXCEPTION_HPP
-#define LS_STD_NULL_POINTER_EXCEPTION_HPP
-
-#include <exception>
-
-namespace ls_std
-{
-  class NullPointerException : public std::exception
-  {
-    public:
-
-      explicit NullPointerException() = default;
-
-      const char *what() const noexcept override
-      {
-        return "NullPointerException thrown - reference is null!";
-      }
-  };
-}
-
-#endif

include/ls_std/factory/IFactory.hpp

@@ -1,29 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2021-04-23
- * Changed:         2021-04-23
- *
- * */
-
-#ifndef LS_STD_I_FACTORY_HPP
-#define LS_STD_I_FACTORY_HPP
-
-#include <memory>
-#include <ls_std/base/Class.hpp>
-
-namespace ls_std
-{
-  class IFactory
-  {
-    public:
-
-      IFactory() = default;
-      ~IFactory() = default;
-
-      virtual std::shared_ptr<ls_std::Class> build() = 0;
-  };
-}
-
-#endif

include/ls_std/io/File.hpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2021-09-26
+ * Changed:         2022-05-11
  *
  * */
 
 #ifndef LS_STD_FILE_HPP
 #define LS_STD_FILE_HPP
 
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include <string>
 #include <vector>
 #include <list>
@@ -29,95 +29,101 @@
 
 #endif
 
-namespace ls_std
+namespace ls
 {
-  class File : public ls_std::Class
+  namespace std
   {
-    public:
-
-      explicit File(std::string _absoluteFilePath);
-      ~File() override = default;
-
-      // comparison operators
-
-      bool operator==(ls_std::File &_file);
-      bool operator!=(ls_std::File &_file);
-
-      // additional functionality
-
-      bool canExecute();
-      bool canRead();
-      bool canWrite();
-      void createNewFile();
-      bool exists();
-      std::string getAbsoluteFilePath();
-      std::string getName();
-      std::string getParent();
-      static std::string getWorkingDirectory();
-      long getSize();
-      bool isDirectory();
-      bool isFile();
-      time_t lastModified();
-      std::list<std::string> list();
-      std::list<std::string> listFiles();
-      void makeDirectory();
-      void makeDirectories();
-      void remove();
-      bool renameTo(const std::string &_newName);
-      void reset(const std::string &_newPath);
-
-    private:
-
-      std::string absoluteFilePath{};
-
-      #if defined(unix) || defined(__APPLE__)
-      static void _addToFileListUnix(const std::string &_path, bool _withDirectories, dirent *directoryEntity, std::list<std::string> &_list);
-      #endif
-      #ifdef _WIN32
-      static void _addToFileListWindows(const std::string &_path, bool _withDirectories, WIN32_FIND_DATA _data, std::list<std::string> &_list);
-      #endif
-      static bool _equals(ls_std::File &_file, ls_std::File &_foreignFile);
-      static bool _exists(const std::string &_path);
-      static std::string _getParent(const std::string &_path);
-      #if defined(unix) || defined(__APPLE__)
-      static std::string _getWorkingDirectoryUnix();
-      #endif
-      #ifdef _WIN32
-      static std::string _getWorkingDirectoryWindows();
-      #endif
-      static bool _isDirectory(const std::string &_path);
-      static bool _isExecutable(const std::string &_path);
-      static bool _isFile(const std::string &_path);
-      #if defined(unix) || defined(__APPLE__)
-      static bool _isReadableUnix(const std::string &_path);
-      #endif
-      #ifdef _WIN32
-      static bool _isReadableWindows(const std::string &_path);
-      #endif
-      static bool _isWritable(const std::string &_path);
-      static time_t _lastModified(const std::string &_path);
-      static std::list<std::string> _list(const std::string &_path);
-      static std::list<std::string> _listFiles(const std::string &_path);
-      #if defined(unix) || defined(__APPLE__)
-      static std::list<std::string> _listUnix(const std::string &_path, bool withDirectories);
-      #endif
-      #ifdef _WIN32
-      static std::list<std::string> _listWindows(const std::string &_path, bool withDirectories);
-      #endif
-      static int _mkdir(const std::string &_path);
-      static std::string _normalizePath(std::string _path);
-      static std::string _reduceSeparators(const std::string &_path);
-      static void _remove(const std::string &_path);
-      #if defined(unix) || defined(__APPLE__)
-      static void _removeUnix(const std::string &_path);
-      #endif
-      #ifdef _WIN32
-      static void _removeWindows(const std::string &_path);
-      #endif
-      static bool _renameTo(const std::string &_oldName, const std::string &_newName);
-      static std::string _replaceWrongSeparator(std::string _path);
-      static std::vector<std::string> _splitIntoSubDirectoryNames(const std::string &_path);
-  };
+    namespace io
+    {
+      class File : public ls::std::core::Class
+      {
+        public:
+
+          explicit File(::std::string _absoluteFilePath);
+          ~File() override = default;
+
+          // comparison operators
+
+          bool operator==(ls::std::io::File &_file);
+          bool operator!=(ls::std::io::File &_file);
+
+          // additional functionality
+
+          bool canExecute();
+          bool canRead();
+          bool canWrite();
+          void createNewFile();
+          bool exists();
+          ::std::string getAbsoluteFilePath();
+          ::std::string getName();
+          ::std::string getParent();
+          static ::std::string getWorkingDirectory();
+          long getSize();
+          bool isDirectory();
+          bool isFile();
+          time_t lastModified();
+          ::std::list<::std::string> list();
+          ::std::list<::std::string> listFiles();
+          void makeDirectory();
+          void makeDirectories();
+          void remove();
+          bool renameTo(const ::std::string &_newName);
+          void reset(const ::std::string &_newPath);
+
+        private:
+
+          ::std::string absoluteFilePath{};
+
+          #if defined(unix) || defined(__APPLE__)
+          static void _addToFileListUnix(const ::std::string &_path, bool _withDirectories, dirent *directoryEntity, ::std::list<::std::string> &_list);
+          #endif
+          #ifdef _WIN32
+          static void _addToFileListWindows(const ::std::string &_path, bool _withDirectories, WIN32_FIND_DATA _data, ::std::list<::std::string> &_list);
+          #endif
+          static bool _equals(ls::std::io::File &_file, ls::std::io::File &_foreignFile);
+          static bool _exists(const ::std::string &_path);
+          static ::std::string _getParent(const ::std::string &_path);
+          #if defined(unix) || defined(__APPLE__)
+          static ::std::string _getWorkingDirectoryUnix();
+          #endif
+          #ifdef _WIN32
+          static ::std::string _getWorkingDirectoryWindows();
+          #endif
+          static bool _isDirectory(const ::std::string &_path);
+          static bool _isExecutable(const ::std::string &_path);
+          static bool _isFile(const ::std::string &_path);
+          #if defined(unix) || defined(__APPLE__)
+          static bool _isReadableUnix(const ::std::string &_path);
+          #endif
+          #ifdef _WIN32
+          static bool _isReadableWindows(const ::std::string &_path);
+          #endif
+          static bool _isWritable(const ::std::string &_path);
+          static time_t _lastModified(const ::std::string &_path);
+          static ::std::list<::std::string> _list(const ::std::string &_path);
+          static ::std::list<::std::string> _listFiles(const ::std::string &_path);
+          #if defined(unix) || defined(__APPLE__)
+          static ::std::list<::std::string> _listUnix(const ::std::string &_path, bool withDirectories);
+          #endif
+          #ifdef _WIN32
+          static ::std::list<::std::string> _listWindows(const ::std::string &_path, bool withDirectories);
+          #endif
+          static int _mkdir(const ::std::string &_path);
+          static ::std::string _normalizePath(::std::string _path);
+          static ::std::string _reduceSeparators(const ::std::string &_path);
+          static void _remove(const ::std::string &_path);
+          #if defined(unix) || defined(__APPLE__)
+          static void _removeUnix(const ::std::string &_path);
+          #endif
+          #ifdef _WIN32
+          static void _removeWindows(const ::std::string &_path);
+          #endif
+          static bool _renameTo(const ::std::string &_oldName, const ::std::string &_newName);
+          static ::std::string _replaceWrongSeparator(::std::string _path);
+          static ::std::vector<::std::string> _splitIntoSubDirectoryNames(const ::std::string &_path);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/FileOutputStream.hpp

@@ -3,40 +3,46 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2021-05-01
+ * Changed:         2022-05-16
  *
  * */
 
 #ifndef LS_STD_FILE_OUTPUT_STREAM_HPP
 #define LS_STD_FILE_OUTPUT_STREAM_HPP
 
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include "File.hpp"
-#include "IWriter.hpp"
+#include <ls_std/core/interface/IWriter.hpp>
 #include <fstream>
 
-namespace ls_std
+namespace ls
 {
-  class FileOutputStream : public ls_std::Class, public ls_std::IWriter
+  namespace std
   {
-    public:
-
-      explicit FileOutputStream(ls_std::File &_file);
-      explicit FileOutputStream(ls_std::File &_file, bool _append);
-      ~FileOutputStream() override;
-
-      void close();
-      bool write(const ls_std::byte_field &_data) override;
-
-    private:
-
-      bool append{};
-      ls_std::File file;
-      std::ofstream outputStream{};
-
-      void _close();
-      void _init();
-  };
+    namespace io
+    {
+      class FileOutputStream : public ls::std::core::Class, public ls::std::core::interface::IWriter
+      {
+        public:
+
+          explicit FileOutputStream(ls::std::io::File &_file);
+          explicit FileOutputStream(ls::std::io::File &_file, bool _append);
+          ~FileOutputStream() override;
+
+          void close();
+          bool write(const ls::std::core::type::byte_field &_data) override;
+
+        private:
+
+          bool append{};
+          ls::std::io::File file;
+          ::std::ofstream outputStream{};
+
+          void _close();
+          void _init();
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/FilePathSeparator.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2021-04-23
+ * Changed:         2022-05-11
  *
  * */
 
@@ -12,39 +12,45 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
-  class FilePathSeparator
+  namespace std
   {
-    public:
-
-      FilePathSeparator() = default;
-      ~FilePathSeparator() = default;
-
-      static char get()
-      {
-        char separator;
-
-        #ifdef _WIN32
-        separator = ls_std::FilePathSeparator::getWindowsFilePathSeparator();
-        #endif
-        #if defined(unix) || defined(__APPLE__)
-        separator = ls_std::FilePathSeparator::getUnixFilePathSeparator();
-        #endif
-
-        return separator;
-      }
-
-      static char getUnixFilePathSeparator()
-      {
-        return '/';
-      }
-
-      static char getWindowsFilePathSeparator()
+    namespace io
+    {
+      class FilePathSeparator
       {
-        return '\\';
-      }
-  };
+        public:
+
+          FilePathSeparator() = default;
+          ~FilePathSeparator() = default;
+
+          static char get()
+          {
+            char separator;
+
+            #ifdef _WIN32
+            separator = ls::std::io::FilePathSeparator::getWindowsFilePathSeparator();
+            #endif
+            #if defined(unix) || defined(__APPLE__)
+            separator = ls::std::io::FilePathSeparator::getUnixFilePathSeparator();
+            #endif
+
+            return separator;
+          }
+
+          static char getUnixFilePathSeparator()
+          {
+            return '/';
+          }
+
+          static char getWindowsFilePathSeparator()
+          {
+            return '\\';
+          }
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/FilePathSeparatorMatch.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2021-04-23
+ * Changed:         2022-05-11
  *
  * */
 
@@ -12,15 +12,21 @@
 
 #include "FilePathSeparator.hpp"
 
-namespace ls_std
+namespace ls
 {
-  struct FilePathSeparatorMatch
+  namespace std
   {
-    bool operator()(char _char) const
+    namespace io
     {
-      return _char == ls_std::FilePathSeparator::getWindowsFilePathSeparator() || _char == ls_std::FilePathSeparator::getUnixFilePathSeparator();
+      struct FilePathSeparatorMatch
+      {
+        bool operator()(char _char) const
+        {
+          return _char == ls::std::io::FilePathSeparator::getWindowsFilePathSeparator() || _char == ls::std::io::FilePathSeparator::getUnixFilePathSeparator();
+        }
+      };
     }
-  };
+  }
 }
 
 #endif

include/ls_std/io/FileReader.hpp

@@ -3,35 +3,41 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2021-05-01
+ * Changed:         2022-05-16
  *
  * */
 
 #ifndef LS_STD_FILE_READER_HPP
 #define LS_STD_FILE_READER_HPP
 
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include "File.hpp"
-#include "IReader.hpp"
+#include <ls_std/core/interface/IReader.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class FileReader : public ls_std::Class, public ls_std::IReader
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class FileReader : public ls::std::core::Class, public ls::std::core::interface::IReader
+      {
+        public:
 
-      explicit FileReader(ls_std::File &_file);
-      ~FileReader() override = default;
+          explicit FileReader(ls::std::io::File &_file);
+          ~FileReader() override = default;
 
-      ls_std::byte_field read() override;
-      void reset(ls_std::File &_file);
+          ls::std::core::type::byte_field read() override;
+          void reset(ls::std::io::File &_file);
 
-    private:
+        private:
 
-      ls_std::File file;
+          ls::std::io::File file;
 
-      static void _init(ls_std::File &_file);
-  };
+          static void _init(ls::std::io::File &_file);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/FileWriter.hpp

@@ -3,35 +3,41 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2021-05-01
+ * Changed:         2022-05-16
  *
  * */
 
 #ifndef LS_STD_FILE_WRITER_HPP
 #define LS_STD_FILE_WRITER_HPP
 
-#include <ls_std/base/Class.hpp>
-#include "IWriter.hpp"
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/interface/IWriter.hpp>
 #include "File.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class FileWriter : public ls_std::Class, public ls_std::IWriter
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class FileWriter : public ls::std::core::Class, public ls::std::core::interface::IWriter
+      {
+        public:
 
-      explicit FileWriter(ls_std::File &_file);
-      ~FileWriter() override = default;
+          explicit FileWriter(ls::std::io::File &_file);
+          ~FileWriter() override = default;
 
-      void reset(ls_std::File &_file);
-      bool write(const ls_std::byte_field &_data) override;
+          void reset(ls::std::io::File &_file);
+          bool write(const ls::std::core::type::byte_field &_data) override;
 
-    private:
+        private:
 
-      ls_std::File file;
+          ls::std::io::File file;
 
-      static void _init(ls_std::File &_file);
-  };
+          static void _init(ls::std::io::File &_file);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/IReader.hpp

@@ -1,28 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-08-17
- * Changed:         2021-04-23
- *
- * */
-
-#ifndef LS_STD_I_READER_HPP
-#define LS_STD_I_READER_HPP
-
-#include <ls_std/base/Types.hpp>
-
-namespace ls_std
-{
-  class IReader
-  {
-    public:
-
-      IReader() = default;
-      ~IReader() = default;
-
-      virtual ls_std::byte_field read() = 0;
-  };
-}
-
-#endif

include/ls_std/io/IStorable.hpp

@@ -1,28 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-08-19
- * Changed:         2021-04-23
- *
- * */
-
-#ifndef LS_STD_I_STORABLE_HPP
-#define LS_STD_I_STORABLE_HPP
-
-#include <ls_std/base/Types.hpp>
-
-namespace ls_std
-{
-  class IStorable
-  {
-    public:
-      IStorable() = default;
-      ~IStorable() = default;
-
-      virtual ls_std::byte_field load() = 0;
-      virtual void save(const ls_std::byte_field &_data) = 0;
-  };
-}
-
-#endif

include/ls_std/io/IWriter.hpp

@@ -1,29 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-08-17
- * Changed:         2021-04-23
- *
- * */
-
-#ifndef LS_STD_I_WRITER_HPP
-#define LS_STD_I_WRITER_HPP
-
-#include <vector>
-#include <ls_std/base/Types.hpp>
-
-namespace ls_std
-{
-  class IWriter
-  {
-    public:
-
-      IWriter() = default;
-      ~IWriter() = default;
-
-      virtual bool write(const ls_std::byte_field &_data) = 0;
-  };
-}
-
-#endif

include/ls_std/io/NewLine.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-18
- * Changed:         2021-04-23
+ * Changed:         2022-05-11
  *
  * */
 
@@ -12,39 +12,45 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
-  class NewLine
+  namespace std
   {
-    public:
-
-      NewLine() = default;
-      ~NewLine() = default;
-
-      static std::string get()
-      {
-        std::string newLine{};
-
-        #if defined(unix) || defined(__APPLE__)
-        newLine = ls_std::NewLine::getUnixNewLine();
-        #endif
-        #ifdef _WIN32
-        newLine = ls_std::NewLine::getWindowsNewLine();
-        #endif
-
-        return newLine;
-      }
-
-      static std::string getUnixNewLine()
-      {
-        return "\n";
-      }
-
-      static std::string getWindowsNewLine()
+    namespace io
+    {
+      class NewLine
       {
-        return "\r\n";
-      }
-  };
+        public:
+
+          NewLine() = default;
+          ~NewLine() = default;
+
+          static ::std::string get()
+          {
+            ::std::string newLine{};
+
+            #if defined(unix) || defined(__APPLE__)
+            newLine = ls::std::io::NewLine::getUnixNewLine();
+            #endif
+            #ifdef _WIN32
+            newLine = ls::std::io::NewLine::getWindowsNewLine();
+            #endif
+
+            return newLine;
+          }
+
+          static ::std::string getUnixNewLine()
+          {
+            return "\n";
+          }
+
+          static ::std::string getWindowsNewLine()
+          {
+            return "\r\n";
+          }
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/StandardOutputWriter.hpp

@@ -3,26 +3,32 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-06
- * Changed:         2021-05-01
+ * Changed:         2022-05-16
  *
  * */
 
 #ifndef LS_STD_STANDARD_OUTPUT_WRITER_HPP
 #define LS_STD_STANDARD_OUTPUT_WRITER_HPP
 
-#include "IWriter.hpp"
+#include <ls_std/core/interface/IWriter.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class StandardOutputWriter : public ls_std::IWriter
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class StandardOutputWriter : public ls::std::core::interface::IWriter
+      {
+        public:
 
-      StandardOutputWriter() = default;
-      ~StandardOutputWriter() = default;
+          StandardOutputWriter() = default;
+          ~StandardOutputWriter() = default;
 
-      bool write(const ls_std::byte_field &_data) override;
-  };
+          bool write(const ls::std::core::type::byte_field &_data) override;
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/StorableFile.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2021-05-01
+ * Changed:         2022-05-16
  *
  * */
 
@@ -12,29 +12,35 @@
 
 #include <string>
 #include <memory>
-#include "IStorable.hpp"
+#include <ls_std/core/interface/IStorable.hpp>
 #include "File.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class StorableFile : public ls_std::IStorable
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class StorableFile : public ls::std::core::interface::IStorable
+      {
+        public:
 
-      explicit StorableFile(const std::string &_path);
-      ~StorableFile() = default;
+          explicit StorableFile(const ::std::string &_path);
+          ~StorableFile() = default;
 
-      std::shared_ptr<ls_std::File> getFile();
-      ls_std::byte_field load() override;
-      void reset(const std::string &_path);
-      void save(const ls_std::byte_field &_data) override;
+          ::std::shared_ptr<ls::std::io::File> getFile();
+          ls::std::core::type::byte_field load() override;
+          void reset(const ::std::string &_path);
+          void save(const ls::std::core::type::byte_field &_data) override;
 
-    private:
+        private:
 
-      std::shared_ptr<ls_std::File> file{};
+          ::std::shared_ptr<ls::std::io::File> file{};
 
-      void _init(const std::string &_path);
-  };
+          void _init(const ::std::string &_path);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/kv/KvDocument.hpp

@@ -3,39 +3,45 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-07-15
+ * Changed:         2022-05-12
  *
  * */
 
 #ifndef LS_STD_KV_DOCUMENT_HPP
 #define LS_STD_KV_DOCUMENT_HPP
 
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include "KvPair.hpp"
-#include "KvTypes.hpp"
+#include <ls_std/core/types/KvTypes.hpp>
 #include <map>
 
-namespace ls_std
+namespace ls
 {
-  class KvDocument : public ls_std::Class
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class KvDocument : public ls::std::core::Class
+      {
+        public:
 
-      KvDocument();
-      ~KvDocument() override = default;
+          KvDocument();
+          ~KvDocument() override = default;
 
-      bool addPair(ls_std::KvPair _pair);
-      void clear();
-      std::map<ls_std::kv_key, ls_std::KvPair> getPairs();
-      bool hasPair(const ls_std::kv_key &_key);
-      bool removePair(const ls_std::kv_key &_key);
+          bool addPair(ls::std::io::KvPair _pair);
+          void clear();
+          ::std::map<ls::std::core::type::kv_key, ls::std::io::KvPair> getPairs();
+          bool hasPair(const ls::std::core::type::kv_key &_key);
+          bool removePair(const ls::std::core::type::kv_key &_key);
 
-    private:
+        private:
 
-      std::map<ls_std::kv_key, ls_std::KvPair> pairs{};
+          ::std::map<ls::std::core::type::kv_key, ls::std::io::KvPair> pairs{};
 
-      bool _hasPair(const ls_std::kv_key &_key);
-  };
+          bool _hasPair(const ls::std::core::type::kv_key &_key);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/kv/KvFileReader.hpp

@@ -3,46 +3,52 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-07-15
+ * Changed:         2022-05-16
  *
  * */
 
 #ifndef LS_STD_KV_FILE_READER_HPP
 #define LS_STD_KV_FILE_READER_HPP
 
-#include <ls_std/base/Class.hpp>
-#include <ls_std/io/IReader.hpp>
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/interface/IReader.hpp>
 #include <ls_std/io/kv/KvDocument.hpp>
 #include <ls_std/io/File.hpp>
 #include <memory>
 
-namespace ls_std
+namespace ls
 {
-  class KvFileReader : public ls_std::Class, public ls_std::IReader
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class KvFileReader : public ls::std::core::Class, public ls::std::core::interface::IReader
+      {
+        public:
 
-      explicit KvFileReader(const std::shared_ptr<ls_std::KvDocument> &_document, const std::string &_absolutePath);
-      ~KvFileReader() override = default;
+          explicit KvFileReader(const ::std::shared_ptr<ls::std::io::KvDocument> &_document, const ::std::string &_absolutePath);
+          ~KvFileReader() override = default;
 
-      // implementation
+          // implementation
 
-      ls_std::byte_field read() override;
+          ls::std::core::type::byte_field read() override;
 
-      // additional functionality
+          // additional functionality
 
-      std::shared_ptr<ls_std::KvDocument> getDocument();
-      void setDocument(const std::shared_ptr<ls_std::KvDocument> &_document);
-      void setFile(const ls_std::File &_kvFile);
+          ::std::shared_ptr<ls::std::io::KvDocument> getDocument();
+          void setDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document);
+          void setFile(const ls::std::io::File &_kvFile);
 
-    private:
+        private:
 
-      std::shared_ptr<ls_std::KvDocument> document{};
-      ls_std::File kvFile;
+          ::std::shared_ptr<ls::std::io::KvDocument> document{};
+          ls::std::io::File kvFile;
 
-      void _assignDocument(const std::shared_ptr<ls_std::KvDocument> &_document);
-      void _assignFile(ls_std::File _kvFile);
-  };
+          void _assignDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document);
+          void _assignFile(ls::std::io::File _kvFile);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/kv/KvPair.hpp

@@ -3,36 +3,42 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-05-02
+ * Changed:         2022-05-12
  *
  * */
 
 #ifndef LS_STD_KV_PAIR_HPP
 #define LS_STD_KV_PAIR_HPP
 
-#include <ls_std/base/Class.hpp>
-#include "KvTypes.hpp"
+#include <ls_std/core/Class.hpp>
+#include "ls_std/core/types/KvTypes.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class KvPair : public ls_std::Class
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class KvPair : public ls::std::core::Class
+      {
+        public:
 
-      explicit KvPair(const ls_std::kv_key &_key, ls_std::kv_value _value);
-      ~KvPair() override = default;
+          explicit KvPair(const ls::std::core::type::kv_key &_key, ls::std::core::type::kv_value _value);
+          ~KvPair() override = default;
 
-      ls_std::kv_key getKey();
-      ls_std::kv_value getValue();
-      void setValue(const ls_std::kv_value &_value);
+          ls::std::core::type::kv_key getKey();
+          ls::std::core::type::kv_value getValue();
+          void setValue(const ls::std::core::type::kv_value &_value);
 
-    private:
+        private:
 
-      ls_std::kv_key key{};
-      ls_std::kv_value value{};
+          ls::std::core::type::kv_key key{};
+          ls::std::core::type::kv_value value{};
 
-      void _assignKey(const ls_std::kv_key &_key);
-  };
+          void _assignKey(const ls::std::core::type::kv_key &_key);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/kv/KvParseParameter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-05-02
+ * Changed:         2022-05-13
  *
  * */
 
@@ -11,15 +11,20 @@
 #define LS_STD_KV_PARSE_DATA_HPP
 
 #include <string>
-#include <ls_std/boxing/String.hpp>
 
-namespace ls_std
+namespace ls
 {
-  struct KvParseParameter
+  namespace std
   {
-    std::string::size_type index{};
-    ls_std::String line{};
-  };
+    namespace io
+    {
+      struct KvParseParameter
+      {
+        ::std::string::size_type index{};
+        ::std::string line{};
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/kv/KvParser.hpp

@@ -3,44 +3,51 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-05-02
+ * Changed:         2022-05-13
  *
  * */
 
 #ifndef LS_STD_KV_PARSER_HPP
 #define LS_STD_KV_PARSER_HPP
 
-#include <ls_std/base/Class.hpp>
-#include <ls_std/base/Types.hpp>
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/types/Types.hpp>
 #include "KvDocument.hpp"
 #include "KvParseParameter.hpp"
 #include <memory>
 
-namespace ls_std
+namespace ls
 {
-  class KvParser : public ls_std::Class
+  namespace std
   {
-    public:
-
-      explicit KvParser(const std::shared_ptr<ls_std::KvDocument> &_document);
-      ~KvParser() override = default;
-
-      std::shared_ptr<ls_std::KvDocument> getDocument();
-      void parse(const ls_std::byte_field &_data);
-      void setDocument(const std::shared_ptr<ls_std::KvDocument> &_document);
-
-    private:
-
-      std::shared_ptr<ls_std::KvDocument> document{};
-
-      void _assignDocument(const std::shared_ptr<ls_std::KvDocument> &_document);
-      static bool _lineHasPair(ls_std::KvParseParameter _parseParameter);
-      void _parse(const ls_std::byte_field &_data);
-      void _parsePair(ls_std::KvParseParameter _parseParameter);
-      static ls_std::KvParseParameter _readLine(const ls_std::byte_field &_data, std::string::size_type _index);
-      static void _readLineWithUnixLineBreak(ls_std::KvParseParameter &_parseParameter);
-      static void _readLineWithWindowsLineBreak(ls_std::KvParseParameter &_parseParameter);
-  };
+    namespace io
+    {
+      class KvParser : public ls::std::core::Class
+      {
+        public:
+
+          explicit KvParser(const ::std::shared_ptr<ls::std::io::KvDocument> &_document);
+          ~KvParser() override = default;
+
+          ::std::shared_ptr<ls::std::io::KvDocument> getDocument();
+          void parse(const ls::std::core::type::byte_field &_data);
+          void setDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document);
+
+        private:
+
+          ::std::shared_ptr<ls::std::io::KvDocument> document{};
+
+          void _assignDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document);
+          static bool _contains(const ::std::string &_text, const ::std::string &_searchText);
+          static bool _lineHasPair(const ls::std::io::KvParseParameter& _parseParameter);
+          void _parse(const ls::std::core::type::byte_field &_data);
+          void _parsePair(const ls::std::io::KvParseParameter& _parseParameter);
+          static ls::std::io::KvParseParameter _readLine(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index);
+          static void _readLineWithUnixLineBreak(ls::std::io::KvParseParameter &_parseParameter);
+          static void _readLineWithWindowsLineBreak(ls::std::io::KvParseParameter &_parseParameter);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/logging/LogLevel.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2021-05-02
+ * Changed:         2022-05-11
  *
  * */
 
@@ -11,40 +11,46 @@
 #define LS_STD_LOG_LEVEL_HPP
 
 #include <unordered_map>
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include "LogLevelValue.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class LogLevel : public ls_std::Class
+  namespace std
   {
-    public:
-
-      explicit LogLevel(const ls_std::LogLevelValue &_value);
-      LogLevel();
-      ~LogLevel() override = default;
-
-      operator unsigned char() const;
-      ls_std::LogLevel &operator=(const ls_std::LogLevelValue &_value);
-      bool operator<(const ls_std::LogLevelValue &_value);
-      bool operator<=(const ls_std::LogLevelValue &_value);
-      bool operator>(const ls_std::LogLevelValue &_value);
-      bool operator>=(const ls_std::LogLevelValue &_value);
-      bool operator==(const ls_std::LogLevelValue &_value);
-
-      void setLogLevel(const ls_std::LogLevelValue &_value);
-      void setLogLevel(const std::string &_value);
-      std::string toString() const;
-
-    private:
-
-      std::unordered_map<uint8_t, std::string> level{};
-      ls_std::LogLevelValue value{};
-
-      ls_std::LogLevelValue _getValueFromString(const std::string &_value);
-      void _init();
-      bool _isValidLogLevelString(const std::string &_value);
-  };
+    namespace io
+    {
+      class LogLevel : public ls::std::core::Class
+      {
+        public:
+
+          explicit LogLevel(const ls::std::io::LogLevelValue &_value);
+          LogLevel();
+          ~LogLevel() override = default;
+
+          operator unsigned char() const;
+          ls::std::io::LogLevel &operator=(const ls::std::io::LogLevelValue &_value);
+          bool operator<(const ls::std::io::LogLevelValue &_value);
+          bool operator<=(const ls::std::io::LogLevelValue &_value);
+          bool operator>(const ls::std::io::LogLevelValue &_value);
+          bool operator>=(const ls::std::io::LogLevelValue &_value);
+          bool operator==(const ls::std::io::LogLevelValue &_value);
+
+          void setLogLevel(const ls::std::io::LogLevelValue &_value);
+          void setLogLevel(const ::std::string &_value);
+          ::std::string toString() const;
+
+        private:
+
+          ::std::unordered_map<uint8_t, ::std::string> level{};
+          ls::std::io::LogLevelValue value{};
+
+          ls::std::io::LogLevelValue _getValueFromString(const ::std::string &_value);
+          void _init();
+          bool _isValidLogLevelString(const ::std::string &_value);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/logging/LogLevelValue.hpp

@@ -3,19 +3,25 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2021-05-02
+ * Changed:         2022-05-11
  *
  * */
 
 #ifndef LS_STD_LOG_LEVEL_VALUE_HPP
 #define LS_STD_LOG_LEVEL_VALUE_HPP
 
-namespace ls_std
+namespace ls
 {
-  enum LogLevelValue
+  namespace std
   {
-    FATAL = 0, ERR, WARN, INFO, DEBUG, TRACE
-  };
+    namespace io
+    {
+      enum LogLevelValue
+      {
+        FATAL = 0, ERR, WARN, INFO, DEBUG, TRACE
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/logging/Logger.hpp

@@ -3,46 +3,56 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2021-07-16
+ * Changed:         2022-05-16
  *
  * */
 
 #ifndef LS_STD_LOGGER_HPP
 #define LS_STD_LOGGER_HPP
 
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include "LogLevel.hpp"
-#include <ls_std/io/IWriter.hpp>
+#include <ls_std/core/interface/IWriter.hpp>
 #include <ls_std/io/File.hpp>
 #include <ls_std/io/FileOutputStream.hpp>
 #include <string>
 
-namespace ls_std
+namespace ls
 {
-  class Logger : public ls_std::Class
+  namespace std
   {
-    public:
-
-      explicit Logger(const std::shared_ptr<ls_std::IWriter> &_writer);
-      ~Logger() override = default;
-
-      void debug(const ls_std::byte *_data);
-      void error(const ls_std::byte *_data);
-      void fatal(const ls_std::byte *_data);
-      ls_std::LogLevel getLogLevel();
-      void info(const ls_std::byte *_data);
-      void setLogLevel(const ls_std::LogLevelValue &_logLevelValue);
-      void trace(const ls_std::byte *_data);
-      void warn(const ls_std::byte *_data);
-
-    private:
-
-      ls_std::LogLevel logLevel{};
-      std::shared_ptr<ls_std::IWriter> writer{};
-
-      void _assignWriter(const std::shared_ptr<ls_std::IWriter> &_writer);
-      void _log(const ls_std::byte *_data, const ls_std::LogLevel &_logLevel);
-  };
+    namespace io
+    {
+      class Logger : public ls::std::core::Class
+      {
+        public:
+
+          explicit Logger(const ::std::shared_ptr<ls::std::core::interface::IWriter> &_writer);
+          ~Logger() override = default;
+
+          void debug(const ls::std::core::type::byte *_data);
+          void error(const ls::std::core::type::byte *_data);
+          void fatal(const ls::std::core::type::byte *_data);
+          ls::std::io::LogLevel getLogLevel();
+          void info(const ls::std::core::type::byte *_data);
+          void setLogLevel(const ls::std::io::LogLevelValue &_logLevelValue);
+          void trace(const ls::std::core::type::byte *_data);
+          void warn(const ls::std::core::type::byte *_data);
+
+        private:
+
+          ls::std::io::LogLevel logLevel{};
+          ::std::shared_ptr<ls::std::core::interface::IWriter> writer{};
+
+          void _assignWriter(const ::std::shared_ptr<ls::std::core::interface::IWriter> &_writer);
+          static ::std::string _buildCharacterChain(size_t _amount);
+          static ::std::string _createFillContent(const ::std::string &_text);
+          static ::std::string _generateTimeString(tm *_localTime);
+          void _log(const ls::std::core::type::byte *_data, const ls::std::io::LogLevel &_logLevel);
+          static ::std::string _padRight(const ::std::string& _text);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlAttribute.hpp

@@ -3,39 +3,45 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-23
- * Changed:         2021-07-16
+ * Changed:         2022-05-11
  *
  * */
 
 #ifndef LS_STD_XML_ATTRIBUTE_HPP
 #define LS_STD_XML_ATTRIBUTE_HPP
 
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include <string>
 
-namespace ls_std
+namespace ls
 {
-  class XmlAttribute : public ls_std::Class
+  namespace std
   {
-    public:
-
-      explicit XmlAttribute(const std::string& _name);
-      ~XmlAttribute() override = default;
-
-      std::string getName();
-      std::string getValue();
-      void setName(const std::string& _name);
-      void setValue(const std::string& _value);
-      std::string toXml();
-
-    private:
-
-      std::string name{};
-      std::string value{};
-
-      void _assignName(const std::string& _name);
-      void _assignValue(const std::string& _value);
-  };
+    namespace io
+    {
+      class XmlAttribute : public ls::std::core::Class
+      {
+        public:
+
+          explicit XmlAttribute(const ::std::string &_name);
+          ~XmlAttribute() override = default;
+
+          ::std::string getName();
+          ::std::string getValue();
+          void setName(const ::std::string &_name);
+          void setValue(const ::std::string &_value);
+          ::std::string toXml();
+
+        private:
+
+          ::std::string name{};
+          ::std::string value{};
+
+          void _assignName(const ::std::string &_name);
+          void _assignValue(const ::std::string &_value);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlDeclaration.hpp

@@ -3,41 +3,47 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2021-07-16
+ * Changed:         2022-05-11
  *
  * */
 
 #ifndef LS_STD_XML_DECLARATION_HPP
 #define LS_STD_XML_DECLARATION_HPP
 
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include "XmlAttribute.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class XmlDeclaration : public ls_std::Class
+  namespace std
   {
-    public:
-
-      explicit XmlDeclaration(const std::string& _version);
-      ~XmlDeclaration() override = default;
-
-      std::string getEncoding();
-      std::string getStandalone();
-      std::string getVersion();
-      void setEncoding(const std::string& _encoding);
-      void setStandalone(const std::string& _standalone);
-      void setVersion(const std::string& _version);
-      std::string toXml();
-
-    private:
-
-      ls_std::XmlAttribute encoding{"encoding"};
-      ls_std::XmlAttribute standalone{"standalone"};
-      ls_std::XmlAttribute version{"version"};
-
-      static std::string _toXmlAttribute(ls_std::XmlAttribute _attribute);
-  };
+    namespace io
+    {
+      class XmlDeclaration : public ls::std::core::Class
+      {
+        public:
+
+          explicit XmlDeclaration(const ::std::string &_version);
+          ~XmlDeclaration() override = default;
+
+          ::std::string getEncoding();
+          ::std::string getStandalone();
+          ::std::string getVersion();
+          void setEncoding(const ::std::string &_encoding);
+          void setStandalone(const ::std::string &_standalone);
+          void setVersion(const ::std::string &_version);
+          ::std::string toXml();
+
+        private:
+
+          ls::std::io::XmlAttribute encoding{"encoding"};
+          ls::std::io::XmlAttribute standalone{"standalone"};
+          ls::std::io::XmlAttribute version{"version"};
+
+          static ::std::string _toXmlAttribute(ls::std::io::XmlAttribute _attribute);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlDocument.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2021-07-16
+ * Changed:         2022-05-11
  *
  * */
 
@@ -11,33 +11,39 @@
 #define LS_STD_XML_DOCUMENT_HPP
 
 #include <memory>
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include "XmlNode.hpp"
 #include "XmlDeclaration.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class XmlDocument : public ls_std::Class
+  namespace std
   {
-    public:
-
-      XmlDocument();
-      ~XmlDocument() override = default;
-
-      std::shared_ptr<ls_std::XmlDeclaration> getDeclaration();
-      std::shared_ptr<ls_std::XmlNode> getRootElement();
-      void setDeclaration(const std::shared_ptr<ls_std::XmlDeclaration> &_declaration);
-      void setRootElement(const std::shared_ptr<ls_std::XmlNode> &_rootElement);
-      std::string toXml();
-
-    private:
-
-      std::shared_ptr<ls_std::XmlDeclaration> declaration{};
-      std::shared_ptr<ls_std::XmlNode> rootElement{};
-
-      void _assignDeclaration(const std::shared_ptr<ls_std::XmlDeclaration> &_declaration);
-      void _assignRootElement(const std::shared_ptr<ls_std::XmlNode> &_rootElement);
-  };
+    namespace io
+    {
+      class XmlDocument : public ls::std::core::Class
+      {
+        public:
+
+          XmlDocument();
+          ~XmlDocument() override = default;
+
+          ::std::shared_ptr<ls::std::io::XmlDeclaration> getDeclaration();
+          ::std::shared_ptr<ls::std::io::XmlNode> getRootElement();
+          void setDeclaration(const ::std::shared_ptr<ls::std::io::XmlDeclaration> &_declaration);
+          void setRootElement(const ::std::shared_ptr<ls::std::io::XmlNode> &_rootElement);
+          ::std::string toXml();
+
+        private:
+
+          ::std::shared_ptr<ls::std::io::XmlDeclaration> declaration{};
+          ::std::shared_ptr<ls::std::io::XmlNode> rootElement{};
+
+          void _assignDeclaration(const ::std::shared_ptr<ls::std::io::XmlDeclaration> &_declaration);
+          void _assignRootElement(const ::std::shared_ptr<ls::std::io::XmlNode> &_rootElement);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlNode.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-24
- * Changed:         2021-07-16
+ * Changed:         2022-05-11
  *
  * */
 
@@ -12,71 +12,77 @@
 
 #include <list>
 #include <memory>
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include "XmlAttribute.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class XmlNode : public ls_std::Class
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class XmlNode : public ls::std::core::Class
+      {
+        public:
 
-      explicit XmlNode(std::string _name);
-      ~XmlNode() override = default;
+          explicit XmlNode(::std::string _name);
+          ~XmlNode() override = default;
 
-      bool addAttributeAfter(const std::shared_ptr<ls_std::XmlAttribute> &_attribute, const std::string &_name);
-      bool addAttributeBefore(const std::shared_ptr<ls_std::XmlAttribute> &_attribute, const std::string &_name);
-      bool addAttributeToBeginning(const std::shared_ptr<ls_std::XmlAttribute> &_attribute);
-      bool addAttributeToEnd(const std::shared_ptr<ls_std::XmlAttribute> &_attribute);
-      bool addChildAfter(const std::shared_ptr<ls_std::XmlNode> &_child, const std::shared_ptr<ls_std::XmlNode> &_search);
-      bool addChildBefore(const std::shared_ptr<ls_std::XmlNode> &_child, const std::shared_ptr<ls_std::XmlNode> &_search);
-      bool addChildToBeginning(const std::shared_ptr<ls_std::XmlNode> &_child);
-      bool addChildToEnd(const std::shared_ptr<ls_std::XmlNode> &_child);
-      void clearValue();
-      std::list<std::shared_ptr<ls_std::XmlAttribute>> getAttributes();
-      std::list<std::shared_ptr<ls_std::XmlNode>> getChildren();
-      std::list<std::shared_ptr<ls_std::XmlNode>> getChildren(const std::string &_name);
-      std::string getName();
-      std::string getValue();
-      bool hasAttribute(const std::string &_name);
-      bool hasChild(const std::string &_name);
-      bool hasChild(const std::shared_ptr<ls_std::XmlNode> &_child);
-      bool removeFirstAttribute();
-      bool removeLastAttribute();
-      bool removeFirstChild();
-      bool removeLastChild();
-      void setName(const std::string &_name);
-      void setValue(const std::string &_value);
-      std::string toXml();
+          bool addAttributeAfter(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute, const ::std::string &_name);
+          bool addAttributeBefore(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute, const ::std::string &_name);
+          bool addAttributeToBeginning(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute);
+          bool addAttributeToEnd(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute);
+          bool addChildAfter(const ::std::shared_ptr<ls::std::io::XmlNode> &_child, const ::std::shared_ptr<ls::std::io::XmlNode> &_search);
+          bool addChildBefore(const ::std::shared_ptr<ls::std::io::XmlNode> &_child, const ::std::shared_ptr<ls::std::io::XmlNode> &_search);
+          bool addChildToBeginning(const ::std::shared_ptr<ls::std::io::XmlNode> &_child);
+          bool addChildToEnd(const ::std::shared_ptr<ls::std::io::XmlNode> &_child);
+          void clearValue();
+          ::std::list<::std::shared_ptr<ls::std::io::XmlAttribute>> getAttributes();
+          ::std::list<::std::shared_ptr<ls::std::io::XmlNode>> getChildren();
+          ::std::list<::std::shared_ptr<ls::std::io::XmlNode>> getChildren(const ::std::string &_name);
+          ::std::string getName();
+          ::std::string getValue();
+          bool hasAttribute(const ::std::string &_name);
+          bool hasChild(const ::std::string &_name);
+          bool hasChild(const ::std::shared_ptr<ls::std::io::XmlNode> &_child);
+          bool removeFirstAttribute();
+          bool removeLastAttribute();
+          bool removeFirstChild();
+          bool removeLastChild();
+          void setName(const ::std::string &_name);
+          void setValue(const ::std::string &_value);
+          ::std::string toXml();
 
-    protected:
+        protected:
 
-      std::string _toXml_(uint8_t _tabSize);
+          ::std::string _toXml_(uint8_t _tabSize);
 
-    private:
+        private:
 
-      std::list<std::shared_ptr<ls_std::XmlAttribute>> attributes{};
-      std::list<std::shared_ptr<ls_std::XmlNode>> children{};
-      std::string name{};
-      const static uint8_t TAB_SIZE{4};
-      std::string value{};
+          ::std::list<::std::shared_ptr<ls::std::io::XmlAttribute>> attributes{};
+          ::std::list<::std::shared_ptr<ls::std::io::XmlNode>> children{};
+          ::std::string name{};
+          const static uint8_t TAB_SIZE{4};
+          ::std::string value{};
 
-      void _assignName(const std::string &_name);
-      void _assignValue(const std::string &_value);
-      static void _checkIfAttributeReferenceIsValid(const std::shared_ptr<ls_std::XmlAttribute> &_attribute);
-      static void _checkIfNameIsNotEmpty(const std::string &_name);
-      static void _checkIfNodeReferenceIsValid(const std::shared_ptr<ls_std::XmlNode> &_child);
-      static std::string _getTab(uint8_t _tabSize);
-      bool _hasAttribute(const std::string &_name);
-      bool _hasChild(const std::shared_ptr<ls_std::XmlNode> &_child);
-      bool _hasChild(const std::string &_name);
-      std::string _toXmlAttributes();
-      std::string _toXmlChildren(uint8_t _tabSize);
-      std::string _toXmlCloseTag();
-      std::string _toXmlOpenTag();
-      std::string _toXmlOpenTagClose();
-      std::string _toXmlValue();
-  };
+          void _assignName(const ::std::string &_name);
+          void _assignValue(const ::std::string &_value);
+          static void _checkIfAttributeReferenceIsValid(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute);
+          static void _checkIfNameIsNotEmpty(const ::std::string &_name);
+          static void _checkIfNodeReferenceIsValid(const ::std::shared_ptr<ls::std::io::XmlNode> &_child);
+          static ::std::string _getTab(uint8_t _tabSize);
+          bool _hasAttribute(const ::std::string &_name);
+          bool _hasChild(const ::std::shared_ptr<ls::std::io::XmlNode> &_child);
+          bool _hasChild(const ::std::string &_name);
+          ::std::string _toXmlAttributes();
+          ::std::string _toXmlChildren(uint8_t _tabSize);
+          ::std::string _toXmlCloseTag();
+          ::std::string _toXmlOpenTag();
+          ::std::string _toXmlOpenTagClose();
+          ::std::string _toXmlValue();
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlParseMode.hpp

@@ -3,19 +3,25 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-13
- * Changed:         2021-05-02
+ * Changed:         2022-05-11
  *
  * */
 
 #ifndef LS_STD_XML_PARSE_MODE_HPP
 #define LS_STD_XML_PARSE_MODE_HPP
 
-namespace ls_std
+namespace ls
 {
-  enum XmlParseMode
+  namespace std
   {
-    XML_PARSE_MODE_ANALYZE = 0, XML_PARSE_MODE_DECLARATION, XML_PARSE_MODE_OPENING_TAG, XML_PARSE_MODE_VALUE, XML_PARSE_MODE_CLOSING_TAG
-  };
+    namespace io
+    {
+      enum XmlParseMode
+      {
+        XML_PARSE_MODE_ANALYZE = 0, XML_PARSE_MODE_DECLARATION, XML_PARSE_MODE_OPENING_TAG, XML_PARSE_MODE_VALUE, XML_PARSE_MODE_CLOSING_TAG
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlParseParameter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-17
- * Changed:         2021-05-02
+ * Changed:         2022-05-11
  *
  * */
 
@@ -14,13 +14,19 @@
 #include <memory>
 #include "XmlNode.hpp"
 
-namespace ls_std
+namespace ls
 {
-  struct XmlParseParameter
+  namespace std
   {
-    uint8_t level{};
-    std::shared_ptr<ls_std::XmlNode> node{};
-  };
+    namespace io
+    {
+      struct XmlParseParameter
+      {
+        uint8_t level{};
+        ::std::shared_ptr<ls::std::io::XmlNode> node{};
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlParser.hpp

@@ -3,71 +3,79 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-25
- * Changed:         2021-05-02
+ * Changed:         2022-05-13
  *
  * */
 
 #ifndef LS_STD_XML_PARSER_HPP
 #define LS_STD_XML_PARSER_HPP
 
-#include <ls_std/base/Class.hpp>
-#include <ls_std/base/Types.hpp>
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/types/Types.hpp>
 #include "XmlDocument.hpp"
 #include "XmlParseMode.hpp"
 #include "XmlParseParameter.hpp"
 #include <list>
 
-namespace ls_std
+namespace ls
 {
-  class XmlParser : public ls_std::Class
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class XmlParser : public ls::std::core::Class
+      {
+        public:
 
-      explicit XmlParser(const std::shared_ptr<ls_std::XmlDocument> &_document);
-      ~XmlParser() override = default;
+          explicit XmlParser(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
+          ~XmlParser() override = default;
 
-      std::shared_ptr<ls_std::XmlDocument> getDocument();
-      void parse(const ls_std::byte_field &_data);
-      void setDocument(const std::shared_ptr<ls_std::XmlDocument> &_document);
+          ::std::shared_ptr<ls::std::io::XmlDocument> getDocument();
+          void parse(const ls::std::core::type::byte_field &_data);
+          void setDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
 
-    protected:
+        protected:
 
-      static std::pair<std::string, std::string> _readAttribute_(const ls_std::byte_field &_data);
-      static std::list<std::pair<std::string, std::string>> _readAttributes_(ls_std::byte_field _data);
+          static ::std::pair<::std::string, ::std::string> _readAttribute_(const ls::std::core::type::byte_field &_data);
+          static ::std::list<::std::pair<::std::string, ::std::string>> _readAttributes_(ls::std::core::type::byte_field _data);
 
-    private:
+        private:
 
-      uint8_t currentLevel{};
-      std::shared_ptr<ls_std::XmlDocument> document{};
-      uint8_t maxLevel{};
-      ls_std::XmlParseMode mode{};
-      std::list<ls_std::XmlParseParameter> parseParameters{};
+          uint8_t currentLevel{};
+          ::std::shared_ptr<ls::std::io::XmlDocument> document{};
+          uint8_t maxLevel{};
+          ls::std::io::XmlParseMode mode{};
+          ::std::list<ls::std::io::XmlParseParameter> parseParameters{};
 
-      void _analyze(const ls_std::byte_field &_data, std::string::size_type _index);
-      void _assignDocument(const std::shared_ptr<ls_std::XmlDocument> &_document);
-      static std::shared_ptr<ls_std::XmlDeclaration> _createDeclaration(const std::list<std::pair<std::string, std::string>> &_attributes);
-      static std::shared_ptr<ls_std::XmlNode> _createNode(const std::list<std::pair<std::string, std::string>> &_attributes, const std::string &_name);
-      static std::pair<std::string, std::string> _findAttribute(const std::list<std::pair<std::string, std::string>> &_attributes, const std::string &_name);
-      static size_t _findAttributeEndPosition(const ls_std::byte_field &_data);
-      static ls_std::byte_field _getNextTagString(const ls_std::byte_field &_data, std::string::size_type _index);
-      void _isClosingTag(const ls_std::byte_field &_data, std::string::size_type _index);
-      void _isDeclaration(const ls_std::byte_field &_data, std::string::size_type _index);
-      void _isOpeningTag(const ls_std::byte_field &_data, std::string::size_type _index);
-      void _isValue(const ls_std::byte_field &_data, std::string::size_type _index);
-      void _mergeNodes();
-      void _mergeChildrenToParentNode(const std::shared_ptr<ls_std::XmlNode> &_parent, std::list<ls_std::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel);
-      void _mergeNodesOnCurrentLevel();
-      void _parse(const ls_std::byte_field &_data);
-      static std::pair<std::string, std::string> _parseAttribute(const ls_std::byte_field &_data);
-      static std::list<std::pair<std::string, std::string>> _parseAttributes(ls_std::byte_field _data);
-      size_t _parseClosingTag(const ls_std::byte_field &_data, std::string::size_type _index);
-      size_t _parseDeclaration(const ls_std::byte_field &_data, std::string::size_type _index);
-      size_t _parseOpeningTag(const ls_std::byte_field &_data, std::string::size_type _index);
-      static ls_std::byte_field _parseTagName(const ls_std::byte_field &_data);
-      size_t _parseValue(const ls_std::byte_field &_data, std::string::size_type _index);
-      void _reset();
-      void _setMaxLevel();
-  };
+          void _analyze(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index);
+          void _assignDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
+          static bool _contains(const ::std::string &_text, const ::std::string &_searchText);
+          static ::std::shared_ptr<ls::std::io::XmlDeclaration> _createDeclaration(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes);
+          static ::std::shared_ptr<ls::std::io::XmlNode> _createNode(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name);
+          static bool _endsWith(const ::std::string &_text, const ::std::string &_ending);
+          static ::std::pair<::std::string, ::std::string> _findAttribute(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name);
+          static size_t _findAttributeEndPosition(const ls::std::core::type::byte_field &_data);
+          static ls::std::core::type::byte_field _getNextTagString(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index);
+          void _isClosingTag(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index);
+          void _isDeclaration(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index);
+          void _isOpeningTag(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index);
+          void _isValue(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index);
+          void _mergeNodes();
+          void _mergeChildrenToParentNode(const ::std::shared_ptr<ls::std::io::XmlNode> &_parent, ::std::list<ls::std::io::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel);
+          void _mergeNodesOnCurrentLevel();
+          void _parse(const ls::std::core::type::byte_field &_data);
+          static ::std::pair<::std::string, ::std::string> _parseAttribute(const ls::std::core::type::byte_field &_data);
+          static ::std::list<::std::pair<::std::string, ::std::string>> _parseAttributes(ls::std::core::type::byte_field _data);
+          size_t _parseClosingTag(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index);
+          size_t _parseDeclaration(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index);
+          size_t _parseOpeningTag(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index);
+          static ls::std::core::type::byte_field _parseTagName(const ls::std::core::type::byte_field &_data);
+          size_t _parseValue(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index);
+          void _reset();
+          void _setMaxLevel();
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlReader.hpp

@@ -3,48 +3,54 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-08
- * Changed:         2021-05-02
+ * Changed:         2022-05-16
  *
  * */
 
 #ifndef LS_STD_XML_READER_HPP
 #define LS_STD_XML_READER_HPP
 
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include "XmlDocument.hpp"
-#include <ls_std/io/IReader.hpp>
+#include <ls_std/core/interface/IReader.hpp>
 #include <ls_std/io/File.hpp>
 #include "XmlParseMode.hpp"
 #include "XmlParseParameter.hpp"
 #include <list>
 
-namespace ls_std
+namespace ls
 {
-  class XmlReader : public ls_std::Class, public ls_std::IReader
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class XmlReader : public ls::std::core::Class, public ls::std::core::interface::IReader
+      {
+        public:
 
-      explicit XmlReader(const std::shared_ptr<ls_std::XmlDocument> &_document, const std::string &_absolutePath);
-      ~XmlReader() override = default;
+          explicit XmlReader(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document, const ::std::string &_absolutePath);
+          ~XmlReader() override = default;
 
-      // implementation
+          // implementation
 
-      ls_std::byte_field read() override;
+          ls::std::core::type::byte_field read() override;
 
-      // additional functionality
+          // additional functionality
 
-      std::shared_ptr<ls_std::XmlDocument> getDocument();
-      void setDocument(const std::shared_ptr<ls_std::XmlDocument> &_document);
-      void setFile(const ls_std::File &_xmlFile);
+          ::std::shared_ptr<ls::std::io::XmlDocument> getDocument();
+          void setDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
+          void setFile(const ls::std::io::File &_xmlFile);
 
-    private:
+        private:
 
-      std::shared_ptr<ls_std::XmlDocument> document{};
-      ls_std::File xmlFile;
+          ::std::shared_ptr<ls::std::io::XmlDocument> document{};
+          ls::std::io::File xmlFile;
 
-      void _assignDocument(const std::shared_ptr<ls_std::XmlDocument> &_document);
-      void _assignFile(ls_std::File _xmlFile);
-  };
+          void _assignDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
+          void _assignFile(ls::std::io::File _xmlFile);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/logic/IListener.hpp

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

include/ls_std/logic/Narrator.hpp

@@ -1,39 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-14
- * Changed:         2021-05-27
- *
- * */
-
-#ifndef LS_STD_NARRATOR_HPP
-#define LS_STD_NARRATOR_HPP
-
-#include <ls_std/base/Class.hpp>
-#include "IListener.hpp"
-#include <list>
-#include <memory>
-
-namespace ls_std
-{
-  class Narrator : public ls_std::Class
-  {
-    public:
-
-      Narrator();
-      ~Narrator() override = default;
-
-      bool addListener(const std::shared_ptr<ls_std::IListener> &_listener);
-      void clear();
-      std::list<std::shared_ptr<ls_std::IListener>> getListeners();
-      bool removeListener(const std::shared_ptr<ls_std::IListener> &_listener);
-      void tell(const ls_std::Class &_info);
-
-    private:
-
-      std::list<std::shared_ptr<ls_std::IListener>> listeners{};
-  };
-}
-
-#endif

include/ls_std/logic/State.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-05
- * Changed:         2021-07-14
+ * Changed:         2022-05-12
  *
  * */
 
@@ -12,39 +12,45 @@
 
 #include <memory>
 #include <unordered_map>
-#include <ls_std/base/Class.hpp>
-#include "StateMachineTypes.hpp"
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/types/StateMachineTypes.hpp>
 #include "StateConnection.hpp"
-#include <ls_std/serialization/ISerializable.hpp>
+#include <ls_std/core/interface/ISerializable.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class State : public ls_std::Class
+  namespace std
   {
-    public:
-
-      explicit State(const ls_std::StateId& _id);
-      ~State() override = default;
-
-      // additional functionality
-
-      bool addStateConnection(const ls_std::StateConnectionId &_connectionId, const std::shared_ptr<ls_std::State> &_connectedState);
-      bool addStateConnection(const std::shared_ptr<ls_std::StateConnection> &_connection);
-      void clearConnections();
-      std::unordered_map<ls_std::StateConnectionId, std::shared_ptr<ls_std::StateConnection>> getConnectedStates();
-      ls_std::StateId getId();
-      bool hasConnection(const ls_std::StateConnectionId &_connectionId);
-      void setId(const ls_std::StateId& _id);
-
-    private:
-
-      std::unordered_map<ls_std::StateConnectionId, std::shared_ptr<ls_std::StateConnection>> connectedStates{};
-      ls_std::StateId id{};
-
-      void _assignStateId(const ls_std::StateId& _id);
-      void _clearConnections();
-      bool _hasConnection(const ls_std::StateConnectionId &_connectionId);
-  };
+    namespace logic
+    {
+      class 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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-10
- * Changed:         2021-05-27
+ * Changed:         2022-05-12
  *
  * */
 
@@ -11,34 +11,40 @@
 #define LS_STD_STATE_CONNECTION_HPP
 
 #include <memory>
-#include <ls_std/base/Class.hpp>
-#include "StateMachineTypes.hpp"
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/types/StateMachineTypes.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class StateConnection : public ls_std::Class
+  namespace std
   {
-    public:
-
-      explicit StateConnection(const ls_std::StateConnectionId& _connectionId, const ls_std::StateId& _stateId);
-      ~StateConnection() override = default;
-
-      StateConnectionId getConnectionId();
-      ls_std::StateId getStateId();
-      bool isPassable() const;
-      void setConnectionId(const ls_std::StateConnectionId& _connectionId);
-      void setStateId(const ls_std::StateId& _stateId);
-      void updatePassCondition(bool _condition);
-
-    private:
-
-      bool condition{};
-      ls_std::StateConnectionId connectionId{};
-      ls_std::StateId stateId{};
-
-      void _assignConnectionId(const ls_std::StateConnectionId& _connectionId);
-      void _assignStateId(const ls_std::StateId& _stateId);
-  };
+    namespace logic
+    {
+      class 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();
+          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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-05
- * Changed:         2021-05-01
+ * Changed:         2022-05-12
  *
  * */
 
@@ -14,43 +14,49 @@
 #include <unordered_map>
 #include <string>
 #include <vector>
-#include <ls_std/base/Class.hpp>
+#include <ls_std/core/Class.hpp>
 #include "State.hpp"
-#include "StateMachineTypes.hpp"
+#include <ls_std/core/types/StateMachineTypes.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class StateMachine : public ls_std::Class
+  namespace std
   {
-    public:
-
-      explicit StateMachine(const std::string& _name);
-      ~StateMachine() override = default;
-
-      bool addState(const std::shared_ptr<ls_std::State> &_state);
-      std::shared_ptr<ls_std::State> getCurrentState();
-      std::vector<ls_std::StateId> getMemory();
-      std::string getName();
-      std::unordered_map<StateId, std::shared_ptr<ls_std::State>> getStates();
-      bool hasState(const ls_std::StateId &_id);
-      bool proceed();
-      void setMemory(const std::vector<ls_std::StateId>& _memory);
-      void setName(const std::string& _name);
-      bool setStartState(const ls_std::StateId &_id);
-
-    private:
-
-      std::shared_ptr<State> currentState{};
-      std::vector<ls_std::StateId> memory{};
-      std::string name{};
-      std::unordered_map<ls_std::StateId, std::shared_ptr<ls_std::State>> states{};
-
-      void _assignMemory(const std::vector<ls_std::StateId>& _memory);
-      void _assignName(const std::string& _name);
-      std::vector<ls_std::StateId> _getNextValidStates();
-      void _remember(const ls_std::StateId &_id);
-      bool _hasState(const ls_std::StateId &_id);
-  };
+    namespace logic
+    {
+      class 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

@@ -0,0 +1,57 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-09-15
+ * Changed:         2022-05-16
+ *
+ * */
+
+#ifndef LS_STD_SERIALIZABLE_JSON_STATE_HPP
+#define LS_STD_SERIALIZABLE_JSON_STATE_HPP
+
+#include <memory>
+#include <ls_std/lib/nlohmann_json/include/nlohmann/json.hpp>
+#include <ls_std/logic/State.hpp>
+#include <ls_std/core/interface/ISerializable.hpp>
+#include <ls_std/core/Class.hpp>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace logic
+    {
+      class SerializableJsonState : public ls::std::core::Class, public ls::std::core::interface::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:
+
+          nlohmann::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

@@ -0,0 +1,55 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-09-14
+ * Changed:         2022-05-16
+ *
+ * */
+
+#ifndef LS_STD_SERIALIZABLE_JSON_STATE_CONNECTION_HPP
+#define LS_STD_SERIALIZABLE_JSON_STATE_CONNECTION_HPP
+
+#include <memory>
+#include <ls_std/lib/nlohmann_json/include/nlohmann/json.hpp>
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/interface/ISerializable.hpp>
+#include <ls_std/logic/StateConnection.hpp>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace logic
+    {
+      class SerializableJsonStateConnection : public ls::std::core::Class, public ls::std::core::interface::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:
+
+          nlohmann::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

@@ -0,0 +1,58 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-09-17
+ * Changed:         2022-05-16
+ *
+ * */
+
+#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/lib/nlohmann_json/include/nlohmann/json.hpp>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace logic
+    {
+      class SerializableJsonStateMachine : public ls::std::core::Class, public ls::std::core::interface::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:
+
+          nlohmann::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.hpp

@@ -1,95 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-10-29
- * Changed:         2021-09-18
- *
- * */
-
-#ifndef LS_STD_LS_STD_HPP
-#define LS_STD_LS_STD_HPP
-
-#if _WIN32
-#include <winsock2.h>
-#endif
-
-#include "base/Class.hpp"
-#include "base/Types.hpp"
-#include "base/Version.hpp"
-#include "base/LibraryVersion.hpp"
-
-#include "boxing/IBoxing.hpp"
-#include "boxing/Boolean.hpp"
-#include "boxing/Double.hpp"
-#include "boxing/Float.hpp"
-#include "boxing/Integer.hpp"
-#include "boxing/Long.hpp"
-#include "boxing/String.hpp"
-
-#include "exception/EventNotHandledException.hpp"
-#include "exception/EventNotSubscribedException.hpp"
-#include "exception/FileNotFoundException.hpp"
-#include "exception/FileOperationException.hpp"
-#include "exception/IllegalArgumentException.hpp"
-#include "exception/IllegalArithmeticOperationException.hpp"
-#include "exception/IncompleteJsonException.hpp"
-#include "exception/NullPointerException.hpp"
-
-#include "io/logging/LogLevel.hpp"
-#include "io/logging/LogLevelValue.hpp"
-#include "io/logging/Logger.hpp"
-#include "io/xml/XmlReader.hpp"
-#include "io/xml/XmlParseMode.hpp"
-#include "io/xml/XmlParseParameter.hpp"
-#include "io/xml/XmlNode.hpp"
-#include "io/xml/XmlDocument.hpp"
-#include "io/xml/XmlDeclaration.hpp"
-#include "io/xml/XmlAttribute.hpp"
-#include "io/xml/XmlParser.hpp"
-#include "io/File.hpp"
-#include "io/FileOutputStream.hpp"
-#include "io/FilePathSeparator.hpp"
-#include "io/FilePathSeparatorMatch.hpp"
-#include "io/FileReader.hpp"
-#include "io/FileWriter.hpp"
-#include "io/IReader.hpp"
-#include "io/IStorable.hpp"
-#include "io/IWriter.hpp"
-#include "io/NewLine.hpp"
-#include "io/StorableFile.hpp"
-#include "io/StandardOutputWriter.hpp"
-#include "io/kv/KvPair.hpp"
-#include "io/kv/KvDocument.hpp"
-#include "io/kv/KvParser.hpp"
-#include "io/kv/KvFileReader.hpp"
-
-#include "logic/State.hpp"
-#include "logic/StateConnection.hpp"
-#include "logic/StateMachine.hpp"
-#include "logic/StateMachineTypes.hpp"
-
-#include "serialization/json/logic/SerializableJsonState.hpp"
-#include "serialization/json/logic/SerializableJsonStateConnection.hpp"
-#include "serialization/json/logic/SerializableJsonStateMachine.hpp"
-#include "serialization/json/event/SerializableJsonEvent.hpp"
-#include "serialization/ISerializable.hpp"
-
-#include "time/Date.hpp"
-
-#include "utils/RegexUtils.hpp"
-#include "utils/STLUtils.hpp"
-
-#if _WIN32
-#include "utils/WindowsUtils.hpp"
-#endif
-
-#include "event/Event.hpp"
-#include "event/EventTypes.hpp"
-#include "event/EventHandler.hpp"
-#include "event/IEventSubscriber.hpp"
-#include "event/EventManager.hpp"
-
-#include "factory/IFactory.hpp"
-
-#endif

include/ls_std/ls_std_boxing.hpp

@@ -0,0 +1,20 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-05-13
+ * Changed:         2022-05-13
+ *
+ * */
+
+#ifndef LS_STD_LS_STD_BOXING_HPP
+#define LS_STD_LS_STD_BOXING_HPP
+
+#include <ls_std/boxing/Boolean.hpp>
+#include <ls_std/boxing/Double.hpp>
+#include <ls_std/boxing/Float.hpp>
+#include <ls_std/boxing/Integer.hpp>
+#include <ls_std/boxing/Long.hpp>
+#include <ls_std/boxing/String.hpp>
+
+#endif

include/ls_std/ls_std_core.hpp

@@ -0,0 +1,45 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-05-13
+ * Changed:         2022-05-16
+ *
+ * */
+
+#ifndef LS_STD_LS_STD_CORE_HPP
+#define LS_STD_LS_STD_CORE_HPP
+
+#include <ls_std/core/exception/EventNotHandledException.hpp>
+#include <ls_std/core/exception/EventNotSubscribedException.hpp>
+#include <ls_std/core/exception/FileNotFoundException.hpp>
+#include <ls_std/core/exception/FileOperationException.hpp>
+#include <ls_std/core/exception/IllegalArgumentException.hpp>
+#include <ls_std/core/exception/IllegalArithmeticOperationException.hpp>
+#include <ls_std/core/exception/IncompleteJsonException.hpp>
+#include <ls_std/core/exception/NullPointerException.hpp>
+
+#include <ls_std/core/interface/IBoxing.hpp>
+#include <ls_std/core/interface/IEventSubscriber.hpp>
+#include <ls_std/core/interface/IListener.hpp>
+#include <ls_std/core/interface/IReader.hpp>
+#include <ls_std/core/interface/ISerializable.hpp>
+#include <ls_std/core/interface/IStorable.hpp>
+#include <ls_std/core/interface/IWriter.hpp>
+
+#include <ls_std/core/types/EventTypes.hpp>
+#include <ls_std/core/types/KvTypes.hpp>
+#include <ls_std/core/types/StateMachineTypes.hpp>
+#include <ls_std/core/types/Types.hpp>
+
+#include <ls_std/core/utils/RegexUtils.hpp>
+#include <ls_std/core/utils/STLUtils.hpp>
+#if _WIN32
+#include <ls_std/core/utils/WindowsUtils.hpp>
+#endif
+
+#include <ls_std/core/Class.hpp>
+#include <ls_std/core/LibraryVersion.hpp>
+#include <ls_std/core/Version.hpp>
+
+#endif

include/ls_std/ls_std_event.hpp

@@ -0,0 +1,19 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-05-14
+ * Changed:         2022-05-14
+ *
+ * */
+
+#ifndef LS_STD_LS_STD_EVENT_HPP
+#define LS_STD_LS_STD_EVENT_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

include/ls_std/ls_std_io.hpp

@@ -0,0 +1,39 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-05-14
+ * Changed:         2022-05-14
+ *
+ * */
+
+#ifndef LS_STD_LS_STD_IO_HPP
+#define LS_STD_LS_STD_IO_HPP
+
+#include <ls_std/io/kv/KvDocument.hpp>
+#include <ls_std/io/kv/KvFileReader.hpp>
+#include <ls_std/io/kv/KvPair.hpp>
+#include <ls_std/io/kv/KvParseParameter.hpp>
+#include <ls_std/io/kv/KvParser.hpp>
+#include <ls_std/io/logging/Logger.hpp>
+#include <ls_std/io/logging/LogLevel.hpp>
+#include <ls_std/io/logging/LogLevelValue.hpp>
+#include <ls_std/io/xml/XmlAttribute.hpp>
+#include <ls_std/io/xml/XmlDeclaration.hpp>
+#include <ls_std/io/xml/XmlDocument.hpp>
+#include <ls_std/io/xml/XmlNode.hpp>
+#include <ls_std/io/xml/XmlParseMode.hpp>
+#include <ls_std/io/xml/XmlParseParameter.hpp>
+#include <ls_std/io/xml/XmlParser.hpp>
+#include <ls_std/io/xml/XmlReader.hpp>
+#include <ls_std/io/File.hpp>
+#include <ls_std/io/FileOutputStream.hpp>
+#include <ls_std/io/FilePathSeparator.hpp>
+#include <ls_std/io/FilePathSeparatorMatch.hpp>
+#include <ls_std/io/FileReader.hpp>
+#include <ls_std/io/FileWriter.hpp>
+#include <ls_std/io/NewLine.hpp>
+#include <ls_std/io/StandardOutputWriter.hpp>
+#include <ls_std/io/StorableFile.hpp>
+
+#endif

include/ls_std/ls_std_logic.hpp

@@ -0,0 +1,20 @@
+/*
+ * 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

include/ls_std/ls_std_time.hpp

@@ -0,0 +1,15 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-05-16
+ * Changed:         2022-05-16
+ *
+ * */
+
+#ifndef LS_STD_LS_STD_TIME_HPP
+#define LS_STD_LS_STD_TIME_HPP
+
+#include <ls_std/time/Date.hpp>
+
+#endif

include/ls_std/serialization/ISerializable.hpp

@@ -1,29 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-08-21
- * Changed:         2021-04-23
- *
- * */
-
-#ifndef LS_STD_SERIALIZABLE_HPP
-#define LS_STD_SERIALIZABLE_HPP
-
-#include <ls_std/base/Types.hpp>
-
-namespace ls_std
-{
-  class ISerializable
-  {
-    public:
-
-      ISerializable() = default;
-      ~ISerializable() = default;
-
-      virtual ls_std::byte_field marshal() = 0;
-      virtual void unmarshal(const ls_std::byte_field &_data) = 0;
-  };
-}
-
-#endif

include/ls_std/serialization/json/event/SerializableJsonEvent.hpp

@@ -1,50 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-12-07
- * Changed:         2021-05-02
- *
- * */
-
-#ifndef LS_STD_SERIALIZABLE_JSON_EVENT_HPP
-#define LS_STD_SERIALIZABLE_JSON_EVENT_HPP
-
-#include <ls_std/serialization/ISerializable.hpp>
-#include <ls_std/base/Class.hpp>
-#include <ls_std/event/Event.hpp>
-#include <memory>
-#include <ls_std/lib/nlohmann_json/include/nlohmann/json.hpp>
-
-namespace ls_std
-{
-  class SerializableJsonEvent : public ls_std::Class, public ls_std::ISerializable
-  {
-    public:
-
-      explicit SerializableJsonEvent(const std::shared_ptr<ls_std::Event> &_value);
-      ~SerializableJsonEvent() override = default;
-
-      // implementation
-
-      ls_std::byte_field marshal() override;
-      void unmarshal(const ls_std::byte_field &_data) override;
-
-      // additional functionality
-
-      std::shared_ptr<ls_std::Event> getValue();
-      void setValue(const std::shared_ptr<ls_std::Event> &_value);
-
-    private:
-
-      nlohmann::json jsonObject{};
-      std::shared_ptr<ls_std::Event> value{};
-
-      void _assignValue(const std::shared_ptr<ls_std::Event> &_value);
-      void _unmarshalParameterList();
-      void _update();
-      void _updateEventParameterList();
-  };
-}
-
-#endif

include/ls_std/serialization/json/logic/SerializableJsonState.hpp

@@ -1,51 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-15
- * Changed:         2021-05-02
- *
- * */
-
-#ifndef LS_STD_SERIALIZABLE_JSON_STATE_HPP
-#define LS_STD_SERIALIZABLE_JSON_STATE_HPP
-
-#include <memory>
-#include <ls_std/lib/nlohmann_json/include/nlohmann/json.hpp>
-#include <ls_std/logic/State.hpp>
-#include <ls_std/serialization/ISerializable.hpp>
-#include <ls_std/base/Class.hpp>
-
-namespace ls_std
-{
-  class SerializableJsonState : public ls_std::Class, public ls_std::ISerializable
-  {
-    public:
-
-      explicit SerializableJsonState(const std::shared_ptr<ls_std::State> &_value);
-      ~SerializableJsonState() override = default;
-
-      // implementation
-
-      ls_std::byte_field marshal() override;
-      void unmarshal(const ls_std::byte_field &_data) override;
-
-      // additional functionality
-
-      std::shared_ptr<ls_std::State> getValue();
-      void setValue(const std::shared_ptr<ls_std::State> &_value);
-
-    private:
-
-      nlohmann::json jsonObject{};
-      std::shared_ptr<ls_std::State> value{};
-
-      void _assignValue(const std::shared_ptr<ls_std::State> &_value);
-      void _clear();
-      void _unmarshalStateConnections();
-      void _update();
-      void _updateStateConnections();
-  };
-}
-
-#endif

include/ls_std/serialization/json/logic/SerializableJsonStateConnection.hpp

@@ -1,49 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-14
- * Changed:         2021-05-02
- *
- * */
-
-#ifndef LS_STD_SERIALIZABLE_JSON_STATE_CONNECTION_HPP
-#define LS_STD_SERIALIZABLE_JSON_STATE_CONNECTION_HPP
-
-#include <memory>
-#include <ls_std/lib/nlohmann_json/include/nlohmann/json.hpp>
-#include <ls_std/base/Class.hpp>
-#include <ls_std/serialization/ISerializable.hpp>
-#include <ls_std/logic/StateConnection.hpp>
-
-namespace ls_std
-{
-  class SerializableJsonStateConnection : public ls_std::Class, public ls_std::ISerializable
-  {
-    public:
-
-      explicit SerializableJsonStateConnection(const std::shared_ptr<ls_std::StateConnection> &_value);
-      ~SerializableJsonStateConnection() override = default;
-
-      // implementation
-
-      ls_std::byte_field marshal() override;
-      void unmarshal(const ls_std::byte_field &_data) override;
-
-      // additional functionality
-
-      std::shared_ptr<ls_std::StateConnection> getValue();
-      void setValue(const std::shared_ptr<ls_std::StateConnection> &_value);
-
-    private:
-
-      nlohmann::json jsonObject{};
-      std::shared_ptr<ls_std::StateConnection> value{};
-
-      void _assignValue(const std::shared_ptr<ls_std::StateConnection> &_value);
-      void _clear();
-      void _update();
-  };
-}
-
-#endif

include/ls_std/serialization/json/logic/SerializableJsonStateMachine.hpp

@@ -1,52 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-17
- * Changed:         2021-05-02
- *
- * */
-
-#ifndef LS_STD_SERIALIZABLE_JSON_STATE_MACHINE_HPP
-#define LS_STD_SERIALIZABLE_JSON_STATE_MACHINE_HPP
-
-#include <ls_std/base/Class.hpp>
-#include <ls_std/serialization/ISerializable.hpp>
-#include <ls_std/logic/StateMachine.hpp>
-#include <memory>
-#include <ls_std/lib/nlohmann_json/include/nlohmann/json.hpp>
-
-namespace ls_std
-{
-  class SerializableJsonStateMachine : public ls_std::Class, public ls_std::ISerializable
-  {
-    public:
-
-      explicit SerializableJsonStateMachine(const std::shared_ptr<ls_std::StateMachine> &_value);
-      ~SerializableJsonStateMachine() override = default;
-
-      // implementation
-
-      ls_std::byte_field marshal() override;
-      void unmarshal(const ls_std::byte_field &_data) override;
-
-      // additional functionality
-
-      std::shared_ptr<ls_std::StateMachine> getValue();
-      void setValue(const std::shared_ptr<ls_std::StateMachine> &_value);
-
-    private:
-
-      nlohmann::json jsonObject{};
-      std::shared_ptr<ls_std::StateMachine> value{};
-
-      void _assignValue(const std::shared_ptr<ls_std::StateMachine> &_value);
-      void _unmarshalCurrentState();
-      void _unmarshalStates();
-      void _update();
-      void _updateCurrentState();
-      void _updateStates();
-  };
-}
-
-#endif