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

CMakeLists.txt

@@ -1,19 +1,67 @@
+####################################################################################################################
+####################################################################################################################
+####################################################################################################################
+# General
+####################################################################################################################
+####################################################################################################################
+####################################################################################################################
+
 ##########################################################
 # Basic
 ##########################################################
 
 cmake_minimum_required(VERSION 3.17)
-project(ls_std VERSION 2021.2.0)
+project(ls_std VERSION 2022.1.0)
+
+set(MODULE_NAME_BOXING ls_std_boxing)
+set(MODULE_NAME_CORE ls_std_core)
+set(MODULE_NAME_ENCODING ls_std_encoding)
+set(MODULE_NAME_EVENT ls_std_event)
+set(MODULE_NAME_IO ls_std_io)
+set(MODULE_NAME_LOGIC ls_std_logic)
+set(MODULE_NAME_TIME ls_std_time)
+
+set(GOOGLE_TEST_MODULE googletest-1.11.0)
 
 ##########################################################
 # Options
 ##########################################################
 
 option(LS_STD_BUILD_WITH_TESTS "Build project with tests..." OFF)
+option(LS_STD_BUILD_WITH_SUPPORTED_COMPILER "Build project with supported compiler only..." ON)
 option(LS_STD_BUILD_STATIC "Build ls_std static library..." ON)
 option(LS_STD_BUILD_SHARED "Build ls_std shared library..." OFF)
 option(LS_STD_BUILD_MODULE "Build ls_std module library..." OFF)
 
+set(TARGET_COUNTER 0)
+
+if (${LS_STD_BUILD_STATIC})
+    math(EXPR TARGET_COUNTER "${TARGET_COUNTER} + 1")
+    set(GOAL "static library")
+endif ()
+
+if (${LS_STD_BUILD_SHARED})
+    math(EXPR TARGET_COUNTER "${TARGET_COUNTER} + 1")
+    set(GOAL "shared library")
+endif ()
+
+if (${LS_STD_BUILD_MODULE})
+    math(EXPR TARGET_COUNTER "${TARGET_COUNTER} + 1")
+    set(GOAL "module library")
+endif ()
+
+message("${PROJECT_NAME}: [Goal] ${GOAL}")
+
+if (TARGET_COUNTER GREATER 1)
+    message("${PROJECT_NAME}: [Error] only one goal supported at the same time!")
+    return()
+endif ()
+
+if (TARGET_COUNTER EQUAL 0)
+    message("${PROJECT_NAME}: [Error] no goal selected!")
+    return()
+endif ()
+
 ##########################################################
 # Compiler Settings
 ##########################################################
@@ -23,6 +71,37 @@ set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
+##########################################################
+# Compiler Support
+##########################################################
+
+if(${LS_STD_BUILD_WITH_SUPPORTED_COMPILER})
+    message("${PROJECT_NAME}: build with compiler support...")
+
+    # define supported compilers
+
+    if (${CMAKE_CXX_COMPILER_ID} STREQUAL MSVC OR ${CMAKE_CXX_COMPILER_ID} STREQUAL GNU)
+        message("${PROJECT_NAME}: ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION} is supported...")
+    else()
+        message("${PROJECT_NAME}: [Error] ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION} is not supported... terminated!")
+        return()
+    endif ()
+
+    # define which compilers are supported for shared or module goal
+
+    if (${CMAKE_CXX_COMPILER_ID} STREQUAL MSVC AND ${LS_STD_BUILD_SHARED} OR ${LS_STD_BUILD_MODULE})
+        message("${PROJECT_NAME}: [Error] building \"${GOAL}\" with ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION} is not supported... terminated!")
+        return()
+    endif ()
+endif()
+
+# define which goals can run tests
+
+if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_SHARED} OR ${LS_STD_BUILD_MODULE})
+    message("${PROJECT_NAME}: [Error] building \"${GOAL}\" with tests is not supported... terminated!")
+    return()
+endif ()
+
 ######################################################
 # Include Directories
 ######################################################
@@ -31,8 +110,8 @@ message("${PROJECT_NAME}: Adding include directories...")
 
 if (${LS_STD_BUILD_WITH_TESTS})
     include_directories(${CMAKE_CURRENT_SOURCE_DIR}/test)
-    include_directories(${CMAKE_CURRENT_LIST_DIR}/test/lib/googletest-1.8.1/googletest/include)
-    include_directories(${CMAKE_CURRENT_LIST_DIR}/test/lib/googletest-1.8.1/googlemock/include)
+    include_directories(${CMAKE_CURRENT_LIST_DIR}/test/lib/${GOOGLE_TEST_MODULE}/googletest/include)
+    include_directories(${CMAKE_CURRENT_LIST_DIR}/test/lib/${GOOGLE_TEST_MODULE}/googlemock/include)
 endif ()
 
 include_directories(${CMAKE_CURRENT_LIST_DIR}/include)
@@ -44,154 +123,527 @@ include_directories(${CMAKE_CURRENT_LIST_DIR}/include)
 message("${PROJECT_NAME}: Adding additional cmake dependencies...")
 
 if (${LS_STD_BUILD_WITH_TESTS})
-    add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/test/lib/googletest-1.8.1)
+    add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/test/lib/${GOOGLE_TEST_MODULE})
 endif ()
 
-##########################################################
-# Source Files
-##########################################################
+####################################################################################################################
+####################################################################################################################
+####################################################################################################################
+# Source Files Modularization
+####################################################################################################################
+####################################################################################################################
+####################################################################################################################
 
-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_ENCODING
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/encoding/Base64.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)
+
+####################################################################################################################
+####################################################################################################################
+####################################################################################################################
+# Test Files Modularization
+####################################################################################################################
+####################################################################################################################
+####################################################################################################################
 
 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_ENCODING
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/encoding/Base64Test.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 ()
+
+####################################################################################################################
+####################################################################################################################
+####################################################################################################################
+# Test Suite Builds
+####################################################################################################################
+####################################################################################################################
+####################################################################################################################
+
+##########################################################
+# 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 (encoding)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS})
+    message("${MODULE_NAME_ENCODING}: Building tests...")
+    add_executable(${MODULE_NAME_ENCODING}_test ${TEST_FILES_ENCODING})
+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 ()
 
 ##########################################################
-# Build Tests
+# Build Tests (all)
 ##########################################################
 
 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_ENCODING}
+            ${TEST_FILES_EVENT}
+            ${TEST_FILES_IO}
+            ${TEST_FILES_LOGIC}
+            ${TEST_FILES_SERIALIZATION}
+            ${TEST_FILES_TIME})
 endif ()
 
+####################################################################################################################
+####################################################################################################################
+####################################################################################################################
+# Build Library Binaries
+####################################################################################################################
+####################################################################################################################
+####################################################################################################################
+
 ##########################################################
-# 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})
+    target_link_libraries("${MODULE_NAME_BOXING}" ${MODULE_NAME_CORE})
+    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 ()
 
 ##########################################################
-# Linking
+# Build Library (core)
 ##########################################################
 
-if (${LS_STD_BUILD_WITH_TESTS})
+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 ()
+
+if (${LS_STD_BUILD_SHARED})
+    add_library("${MODULE_NAME_CORE}" SHARED ${SOURCE_FILES_CORE})
+    set_target_properties("${MODULE_NAME_CORE}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+if (${LS_STD_BUILD_MODULE})
+    add_library("${MODULE_NAME_CORE}" MODULE ${SOURCE_FILES_CORE})
+    set_target_properties("${MODULE_NAME_CORE}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+##########################################################
+# Build Library (encoding)
+##########################################################
+
+message("${PROJECT_NAME}: Building ${MODULE_NAME_ENCODING} library version ${PROJECT_VERSION}...")
+
+if (${LS_STD_BUILD_STATIC})
+    add_library("${MODULE_NAME_ENCODING}" STATIC ${SOURCE_FILES_ENCODING})
+    set_target_properties("${MODULE_NAME_ENCODING}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+if (${LS_STD_BUILD_SHARED})
+    add_library("${MODULE_NAME_ENCODING}" SHARED ${SOURCE_FILES_ENCODING})
+    set_target_properties("${MODULE_NAME_ENCODING}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+if (${LS_STD_BUILD_MODULE})
+    add_library("${MODULE_NAME_ENCODING}" MODULE ${SOURCE_FILES_ENCODING})
+    set_target_properties("${MODULE_NAME_ENCODING}" 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 ()
+
+if (${LS_STD_BUILD_SHARED})
+    add_library("${MODULE_NAME_EVENT}" SHARED ${SOURCE_FILES_EVENT})
+    target_link_libraries("${MODULE_NAME_EVENT}" ${MODULE_NAME_CORE})
+    set_target_properties("${MODULE_NAME_EVENT}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+if (${LS_STD_BUILD_MODULE})
+    add_library("${MODULE_NAME_EVENT}" MODULE ${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 ()
+
+if (${LS_STD_BUILD_SHARED})
+    add_library("${MODULE_NAME_IO}" SHARED ${SOURCE_FILES_IO})
+    target_link_libraries("${MODULE_NAME_IO}" ${MODULE_NAME_CORE})
+    set_target_properties("${MODULE_NAME_IO}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+if (${LS_STD_BUILD_MODULE})
+    add_library("${MODULE_NAME_IO}" MODULE ${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 ()
+
+if (${LS_STD_BUILD_SHARED})
+    add_library("${MODULE_NAME_LOGIC}" SHARED ${SOURCE_FILES_LOGIC})
+    target_link_libraries("${MODULE_NAME_LOGIC}" ${MODULE_NAME_CORE})
+    set_target_properties("${MODULE_NAME_LOGIC}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+if (${LS_STD_BUILD_MODULE})
+    add_library("${MODULE_NAME_LOGIC}" MODULE ${SOURCE_FILES_LOGIC})
+    set_target_properties("${MODULE_NAME_LOGIC}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+##########################################################
+# Build Library (time)
+##########################################################
+
+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 ()
+
+if (${LS_STD_BUILD_SHARED})
+    add_library("${MODULE_NAME_TIME}" SHARED ${SOURCE_FILES_TIME})
+    target_link_libraries("${MODULE_NAME_TIME}" ${MODULE_NAME_CORE})
+    set_target_properties("${MODULE_NAME_TIME}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+if (${LS_STD_BUILD_MODULE})
+    add_library("${MODULE_NAME_TIME}" MODULE ${SOURCE_FILES_TIME})
+    set_target_properties("${MODULE_NAME_TIME}" PROPERTIES DEBUG_POSTFIX "_d")
+endif ()
+
+####################################################################################################################
+####################################################################################################################
+####################################################################################################################
+# Test Suite: Static Linking
+####################################################################################################################
+####################################################################################################################
+####################################################################################################################
+
+##########################################################
+# Static Linking (boxing)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+    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 ()
+
+##########################################################
+# Static Linking (core)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+    message("${MODULE_NAME_CORE}: Linking libraries for test application...")
+    target_link_libraries(${MODULE_NAME_CORE}_test
+            gtest
+            gmock
+            gtest_main
+            "${MODULE_NAME_CORE}")
+endif ()
+
+##########################################################
+# Static Linking (encoding)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+    message("${MODULE_NAME_ENCODING}: Linking libraries for test application...")
+    target_link_libraries(${MODULE_NAME_ENCODING}_test
+            gtest
+            gmock
+            gtest_main
+            "${MODULE_NAME_ENCODING}"
+            "${MODULE_NAME_CORE}")
+endif ()
+
+##########################################################
+# Static Linking (event)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+    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 ()
+
+##########################################################
+# Static Linking (io)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+    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 ()
+
+##########################################################
+# Static Linking (logic)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+    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 ()
+
+##########################################################
+# Static Linking (time)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+    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 ()
+
+##########################################################
+# Static Linking (all)
+##########################################################
+
+if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
     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_ENCODING}"
+            "${MODULE_NAME_EVENT}"
+            "${MODULE_NAME_IO}"
+            "${MODULE_NAME_LOGIC}"
+            "${MODULE_NAME_TIME}")
 endif ()

README.md

@@ -1,78 +1,55 @@
-# Lynar Studios - Standard Library 2021.2.0 #
+# Lynar Studios - Standard Library 2022.1.0 #
 
-This is a cross-platform standard library written in C++ offering functionalities you'd usually miss in C++ standard library, especially if you'd search for cross-platform implementations. This library has been tested on __Windows__, __Linux__ and __MacOS__ systems.
+This is a cross-platform standard library written in C++ offering functionalities you would usually miss in C++'s standard template library (STL), especially if you would search for cross-platform implementations.  
+This library has been tested on __Windows__, __Linux__ and __MacOS__ systems.
+Following a modularized approach the following submodules are defined in scope of this library, which are independent:
  
 #### Boxing ####
 
-This library provides boxing classes for primitive data types (e.g. string, int, long, float...) to add additional functionalities for each one of them.
- 
-#### File ####
-
-To handle file operations - or to receive information of a file - this library provides an own __File__ class implementation, which can also be passed to library implemented input or output stream classes.
-
-#### Base ####
-
-This is a collection of very basic functionalities like a base __Class__ which provides minimal reflection like class name. Also, you have the possibility with this collection to fetch this libraries version or even handle own versions for your project.
+This library module provides boxing classes for primitive data types (e.g. string, int, long, float...) to provide additional functionalities.
 
-#### Time ####
-
-A __Date__ class comes with this collection, which you can use to represent a date and doing operations on it. 
-
-#### Logic ####
+#### Core ####
 
-This collection of classes provides some nice functionalities to support your project with some nice logical features, like state machines and observer pattern supporting classes.
+The core module is a base module providing a base __Class__, exceptions, data types and interfaces. Usually the other submodules are dependent on this module. 
 
-#### Serialization ####
+#### Encoding ####
 
-Serialization is very important nowadays to persist data. This library offers a serializable interface, which can then be implemented in your project.  
-In addition to that there is already JSON serialization-based implementation for some public library classes.
+To encode a byte field (e.g. a binary file) for transfer the __Base64__ encoding / decoding functionality is being provided by this submodule as a first feature.
 
-#### JSON ####
+#### Event ####
 
-This library uses a transitive JSON dependency, which is in line with our license model. Many thanks to __Niels Lohmann__ for writing this nice little library.
+This submodule comes with an __Event__ class, as well as with handlers and managers to provide an intuitive event handling for your application.
 
-#### XML ####
+#### IO ####
 
-To handle XML files this library has an own XML parser implementation, which uses modern C++ features, such as shared pointers.
+To handle file operations - or to receive information of a file - this library submodule provides an own __File__ class implementation, which can also be passed to library implemented input or output stream classes.  
+Additionally __XML__ and __KV__ parsing functionalities are provided by this submodule.
 
-#### Logger ####
-
-For logging functionality you might need for your project there is a __Logger__ class coming with this library, which is also able to handle different log level.
-
-#### Event Handling ####
-
-With this first implemented milestone of event handling this library provides functionalities for creating and firing events.
-
-#### Exception ####
+#### Logic ####
 
-This library provides some basic exceptions which can be used in your project to create awareness of certain error behaviour.
+Functionalities provided by this submodule support your project with some nice logical features. The first one being provided by it is a state machine.
 
-#### KV ####
+#### Time ####
 
-A key value file offers the possibility to store simple information pairs in a file. This library provides parsing functionalities for __.kv__ files.
+A __Date__ class comes with this submodule, which you can use to represent a date and do operations on it. 
 
 ### Changelog ###
 
 #### Features ####
 
-- extended EventManager class by adding EventHandler availability check method
-- added exceptions for event management
-- extended Date class by introducing __+=__ and __-=__ operators
-- it's now possible to retrieve library version
-- added more operators to __LogLevel__ class
-- added factory interface
-- added "current working directory" detection implementation for __File__ class
+- "encoding" submodule has been added providing __Base64__ encoding and decoding functionality
 
 #### Improvements ####
 
-- increased test coverage by adding more unit tests
-- improved overall error handling by adding more error checks
-- reduced overall unnecessary complexity of public classes 
-- improved naming of certain classes
+- modularization has been improved by restructuring library files, which would result into having submodules - __there is no central header or binary file anymore__ - instead submodules can be linked independently now (e.g. using __ls_std_event.hpp__ and linking __libls_std_event.so__)
+- there is a CMake guard now to ensure that only one goal at the time is being build
+- the CMake option __LS_STD_BUILD_WITH_SUPPORTED_COMPILER__ has been added to detect compiler support
+- namespaces have been improved library wide and are more specific - __there is no ls\_std namespace anymore__ - instead you can choose submodule specific namespaces (e.g. _ls::std::boxing::_)
+- GoogleTest framework has been upgraded to 1.11.0
 
 #### Fixes ####
 
-- added missing header files to main header file
+- none
 
 ### Documentation ###
 
@@ -84,14 +61,14 @@ This software is licensed and uses MIT-license. You can find a __LICENSE.MIT__ f
 
 ### Building ###
 
-To build this library you'd need a recent version of __cmake__ and your OS specific compiler collection, like __gcc__, __MSVC__ or __AppleClang__ installed.  
+To build this library you'd need a recent version of __cmake__ and your OS specific compiler collection, like __gcc__ or __MinGW__ installed.  
 Inside project's root directory create the following folder:
 
 ```
 cmake_build_release
 ```
 
-Open your OS specific command line window and navigate to this new folder and run the following command to configure the project and generate a native build system:  
+Open your OS specific command line interface (CLI) and navigate to this new folder and run the following command to configure the project and generate a native build system:  
 
 ```
 cmake ../
@@ -103,21 +80,23 @@ Inside __cmake_build_release__ folder you will now find cmake generated files. T
 cmake --build . --config Release
 ```
 
-### Add Library To Your Project ###
+__Please note__: Currently only a small set of compilers is officially supported. If you'd like to compile with an unsupported compiler, you have to set __LS_STD_BUILD_WITH_SUPPORTED_COMPILER__ - option in _CMakeLists.txt_ file to __OFF__ - then reset and reload the cmake project.
+
+### Add Library To Your CMake Project ###
 
-If you would like to add this library to your cmake project - to the __CMakeLists.txt__ file - make sure that you add the libraries' include directory:
+If you would like to add this library to your CMake project (__CMakeLists.txt__ file), make sure that you would add the libraries' include directory:
 
 ```
 include_directories(${CMAKE_CURRENT_LIST_DIR}/path/to/this/library/include)
 ```
 
-Then link the library binary file inside your __CMakeLists.txt__ file:
+Then link the libraries' binary file inside your __CMakeLists.txt__ file:
 
 ```
-target_link_libraries(... "path/to/this/library/../libls_std_YYYY.MAJOR.MINOR.dll")
+target_link_libraries(... libls_std_core libls_std_boxing ...)
 ```
 
 ### Testing ###
 
 This project contains unit tests to provide test coverage.  
-To run those tests you have to build this project with option __LS_STD_BUILD_WITH_TESTS__ set to __ON__.
+To run those tests you have to build this project with option __LS_STD_BUILD_WITH_TESTS__ set to __ON__ - then reset and reload the CMake project.

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-21
  *
  * */
 
@@ -11,73 +11,80 @@
 #define LS_STD_BOOLEAN_HPP
 
 #include <memory>
-#include <ls_std/base/Class.hpp>
-#include "IBoxing.hpp"
+#include <sstream>
+#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_type::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-19
  *
  * */
 
@@ -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_type::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-19
  *
  * */
 
@@ -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_type::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-19
  *
  * */
 
@@ -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_type::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-19
  *
  * */
 
@@ -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_type::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-19
  *
  * */
 
 #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_type::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:         2021-09-24
+ * Changed:         2022-05-09
  *
  * */
 
@@ -12,11 +12,17 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
-  static std::string getVersion()
+  namespace std
   {
-    return "2021.2.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-19
+ *
+ * */
+
+#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_type::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-19
+ *
+ * */
+
+#ifndef LS_STD_I_BOXING_HPP
+#define LS_STD_I_BOXING_HPP
+
+#include <string>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      namespace interface_type
+      {
+        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/IEncoding.hpp

@@ -0,0 +1,35 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-01-03
+ * Changed:         2022-05-19
+ *
+ * */
+
+#ifndef LS_STD_I_ENCODING_HPP
+#define LS_STD_I_ENCODING_HPP
+
+#include <string>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace core
+    {
+      namespace interface_type
+      {
+        class IEncoding
+        {
+          public:
+
+            virtual ::std::string encode(const ::std::string &_sequence) = 0;
+            virtual ::std::string decode(const ::std::string &_sequence) = 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-19
+ *
+ * */
+
+#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_type
+      {
+        class IEventSubscriber
+        {
+          public:
+
+            IEventSubscriber() = default;
+            ~IEventSubscriber() = default;
+
+            virtual void subscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener) = 0;
+            virtual void unsubscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener) = 0;
+        };
+      }
+    }
+  }
+}
+
+#endif

include/ls_std/core/interface/IListener.hpp

@@ -0,0 +1,37 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-11-14
+ * Changed:         2022-05-19
+ *
+ * */
+
+#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_type
+      {
+        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-19
+ *
+ * */
+
+#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_type
+      {
+        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-19
+ *
+ * */
+
+#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_type
+      {
+        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-19
+ *
+ * */
+
+#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_type
+      {
+        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-19
+ *
+ * */
+
+#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_type
+      {
+        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/encoding/Base64.hpp

@@ -0,0 +1,55 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-01-03
+ * Changed:         2022-05-20
+ *
+ * */
+
+#ifndef LS_STD_BASE64_HPP
+#define LS_STD_BASE64_HPP
+
+#include <ls_std/core/interface/IEncoding.hpp>
+#include <bitset>
+#include <vector>
+#include <unordered_map>
+
+namespace ls
+{
+  namespace std
+  {
+    namespace encoding
+    {
+      class Base64 : public ls::std::core::interface_type::IEncoding
+      {
+        public:
+
+          Base64() = default;
+          ~Base64() = default;
+
+          // implementation
+
+          ::std::string encode(const ::std::string &_sequence) override;
+          ::std::string decode(const ::std::string &_sequence) override;
+
+        private:
+
+          static ::std::string _applyEndingRule(::std::string _encodedString, size_t _sequenceSize);
+          static ::std::string _decodeByteQuadruple(const ::std::string &_quadruple);
+          static ::std::string _encodeByteTriple(const ::std::string &_byteTriple);
+          static uint32_t _extractBitSequence(uint32_t _bitMask, uint32_t _bitStorage);
+          static uint32_t _generateBitMask(uint32_t _maskValue, uint8_t _shiftValue);
+          static ::std::unordered_map<char, uint8_t> _getDecodingMap();
+          static ::std::unordered_map<uint8_t, char> _getEncodingMap();
+          static ::std::string _getNextByteQuadruple(const ::std::string &_sequence, size_t _index);
+          static ::std::string _getNextByteTriple(const ::std::string &_sequence, size_t _index);
+          static void _mergeBitSequence(uint32_t &_bitStorage, const uint32_t &_bitMask);
+          static uint32_t _toDecodingBitStorage(const ::std::string &_quadruple);
+          static uint32_t _toEncodingBitStorage(const ::std::string &_triple);
+      };
+    }
+  }
+}
+
+#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-19
  *
  * */
 
 #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_type::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_type::IListener> &_listener) override;
+          void unsubscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener) override;
 
-      // additional functionality
+          // 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-19
+ *
+ * */
+
+#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_type::IListener> &_listener);
+          void clear();
+          ::std::list<::std::shared_ptr<ls::std::core::interface_type::IListener>> getListeners();
+          bool removeListener(const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener);
+          void tell(const ls::std::core::Class &_info);
+
+        private:
+
+          ::std::list<::std::shared_ptr<ls::std::core::interface_type::IListener>> listeners{};
+      };
+    }
+  }
+}
+
+#endif

include/ls_std/event/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-19
+ *
+ * */
+
+#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_type::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-19
  *
  * */
 
 #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_type::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-19
  *
  * */
 
 #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_type::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-19
  *
  * */
 
 #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_type::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-19
  *
  * */
 
 #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_type::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-19
  *
  * */
 
@@ -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_type::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-19
  *
  * */
 
 #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_type::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-19
  *
  * */
 
 #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_type::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_type::IWriter> writer{};
+
+          void _assignWriter(const ::std::shared_ptr<ls::std::core::interface_type::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-19
  *
  * */
 
 #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_type::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-19
+ *
+ * */
+
+#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_type::ISerializable
+      {
+        public:
+
+          explicit SerializableJsonState(const ::std::shared_ptr<ls::std::logic::State> &_value);
+          ~SerializableJsonState() override = default;
+
+          // implementation
+
+          ls::std::core::type::byte_field marshal() override;
+          void unmarshal(const ls::std::core::type::byte_field &_data) override;
+
+          // additional functionality
+
+          ::std::shared_ptr<ls::std::logic::State> getValue();
+          void setValue(const ::std::shared_ptr<ls::std::logic::State> &_value);
+
+        private:
+
+          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-19
+ *
+ * */
+
+#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_type::ISerializable
+      {
+        public:
+
+          explicit SerializableJsonStateConnection(const ::std::shared_ptr<ls::std::logic::StateConnection> &_value);
+          ~SerializableJsonStateConnection() override = default;
+
+          // implementation
+
+          ls::std::core::type::byte_field marshal() override;
+          void unmarshal(const ls::std::core::type::byte_field &_data) override;
+
+          // additional functionality
+
+          ::std::shared_ptr<ls::std::logic::StateConnection> getValue();
+          void setValue(const ::std::shared_ptr<ls::std::logic::StateConnection> &_value);
+
+        private:
+
+          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-19
+ *
+ * */
+
+#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_type::ISerializable
+      {
+        public:
+
+          explicit SerializableJsonStateMachine(const ::std::shared_ptr<ls::std::logic::StateMachine> &_value);
+          ~SerializableJsonStateMachine() override = default;
+
+          // implementation
+
+          ls::std::core::type::byte_field marshal() override;
+          void unmarshal(const ls::std::core::type::byte_field &_data) override;
+
+          // additional functionality
+
+          ::std::shared_ptr<ls::std::logic::StateMachine> getValue();
+          void setValue(const ::std::shared_ptr<ls::std::logic::StateMachine> &_value);
+
+        private:
+
+          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,46 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-05-13
+ * Changed:         2022-05-17
+ *
+ * */
+
+#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/IEncoding.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_encoding.hpp

@@ -0,0 +1,15 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-05-17
+ * Changed:         2022-05-17
+ *
+ * */
+
+#ifndef LS_STD_LS_STD_ENCODING_HPP
+#define LS_STD_LS_STD_ENCODING_HPP
+
+#include <ls_std/encoding/Base64.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