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

CMakeLists.txt

@@ -11,7 +11,7 @@
 ##########################################################
 
 cmake_minimum_required(VERSION 3.17)
-project(ls_std VERSION 2022.1.0)
+project(ls_std VERSION 2022.2.0)
 
 set(MODULE_NAME_BOXING ls_std_boxing)
 set(MODULE_NAME_CORE ls_std_core)
@@ -67,7 +67,7 @@ endif ()
 ##########################################################
 
 message("${PROJECT_NAME}: Setting compiler flags...")
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
@@ -80,7 +80,9 @@ if(${LS_STD_BUILD_WITH_SUPPORTED_COMPILER})
 
     # define supported compilers
 
-    if (${CMAKE_CXX_COMPILER_ID} STREQUAL MSVC OR ${CMAKE_CXX_COMPILER_ID} STREQUAL GNU)
+    if (${CMAKE_CXX_COMPILER_ID} STREQUAL MSVC OR
+            ${CMAKE_CXX_COMPILER_ID} STREQUAL GNU OR
+            ${CMAKE_CXX_COMPILER_ID} STREQUAL Clang)
         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!")
@@ -89,7 +91,7 @@ if(${LS_STD_BUILD_WITH_SUPPORTED_COMPILER})
 
     # 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})
+    if (${CMAKE_CXX_COMPILER_ID} STREQUAL MSVC AND ${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 ()
@@ -97,7 +99,7 @@ endif()
 
 # define which goals can run tests
 
-if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_SHARED} OR ${LS_STD_BUILD_MODULE})
+if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_MODULE})
     message("${PROJECT_NAME}: [Error] building \"${GOAL}\" with tests is not supported... terminated!")
     return()
 endif ()
@@ -436,6 +438,13 @@ if (${LS_STD_BUILD_MODULE})
     set_target_properties("${MODULE_NAME_ENCODING}" PROPERTIES DEBUG_POSTFIX "_d")
 endif ()
 
+# CLI base64
+
+add_executable(cli_base64
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/encoding/cli/cli_base64_main.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/encoding/Base64.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/core/Version.cpp)
+
 ##########################################################
 # Build Library (event)
 ##########################################################
@@ -527,16 +536,16 @@ endif ()
 ####################################################################################################################
 ####################################################################################################################
 ####################################################################################################################
-# Test Suite: Static Linking
+# Test Suite: Linking
 ####################################################################################################################
 ####################################################################################################################
 ####################################################################################################################
 
 ##########################################################
-# Static Linking (boxing)
+# Linking (boxing)
 ##########################################################
 
-if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+if (${LS_STD_BUILD_WITH_TESTS})
     message("${MODULE_NAME_BOXING}: Linking libraries for test application...")
     target_link_libraries(${MODULE_NAME_BOXING}_test
             gtest
@@ -547,10 +556,10 @@ if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
 endif ()
 
 ##########################################################
-# Static Linking (core)
+# Linking (core)
 ##########################################################
 
-if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+if (${LS_STD_BUILD_WITH_TESTS})
     message("${MODULE_NAME_CORE}: Linking libraries for test application...")
     target_link_libraries(${MODULE_NAME_CORE}_test
             gtest
@@ -560,10 +569,10 @@ if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
 endif ()
 
 ##########################################################
-# Static Linking (encoding)
+# Linking (encoding)
 ##########################################################
 
-if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+if (${LS_STD_BUILD_WITH_TESTS})
     message("${MODULE_NAME_ENCODING}: Linking libraries for test application...")
     target_link_libraries(${MODULE_NAME_ENCODING}_test
             gtest
@@ -574,10 +583,10 @@ if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
 endif ()
 
 ##########################################################
-# Static Linking (event)
+# Linking (event)
 ##########################################################
 
-if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+if (${LS_STD_BUILD_WITH_TESTS})
     message("${MODULE_NAME_EVENT}: Linking libraries for test application...")
     target_link_libraries(${MODULE_NAME_EVENT}_test
             gtest
@@ -588,10 +597,10 @@ if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
 endif ()
 
 ##########################################################
-# Static Linking (io)
+# Linking (io)
 ##########################################################
 
-if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+if (${LS_STD_BUILD_WITH_TESTS})
     message("${MODULE_NAME_IO}: Linking libraries for test application...")
     target_link_libraries(${MODULE_NAME_IO}_test
             gtest
@@ -602,10 +611,10 @@ if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
 endif ()
 
 ##########################################################
-# Static Linking (logic)
+# Linking (logic)
 ##########################################################
 
-if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+if (${LS_STD_BUILD_WITH_TESTS})
     message("${MODULE_NAME_LOGIC}: Linking libraries for test application...")
     target_link_libraries(${MODULE_NAME_LOGIC}_test
             gtest
@@ -616,10 +625,10 @@ if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
 endif ()
 
 ##########################################################
-# Static Linking (time)
+# Linking (time)
 ##########################################################
 
-if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+if (${LS_STD_BUILD_WITH_TESTS})
     message("${MODULE_NAME_TIME}: Linking libraries for test application...")
     target_link_libraries(${MODULE_NAME_TIME}_test
             gtest
@@ -630,10 +639,10 @@ if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
 endif ()
 
 ##########################################################
-# Static Linking (all)
+# Linking (all)
 ##########################################################
 
-if (${LS_STD_BUILD_WITH_TESTS} AND ${LS_STD_BUILD_STATIC})
+if (${LS_STD_BUILD_WITH_TESTS})
     message("${PROJECT_NAME}: Linking libraries for test application...")
     target_link_libraries(${PROJECT_NAME}_test
             gtest

README.md

@@ -1,4 +1,4 @@
-# Lynar Studios - Standard Library 2022.1.0 #
+# Lynar Studios - Standard Library 2022.2.0 #
 
 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.
@@ -25,7 +25,7 @@ This submodule comes with an __Event__ class, as well as with handlers and manag
 To handle file operations - or to receive information of a file - this library submodule provides an own __File__ class implementation, which can also be passed to library implemented input or output stream classes.  
 Additionally __XML__ and __KV__ parsing functionalities are provided by this submodule.
 
-#### Logic ####
+#### Logic (Deprecated) ####
 
 Functionalities provided by this submodule support your project with some nice logical features. The first one being provided by it is a state machine.
 
@@ -33,32 +33,36 @@ Functionalities provided by this submodule support your project with some nice l
 
 A __Date__ class comes with this submodule, which you can use to represent a date and do operations on it. 
 
+---
 ### Changelog ###
 
 #### Features ####
 
-- "encoding" submodule has been added providing __Base64__ encoding and decoding functionality
+- this library is now being compiled with C++ 17 standard
+- this library can now build shared libraries by using MSVC
+- Clang support has been added to this library
+- added Base64 CLI Tool, which enables a user to use Base64 encoding and decoding functionalities via CLI
 
 #### Improvements ####
 
-- 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
+- JSON type alias has been added to avoid direct nlohmann library usage
+- logic module is now officially deprecated
 
 #### Fixes ####
 
 - none
 
+---
 ### Documentation ###
 
 You can find a detailed documentation on Lynar Studios Website: lynarstudios.com
 
+---
 ### License ###
 
 This software is licensed and uses MIT-license. You can find a __LICENSE.MIT__ file inside the project's root directory.
 
+---
 ### Building ###
 
 To build this library you'd need a recent version of __cmake__ and your OS specific compiler collection, like __gcc__ or __MinGW__ installed.  
@@ -80,8 +84,18 @@ Inside __cmake_build_release__ folder you will now find cmake generated files. T
 cmake --build . --config Release
 ```
 
-__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.
+__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.  
 
+Find below a table of compiler/OS combinations which have been tested during library version development:
+
+| Supported Compiler | OS              | Compiler Version        |
+|--------------------|-----------------|-------------------------|
+| GCC                | Linux Mint 20.3 | 12.1.0                  |
+| Clang              | Linux Mint 20.3 | 12.0.0-3ubuntu1~20.04.5 |
+| MinGW-w64 / GCC    | Windows 10      | 11.2.0                  |
+| MSVC               | Windows 10      | 19.32.31332.0           |
+
+---
 ### Add Library To Your CMake Project ###
 
 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:
@@ -96,6 +110,7 @@ Then link the libraries' binary file inside your __CMakeLists.txt__ file:
 target_link_libraries(... libls_std_core libls_std_boxing ...)
 ```
 
+---
 ### Testing ###
 
 This project contains unit tests to provide test coverage.  

doc/check_list.txt

@@ -0,0 +1,10 @@
+New Version (after merge back to development branch)
+
+- README.md file:
+    - increase version in headline
+    - empty changelog
+- CMakeLists.txt:
+    - increase version
+- LibraryVersion:
+    - increase version in method
+    - adjust test

include/ls_std/boxing/Boolean.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2022-05-21
+ * Changed:         2022-07-03
  *
  * */
 
@@ -14,77 +14,72 @@
 #include <sstream>
 #include <ls_std/core/Class.hpp>
 #include <ls_std/core/interface/IBoxing.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::boxing
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL Boolean : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
   {
-    namespace boxing
-    {
-      class Boolean : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
-      {
-        public:
+    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::boxing::Boolean &operator=(int _value);
-          ls::std::boxing::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::boxing::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::boxing::Boolean &_boolean)
-          {
-            return !_boolean.value;
-          }
+      friend bool operator!(const ls::std::boxing::Boolean &_boolean)
+      {
+        return !_boolean.value;
+      }
 
-          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
+      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::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);
+      [[nodiscard]] 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;
-      };
-    }
-  }
+      [[nodiscard]] ::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:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -13,92 +13,87 @@
 #include <memory>
 #include <ls_std/core/Class.hpp>
 #include <ls_std/core/interface/IBoxing.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::boxing
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL Double : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
   {
-    namespace boxing
-    {
-      class Double : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
-      {
-        public:
+    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::boxing::Double &operator=(double _value);
+      ls::std::boxing::Double &operator=(double _value);
 
-          // arithmetic operators
+      // arithmetic operators
 
-          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;
+      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::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);
+      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::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;
+      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:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -13,92 +13,87 @@
 #include <memory>
 #include <ls_std/core/Class.hpp>
 #include <ls_std/core/interface/IBoxing.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::boxing
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL Float : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
   {
-    namespace boxing
-    {
-      class Float : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
-      {
-        public:
+    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::boxing::Float &operator=(float _value);
+      ls::std::boxing::Float &operator=(float _value);
 
-          // arithmetic operators
+      // arithmetic operators
 
-          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;
+      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::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);
+      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::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;
+      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/Integer.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -13,103 +13,98 @@
 #include <memory>
 #include <ls_std/core/Class.hpp>
 #include <ls_std/core/interface/IBoxing.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::boxing
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL Integer : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
   {
-    namespace boxing
-    {
-      class Integer : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
+    public:
+
+      explicit Integer(int _value);
+      Integer();
+      ~Integer() override = default;
+
+      // conversion operator
+
+      operator int() const;
+
+      // assignment operators
+
+      ls::std::boxing::Integer &operator=(int _value);
+
+      // arithmetic operators
+
+      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;
+
+      // compound operators
+
+      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)
       {
-        public:
+        return !_integer.value;
+      }
 
-          explicit Integer(int _value);
-          Integer();
-          ~Integer() override = default;
+      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;
 
-          // conversion operator
+      // increment / decrement operator
 
-          operator int() const;
+      void operator++();
+      void operator--();
 
-          // assignment operators
+      // implementation
 
-          ls::std::boxing::Integer &operator=(int _value);
+      void parse(::std::string _parseText) override;
+      ::std::string toString() override;
 
-          // arithmetic operators
+      // additional functionality
 
-          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;
+      [[nodiscard]] int getValue() const;
 
-          // compound operators
+    private:
 
-          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{};
-      };
-    }
-  }
+      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:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -14,103 +14,98 @@
 #include <ls_std/core/Class.hpp>
 #include <ls_std/core/interface/IBoxing.hpp>
 #include <ls_std/core/types/Types.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::boxing
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL Long : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
   {
-    namespace boxing
-    {
-      class Long : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
+    public:
+
+      explicit Long(ls::std::core::type::long_type _value);
+      Long();
+      ~Long() override = default;
+
+      // conversion operator
+
+      operator ls::std::core::type::long_type() const;
+
+      // assignment operators
+
+      ls::std::boxing::Long &operator=(ls::std::core::type::long_type _value);
+
+      // arithmetic operators
+
+      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;
+
+      // compound operators
+
+      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)
       {
-        public:
+        return !_long.value;
+      }
 
-          explicit Long(ls::std::core::type::long_type _value);
-          Long();
-          ~Long() override = default;
+      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;
 
-          // conversion operator
+      // increment / decrement operator
 
-          operator ls::std::core::type::long_type() const;
+      void operator++();
+      void operator--();
 
-          // assignment operators
+      // implementation
 
-          ls::std::boxing::Long &operator=(ls::std::core::type::long_type _value);
+      void parse(::std::string _parseText) override;
+      ::std::string toString() override;
 
-          // arithmetic operators
+      // additional functionality
 
-          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;
+      [[nodiscard]] ls::std::core::type::long_type getValue() const;
 
-          // compound operators
+    private:
 
-          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{};
-      };
-    }
-  }
+      ls::std::core::type::long_type value{};
+  };
 }
 
 #endif

include/ls_std/boxing/String.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -16,79 +16,74 @@
 #include <string>
 #include <memory>
 #include <vector>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::boxing
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL String : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
   {
-    namespace boxing
-    {
-      class String : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
-      {
-        public:
+    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::boxing::String &operator=(::std::string _value);
+      ls::std::boxing::String &operator=(::std::string _value);
 
-          // arithmetic operators
+      // arithmetic operators
 
-          ::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);
+      ::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::boxing::String &operator+=(ls::std::boxing::String _string);
-          ls::std::boxing::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::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);
+      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::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();
+      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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2022-05-09
+ * Changed:         2022-07-03
  *
  * */
 
@@ -11,30 +11,25 @@
 #define LS_STD_CLASS_HPP
 
 #include <string>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::core
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL Class
   {
-    namespace core
-    {
-      class Class
-      {
-        public:
+    public:
 
-          explicit Class(const ::std::string &_name);
-          virtual ~Class() = default;
+      explicit Class(const ::std::string &_name);
+      virtual ~Class() = default;
 
-          ::std::string getClassName();
+      ::std::string getClassName();
 
-        private:
+    private:
 
-          ::std::string name{};
+      ::std::string name{};
 
-          void _assignClassName(const ::std::string &_name);
-      };
-    }
-  }
+      void _assignClassName(const ::std::string &_name);
+  };
 }
 
 #endif

include/ls_std/core/LibraryVersion.hpp

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

include/ls_std/core/Version.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -13,45 +13,40 @@
 #include "Class.hpp"
 #include <ls_std/core/interface/ISerializable.hpp>
 #include <ls_std/core/types/Types.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::core
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL Version : public ls::std::core::interface_type::ISerializable
   {
-    namespace core
-    {
-      class Version : public ls::std::core::interface_type::ISerializable
-      {
-        public:
+    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;
+      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
+      // implementation
 
-          ls::std::core::type::byte_field marshal() override;
-          void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      ls::std::core::type::byte_field marshal() override;
+      void unmarshal(const ls::std::core::type::byte_field &_data) override;
 
-          // other functionality
+      // 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);
+      [[nodiscard]] ls::std::core::type::version_type getMajorVersion() const;
+      [[nodiscard]] ls::std::core::type::version_type getMinorVersion() const;
+      [[nodiscard]] 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:
+    private:
 
-          ls::std::core::type::version_type majorVersion{};
-          ls::std::core::type::version_type minorVersion{};
-          ls::std::core::type::version_type patchVersion{};
+      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);
-      };
-    }
-  }
+      static bool _isValid(const ::std::string &_versionString);
+  };
 }
 
 #endif

include/ls_std/core/exception/EventNotHandledException.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-27
- * Changed:         2022-05-09
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,25 +12,19 @@
 
 #include <exception>
 
-namespace ls
+namespace ls::std::core
 {
-  namespace std
+  class EventNotHandledException : public ::std::exception
   {
-    namespace core
-    {
-      class EventNotHandledException : public ::std::exception
-      {
-        public:
+    public:
 
-          EventNotHandledException() = default;
+      EventNotHandledException() = default;
 
-          const char *what() const noexcept override
-          {
-            return "EventNotHandledException thrown - event was not handled - nothing happened!";
-          };
+      [[nodiscard]] const char *what() const noexcept override
+      {
+        return "EventNotHandledException thrown - event was not handled - nothing happened!";
       };
-    }
-  }
+  };
 }
 
 #endif

include/ls_std/core/exception/EventNotSubscribedException.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-27
- * Changed:         2022-05-09
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,25 +12,19 @@
 
 #include <exception>
 
-namespace ls
+namespace ls::std::core
 {
-  namespace std
+  class EventNotSubscribedException : public ::std::exception
   {
-    namespace core
-    {
-      class EventNotSubscribedException : public ::std::exception
-      {
-        public:
+    public:
 
-          EventNotSubscribedException() = default;
+      EventNotSubscribedException() = default;
 
-          const char *what() const noexcept override
-          {
-            return "EventNotSubscribedException thrown - event was not subscribed!";
-          };
+      [[nodiscard]] const char *what() const noexcept override
+      {
+        return "EventNotSubscribedException thrown - event was not subscribed!";
       };
-    }
-  }
+  };
 }
 
 #endif

include/ls_std/core/exception/FileNotFoundException.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-16
+ * Changed:         2022-07-02
  *
  * */
 
@@ -15,25 +15,19 @@
 #include <cstring>
 
 //TODO: pass parameters, use class, show class name
-namespace ls
+namespace ls::std::core
 {
-  namespace std
+  class FileNotFoundException : public ::std::exception
   {
-    namespace core
-    {
-      class FileNotFoundException : public ::std::exception
-      {
-        public:
+    public:
 
-          FileNotFoundException() = default;
+      FileNotFoundException() = default;
 
-          const char *what() const noexcept override
-          {
-            return "FileNotFoundException thrown - file not found!";
-          };
+      [[nodiscard]] const char *what() const noexcept override
+      {
+        return "FileNotFoundException thrown - file not found!";
       };
-    }
-  }
+  };
 }
 
 #endif

include/ls_std/core/exception/FileOperationException.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2022-05-09
+ * Changed:         2022-07-02
  *
  * */
 
@@ -13,25 +13,19 @@
 #include <exception>
 #include <string>
 
-namespace ls
+namespace ls::std::core
 {
-  namespace std
+  class FileOperationException : public ::std::exception
   {
-    namespace core
-    {
-      class FileOperationException : public ::std::exception
-      {
-        public:
+    public:
 
-          explicit FileOperationException() = default;
+      explicit FileOperationException() = default;
 
-          const char *what() const noexcept override
-          {
-            return "FileOperationException thrown - file operation failed!";
-          }
-      };
-    }
-  }
+      [[nodiscard]] const char *what() const noexcept override
+      {
+        return "FileOperationException thrown - file operation failed!";
+      }
+  };
 }
 
 #endif

include/ls_std/core/exception/IllegalArgumentException.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2022-05-09
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,25 +12,19 @@
 
 #include <exception>
 
-namespace ls
+namespace ls::std::core
 {
-  namespace std
+  class IllegalArgumentException : public ::std::exception
   {
-    namespace core
-    {
-      class IllegalArgumentException : public ::std::exception
-      {
-        public:
+    public:
 
-          IllegalArgumentException() = default;
+      IllegalArgumentException() = default;
 
-          const char *what() const noexcept override
-          {
-            return "IllegalArgumentException thrown - passed argument is not valid!";
-          }
-      };
-    }
-  }
+      [[nodiscard]] const char *what() const noexcept override
+      {
+        return "IllegalArgumentException thrown - passed argument is not valid!";
+      }
+  };
 }
 
 #endif

include/ls_std/core/exception/IllegalArithmeticOperationException.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2022-05-09
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,25 +12,19 @@
 
 #include <exception>
 
-namespace ls
+namespace ls::std::core
 {
-  namespace std
+  class IllegalArithmeticOperationException : public ::std::exception
   {
-    namespace core
-    {
-      class IllegalArithmeticOperationException : public ::std::exception
-      {
-        public:
+    public:
 
-          IllegalArithmeticOperationException() = default;
+      IllegalArithmeticOperationException() = default;
 
-          const char *what() const noexcept override
-          {
-            return "IllegalArithmeticOperationException thrown - arithmetic operation is not allowed!";
-          }
-      };
-    }
-  }
+      [[nodiscard]] const char *what() const noexcept override
+      {
+        return "IllegalArithmeticOperationException thrown - arithmetic operation is not allowed!";
+      }
+  };
 }
 
 #endif

include/ls_std/core/exception/IncompleteJsonException.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-30
- * Changed:         2022-05-09
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,25 +12,19 @@
 
 #include <exception>
 
-namespace ls
+namespace ls::std::core
 {
-  namespace std
+  class IncompleteJsonException : public ::std::exception
   {
-    namespace core
-    {
-      class IncompleteJsonException : public ::std::exception
-      {
-        public:
+    public:
 
-          explicit IncompleteJsonException() = default;
+      explicit IncompleteJsonException() = default;
 
-          const char *what() const noexcept override
-          {
-            return "IncompleteJsonException thrown - this JSON string is incomplete.";
-          }
-      };
-    }
-  }
+      [[nodiscard]] const char *what() const noexcept override
+      {
+        return "IncompleteJsonException thrown - this JSON string is incomplete.";
+      }
+  };
 }
 
 #endif

include/ls_std/core/exception/NullPointerException.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-06
- * Changed:         2022-05-09
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,25 +12,19 @@
 
 #include <exception>
 
-namespace ls
+namespace ls::std::core
 {
-  namespace std
+  class NullPointerException : public ::std::exception
   {
-    namespace core
-    {
-      class NullPointerException : public ::std::exception
-      {
-        public:
+    public:
 
-          explicit NullPointerException() = default;
+      explicit NullPointerException() = default;
 
-          const char *what() const noexcept override
-          {
-            return "NullPointerException thrown - reference is null!";
-          }
-      };
-    }
-  }
+      [[nodiscard]] const char *what() const noexcept override
+      {
+        return "NullPointerException thrown - reference is null!";
+      }
+  };
 }
 
 #endif

include/ls_std/core/interface/IBoxing.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2022-05-19
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,27 +12,18 @@
 
 #include <string>
 
-namespace ls
+namespace ls::std::core::interface_type
 {
-  namespace std
+  class IBoxing
   {
-    namespace core
-    {
-      namespace interface_type
-      {
-        class IBoxing
-        {
-          public:
+    public:
 
-            IBoxing() = default;
-            ~IBoxing() = default;
+      IBoxing() = default;
+      ~IBoxing() = default;
 
-            virtual void parse(::std::string _parseText) = 0;
-            virtual ::std::string toString() = 0;
-        };
-      }
-    }
-  }
+      virtual void parse(::std::string _parseText) = 0;
+      virtual ::std::string toString() = 0;
+  };
 }
 
 #endif

include/ls_std/core/interface/IEncoding.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-01-03
- * Changed:         2022-05-19
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,24 +12,15 @@
 
 #include <string>
 
-namespace ls
+namespace ls::std::core::interface_type
 {
-  namespace std
+  class IEncoding
   {
-    namespace core
-    {
-      namespace interface_type
-      {
-        class IEncoding
-        {
-          public:
+    public:
 
-            virtual ::std::string encode(const ::std::string &_sequence) = 0;
-            virtual ::std::string decode(const ::std::string &_sequence) = 0;
-        };
-      }
-    }
-  }
+      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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-19
+ * Changed:         2022-07-02
  *
  * */
 
@@ -14,27 +14,18 @@
 #include <memory>
 #include "IListener.hpp"
 
-namespace ls
+namespace ls::std::core::interface_type
 {
-  namespace std
+  class IEventSubscriber
   {
-    namespace core
-    {
-      namespace interface_type
-      {
-        class IEventSubscriber
-        {
-          public:
+    public:
 
-            IEventSubscriber() = default;
-            ~IEventSubscriber() = default;
+      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;
-        };
-      }
-    }
-  }
+      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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2022-05-19
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,26 +12,17 @@
 
 #include <ls_std/core/Class.hpp>
 
-namespace ls
+namespace ls::std::core::interface_type
 {
-  namespace std
+  class IListener
   {
-    namespace core
-    {
-      namespace interface_type
-      {
-        class IListener
-        {
-          public:
+    public:
 
-            IListener() = default;
-            ~IListener() = default;
+      IListener() = default;
+      ~IListener() = default;
 
-            virtual void listen(const ls::std::core::Class &_info) = 0;
-        };
-      }
-    }
-  }
+      virtual void listen(const ls::std::core::Class &_info) = 0;
+  };
 }
 
 #endif

include/ls_std/core/interface/IReader.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-19
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,26 +12,17 @@
 
 #include <ls_std/core/types/Types.hpp>
 
-namespace ls
+namespace ls::std::core::interface_type
 {
-  namespace std
+  class IReader
   {
-    namespace core
-    {
-      namespace interface_type
-      {
-        class IReader
-        {
-          public:
+    public:
 
-            IReader() = default;
-            ~IReader() = default;
+      IReader() = default;
+      ~IReader() = default;
 
-            virtual ls::std::core::type::byte_field read() = 0;
-        };
-      }
-    }
-  }
+      virtual ls::std::core::type::byte_field read() = 0;
+  };
 }
 
 #endif

include/ls_std/core/interface/ISerializable.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-21
- * Changed:         2022-05-19
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,27 +12,18 @@
 
 #include <ls_std/core/types/Types.hpp>
 
-namespace ls
+namespace ls::std::core::interface_type
 {
-  namespace std
+  class ISerializable
   {
-    namespace core
-    {
-      namespace interface_type
-      {
-        class ISerializable
-        {
-          public:
+    public:
 
-            ISerializable() = default;
-            ~ISerializable() = default;
+      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;
-        };
-      }
-    }
-  }
+      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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2022-05-19
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,27 +12,18 @@
 
 #include <ls_std/core/types/Types.hpp>
 
-namespace ls
+namespace ls::std::core::interface_type
 {
-  namespace std
+  class IStorable
   {
-    namespace core
-    {
-      namespace interface_type
-      {
-        class IStorable
-        {
-          public:
+    public:
 
-            IStorable() = default;
-            ~IStorable() = default;
+      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;
-        };
-      }
-    }
-  }
+      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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-19
+ * Changed:         2022-07-02
  *
  * */
 
@@ -13,26 +13,17 @@
 #include <vector>
 #include <ls_std/core/types/Types.hpp>
 
-namespace ls
+namespace ls::std::core::interface_type
 {
-  namespace std
+  class IWriter
   {
-    namespace core
-    {
-      namespace interface_type
-      {
-        class IWriter
-        {
-          public:
+    public:
 
-            IWriter() = default;
-            ~IWriter() = default;
+      IWriter() = default;
+      ~IWriter() = default;
 
-            virtual bool write(const ls::std::core::type::byte_field &_data) = 0;
-        };
-      }
-    }
-  }
+      virtual bool write(const ls::std::core::type::byte_field &_data) = 0;
+  };
 }
 
 #endif

include/ls_std/core/types/EventTypes.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-12
+ * Changed:         2022-07-02
  *
  * */
 
@@ -14,22 +14,13 @@
 #include <vector>
 #include <map>
 
-namespace ls
+namespace ls::std::core::type
 {
-  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>;
-      }
-    }
-  }
+  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/core/types/KvTypes.hpp

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

include/ls_std/core/types/StateMachineTypes.hpp

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

include/ls_std/core/types/Types.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2022-05-12
+ * Changed:         2022-07-14
  *
  * */
 
@@ -11,22 +11,15 @@
 #define LS_STD_TYPES_HPP
 
 #include <string>
+#include <ls_std/lib/nlohmann_json/include/nlohmann/json.hpp>
 
-namespace ls
+namespace ls::std::core::type
 {
-  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;
-      }
-    }
-  }
+  using byte = char;
+  using byte_field = ::std::string;
+  using long_type = long long int;
+  using version_type = uint16_t;
+  using json = nlohmann::json;
 }
 
 #endif

include/ls_std/core/utils/RegexUtils.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-18
- * Changed:         2022-05-09
+ * Changed:         2022-07-02
  *
  * */
 
@@ -13,27 +13,21 @@
 #include <string>
 #include <regex>
 
-namespace ls
+namespace ls::std::core
 {
-  namespace std
+  class RegexUtils
   {
-    namespace core
-    {
-      class RegexUtils
-      {
-        public:
+    public:
 
-          RegexUtils() = default;
-          ~RegexUtils() = default;
+      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)");
-          }
-      };
-    }
-  }
+      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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-09
+ * Changed:         2022-07-02
  *
  * */
 
@@ -13,50 +13,44 @@
 #include <algorithm>
 #include <list>
 
-namespace ls
+namespace ls::std::core
 {
-  namespace std
+  class STLUtils
   {
-    namespace core
-    {
-      class STLUtils
-      {
-        public:
+    public:
 
-          STLUtils() = default;
-          ~STLUtils() = default;
+      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 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{};
+      template<class dataType>
+      static dataType getListElementAt(const ::std::list<dataType> &_list, size_t _index)
+      {
+        dataType value{};
+        size_t counter{};
 
-            if (_index < _list.size())
+        if (_index < _list.size())
+        {
+          for (const auto &_value: _list)
+          {
+            if (counter == _index)
             {
-              for (const auto &_value: _list)
-              {
-                if (counter == _index)
-                {
-                  value = _value;
-                  break;
-                }
-
-                counter++;
-              }
+              value = _value;
+              break;
             }
 
-            return value;
+            counter++;
           }
-      };
-    }
-  }
+        }
+
+        return value;
+      }
+  };
 }
 
 #endif

include/ls_std/core/utils/WindowsUtils.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-06
- * Changed:         2022-05-12
+ * Changed:         2022-07-02
  *
  * */
 
@@ -14,29 +14,23 @@
 #include <string>
 #include <windows.h>
 
-namespace ls
+namespace ls::std::core
 {
-  namespace std
+  class WindowsUtils
   {
-    namespace core
-    {
-      class WindowsUtils
-      {
-        public:
+    public:
 
-          WindowsUtils() = default;
-          ~WindowsUtils() = default;
+      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);
+      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};
-          }
-      };
-    }
-  }
+        return ::std::string{messageBuffer};
+      }
+  };
 }
 
 #endif

include/ls_std/encoding/Base64.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-01-03
- * Changed:         2022-05-20
+ * Changed:         2022-07-03
  *
  * */
 
@@ -14,42 +14,37 @@
 #include <bitset>
 #include <vector>
 #include <unordered_map>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::encoding
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL Base64 : public ls::std::core::interface_type::IEncoding
   {
-    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);
-      };
-    }
-  }
+    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,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-12
+ * Changed:         2022-07-03
  *
  * */
 
@@ -14,39 +14,34 @@
 #include <ls_std/core/interface/ISerializable.hpp>
 #include <memory>
 #include <ls_std/core/types/EventTypes.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::event
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL Event : public ls::std::core::Class
   {
-    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);
-      };
-    }
-  }
+    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,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-12
+ * Changed:         2022-07-03
  *
  * */
 
@@ -14,32 +14,27 @@
 #include <list>
 #include <memory>
 #include <ls_std/core/interface/IListener.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 #include "Event.hpp"
 #include "Narrator.hpp"
 
-namespace ls
+namespace ls::std::event
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL EventHandler : public ls::std::event::Narrator
   {
-    namespace event
-    {
-      class EventHandler : public ls::std::event::Narrator
-      {
-        public:
+    public:
 
-          explicit EventHandler(const ls::std::core::type::event_id &_id);
-          ~EventHandler() override = default;
+      explicit EventHandler(const ls::std::core::type::event_id &_id);
+      ~EventHandler() override = default;
 
-          ls::std::core::type::event_id getId();
+      ls::std::core::type::event_id getId();
 
-        private:
+    private:
 
-          ls::std::core::type::event_id id{};
+      ls::std::core::type::event_id id{};
 
-          void _assignId(const ls::std::core::type::event_id &_id);
-      };
-    }
-  }
+      void _assignId(const ls::std::core::type::event_id &_id);
+  };
 }
 
 #endif

include/ls_std/event/EventManager.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -16,41 +16,36 @@
 #include <memory>
 #include "EventHandler.hpp"
 #include <ls_std/core/interface/IEventSubscriber.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::event
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL EventManager : public ls::std::core::Class, public ls::std::core::interface_type::IEventSubscriber
   {
-    namespace event
-    {
-      class EventManager : public ls::std::core::Class, public ls::std::core::interface_type::IEventSubscriber
-      {
-        public:
+    public:
 
-          explicit EventManager();
-          ~EventManager() override = default;
+      explicit EventManager();
+      ~EventManager() override = default;
 
-          // implementation
+      // implementation
 
-          void subscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener) override;
-          void unsubscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener) override;
+      void subscribe(const ls::std::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::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);
+      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::core::type::event_id, ::std::shared_ptr<ls::std::event::EventHandler>> eventHandlers{};
+      ::std::map<ls::std::core::type::event_id, ::std::shared_ptr<ls::std::event::EventHandler>> eventHandlers{};
 
-          bool _hasEventHandler(const ls::std::core::type::event_id &_id);
-          bool _removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler);
-      };
-    }
-  }
+      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/Narrator.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -12,34 +12,29 @@
 
 #include <ls_std/core/Class.hpp>
 #include <ls_std/core/interface/IListener.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 #include <list>
 #include <memory>
 
-namespace ls
+namespace ls::std::event
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL Narrator : public ls::std::core::Class
   {
-    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{};
-      };
-    }
-  }
+    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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-07
- * Changed:         2022-05-19
+ * Changed:         2022-07-14
  *
  * */
 
@@ -14,43 +14,38 @@
 #include <ls_std/core/Class.hpp>
 #include <ls_std/event/Event.hpp>
 #include <memory>
-#include <ls_std/lib/nlohmann_json/include/nlohmann/json.hpp>
+#include <ls_std/core/types/Types.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::event
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL SerializableJsonEvent : public ls::std::core::Class, public ls::std::core::interface_type::ISerializable
   {
-    namespace event
-    {
-      class SerializableJsonEvent : public ls::std::core::Class, public ls::std::core::interface_type::ISerializable
-      {
-        public:
+    public:
 
-          explicit SerializableJsonEvent(const ::std::shared_ptr<ls::std::event::Event> &_value);
-          ~SerializableJsonEvent() override = default;
+      explicit SerializableJsonEvent(const ::std::shared_ptr<ls::std::event::Event> &_value);
+      ~SerializableJsonEvent() override = default;
 
-          // implementation
+      // implementation
 
-          ls::std::core::type::byte_field marshal() override;
-          void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      ls::std::core::type::byte_field marshal() override;
+      void unmarshal(const ls::std::core::type::byte_field &_data) override;
 
-          // additional functionality
+      // additional functionality
 
-          ::std::shared_ptr<ls::std::event::Event> getValue();
-          void setValue(const ::std::shared_ptr<ls::std::event::Event> &_value);
+      ::std::shared_ptr<ls::std::event::Event> getValue();
+      void setValue(const ::std::shared_ptr<ls::std::event::Event> &_value);
 
-        private:
+    private:
 
-          nlohmann::json jsonObject{};
-          ::std::shared_ptr<ls::std::event::Event> value{};
+      ls::std::core::type::json jsonObject{};
+      ::std::shared_ptr<ls::std::event::Event> value{};
 
-          void _assignValue(const ::std::shared_ptr<ls::std::event::Event> &_value);
-          void _unmarshalParameterList();
-          void _update();
-          void _updateEventParameterList();
-      };
-    }
-  }
+      void _assignValue(const ::std::shared_ptr<ls::std::event::Event> &_value);
+      void _unmarshalParameterList();
+      void _update();
+      void _updateEventParameterList();
+  };
 }
 
 #endif

include/ls_std/io/File.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2022-05-11
+ * Changed:         2022-07-03
  *
  * */
 
@@ -16,6 +16,7 @@
 #include <list>
 #include <ctime>
 #include <regex>
+#include <ls_std/os/dynamic_goal.hpp>
 
 #if defined(unix) || defined(__APPLE__)
 
@@ -29,101 +30,95 @@
 
 #endif
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL File : public ls::std::core::Class
   {
-    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);
-      };
-    }
-  }
+    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,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -14,35 +14,30 @@
 #include "File.hpp"
 #include <ls_std/core/interface/IWriter.hpp>
 #include <fstream>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL FileOutputStream : public ls::std::core::Class, public ls::std::core::interface_type::IWriter
   {
-    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();
-      };
-    }
-  }
+    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:         2022-05-11
+ * Changed:         2022-07-03
  *
  * */
 
@@ -11,46 +11,41 @@
 #define FILE_PATH_SEPARATOR_HPP
 
 #include <string>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL FilePathSeparator
   {
-    namespace io
-    {
-      class FilePathSeparator
+    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()
       {
-        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 '\\';
-          }
-      };
-    }
-  }
+        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:         2022-05-11
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,21 +12,15 @@
 
 #include "FilePathSeparator.hpp"
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  struct FilePathSeparatorMatch
   {
-    namespace io
+    bool operator()(char _char) const
     {
-      struct FilePathSeparatorMatch
-      {
-        bool operator()(char _char) const
-        {
-          return _char == ls::std::io::FilePathSeparator::getWindowsFilePathSeparator() || _char == ls::std::io::FilePathSeparator::getUnixFilePathSeparator();
-        }
-      };
+      return _char == ls::std::io::FilePathSeparator::getWindowsFilePathSeparator() || _char == ls::std::io::FilePathSeparator::getUnixFilePathSeparator();
     }
-  }
+  };
 }
 
 #endif

include/ls_std/io/FileReader.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -13,31 +13,26 @@
 #include <ls_std/core/Class.hpp>
 #include "File.hpp"
 #include <ls_std/core/interface/IReader.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL FileReader : public ls::std::core::Class, public ls::std::core::interface_type::IReader
   {
-    namespace io
-    {
-      class FileReader : public ls::std::core::Class, public ls::std::core::interface_type::IReader
-      {
-        public:
+    public:
 
-          explicit FileReader(ls::std::io::File &_file);
-          ~FileReader() override = default;
+      explicit FileReader(ls::std::io::File &_file);
+      ~FileReader() override = default;
 
-          ls::std::core::type::byte_field read() override;
-          void reset(ls::std::io::File &_file);
+      ls::std::core::type::byte_field read() override;
+      void reset(ls::std::io::File &_file);
 
-        private:
+    private:
 
-          ls::std::io::File file;
+      ls::std::io::File file;
 
-          static void _init(ls::std::io::File &_file);
-      };
-    }
-  }
+      static void _init(ls::std::io::File &_file);
+  };
 }
 
 #endif

include/ls_std/io/FileWriter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -13,31 +13,26 @@
 #include <ls_std/core/Class.hpp>
 #include <ls_std/core/interface/IWriter.hpp>
 #include "File.hpp"
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL FileWriter : public ls::std::core::Class, public ls::std::core::interface_type::IWriter
   {
-    namespace io
-    {
-      class FileWriter : public ls::std::core::Class, public ls::std::core::interface_type::IWriter
-      {
-        public:
+    public:
 
-          explicit FileWriter(ls::std::io::File &_file);
-          ~FileWriter() override = default;
+      explicit FileWriter(ls::std::io::File &_file);
+      ~FileWriter() override = default;
 
-          void reset(ls::std::io::File &_file);
-          bool write(const ls::std::core::type::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::io::File file;
+      ls::std::io::File file;
 
-          static void _init(ls::std::io::File &_file);
-      };
-    }
-  }
+      static void _init(ls::std::io::File &_file);
+  };
 }
 
 #endif

include/ls_std/io/NewLine.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-18
- * Changed:         2022-05-11
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,45 +12,39 @@
 
 #include <string>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class NewLine
   {
-    namespace io
-    {
-      class NewLine
+    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()
       {
-        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";
-          }
-      };
-    }
-  }
+        return "\r\n";
+      }
+  };
 }
 
 #endif

include/ls_std/io/StandardOutputWriter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-06
- * Changed:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -11,24 +11,19 @@
 #define LS_STD_STANDARD_OUTPUT_WRITER_HPP
 
 #include <ls_std/core/interface/IWriter.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL StandardOutputWriter : public ls::std::core::interface_type::IWriter
   {
-    namespace io
-    {
-      class StandardOutputWriter : public ls::std::core::interface_type::IWriter
-      {
-        public:
+    public:
 
-          StandardOutputWriter() = default;
-          ~StandardOutputWriter() = default;
+      StandardOutputWriter() = default;
+      ~StandardOutputWriter() = default;
 
-          bool write(const ls::std::core::type::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:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -14,33 +14,28 @@
 #include <memory>
 #include <ls_std/core/interface/IStorable.hpp>
 #include "File.hpp"
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL StorableFile : public ls::std::core::interface_type::IStorable
   {
-    namespace io
-    {
-      class StorableFile : public ls::std::core::interface_type::IStorable
-      {
-        public:
+    public:
 
-          explicit StorableFile(const ::std::string &_path);
-          ~StorableFile() = default;
+      explicit StorableFile(const ::std::string &_path);
+      ~StorableFile() = default;
 
-          ::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;
+      ::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::io::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,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-12
+ * Changed:         2022-07-03
  *
  * */
 
@@ -14,34 +14,29 @@
 #include "KvPair.hpp"
 #include <ls_std/core/types/KvTypes.hpp>
 #include <map>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL KvDocument : public ls::std::core::Class
   {
-    namespace io
-    {
-      class KvDocument : public ls::std::core::Class
-      {
-        public:
+    public:
 
-          KvDocument();
-          ~KvDocument() override = default;
+      KvDocument();
+      ~KvDocument() override = default;
 
-          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);
+      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::core::type::kv_key, ls::std::io::KvPair> pairs{};
+      ::std::map<ls::std::core::type::kv_key, ls::std::io::KvPair> pairs{};
 
-          bool _hasPair(const ls::std::core::type::kv_key &_key);
-      };
-    }
-  }
+      bool _hasPair(const ls::std::core::type::kv_key &_key);
+  };
 }
 
 #endif

include/ls_std/io/kv/KvFileReader.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -15,40 +15,35 @@
 #include <ls_std/io/kv/KvDocument.hpp>
 #include <ls_std/io/File.hpp>
 #include <memory>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL KvFileReader : public ls::std::core::Class, public ls::std::core::interface_type::IReader
   {
-    namespace io
-    {
-      class KvFileReader : public ls::std::core::Class, public ls::std::core::interface_type::IReader
-      {
-        public:
+    public:
 
-          explicit KvFileReader(const ::std::shared_ptr<ls::std::io::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::core::type::byte_field read() override;
+      ls::std::core::type::byte_field read() override;
 
-          // additional functionality
+      // additional functionality
 
-          ::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);
+      ::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::io::KvDocument> document{};
-          ls::std::io::File kvFile;
+      ::std::shared_ptr<ls::std::io::KvDocument> document{};
+      ls::std::io::File kvFile;
 
-          void _assignDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document);
-          void _assignFile(ls::std::io::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,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-12
+ * Changed:         2022-07-03
  *
  * */
 
@@ -12,33 +12,28 @@
 
 #include <ls_std/core/Class.hpp>
 #include "ls_std/core/types/KvTypes.hpp"
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL KvPair : public ls::std::core::Class
   {
-    namespace io
-    {
-      class KvPair : public ls::std::core::Class
-      {
-        public:
+    public:
 
-          explicit KvPair(const ls::std::core::type::kv_key &_key, ls::std::core::type::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::core::type::kv_key getKey();
-          ls::std::core::type::kv_value getValue();
-          void setValue(const ls::std::core::type::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::core::type::kv_key key{};
-          ls::std::core::type::kv_value value{};
+      ls::std::core::type::kv_key key{};
+      ls::std::core::type::kv_value value{};
 
-          void _assignKey(const ls::std::core::type::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:         2022-05-13
+ * Changed:         2022-07-02
  *
  * */
 
@@ -12,19 +12,13 @@
 
 #include <string>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  struct KvParseParameter
   {
-    namespace io
-    {
-      struct KvParseParameter
-      {
-        ::std::string::size_type index{};
-        ::std::string line{};
-      };
-    }
-  }
+    ::std::string::size_type index{};
+    ::std::string line{};
+  };
 }
 
 #endif

include/ls_std/io/kv/KvParser.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-13
+ * Changed:         2022-07-03
  *
  * */
 
@@ -15,39 +15,34 @@
 #include "KvDocument.hpp"
 #include "KvParseParameter.hpp"
 #include <memory>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL KvParser : public ls::std::core::Class
   {
-    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);
-      };
-    }
-  }
+    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:         2022-05-11
+ * Changed:         2022-07-03
  *
  * */
 
@@ -13,44 +13,39 @@
 #include <unordered_map>
 #include <ls_std/core/Class.hpp>
 #include "LogLevelValue.hpp"
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL LogLevel : public ls::std::core::Class
   {
-    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);
-      };
-    }
-  }
+    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,25 +3,19 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-11
+ * Changed:         2022-07-02
  *
  * */
 
 #ifndef LS_STD_LOG_LEVEL_VALUE_HPP
 #define LS_STD_LOG_LEVEL_VALUE_HPP
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  enum LogLevelValue
   {
-    namespace io
-    {
-      enum LogLevelValue
-      {
-        FATAL = 0, ERR, WARN, INFO, DEBUG, TRACE
-      };
-    }
-  }
+    FATAL = 0, ERR, WARN, INFO, DEBUG, TRACE
+  };
 }
 
 #endif

include/ls_std/io/logging/Logger.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -16,43 +16,38 @@
 #include <ls_std/io/File.hpp>
 #include <ls_std/io/FileOutputStream.hpp>
 #include <string>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL Logger : public ls::std::core::Class
   {
-    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);
-      };
-    }
-  }
+    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,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-23
- * Changed:         2022-05-11
+ * Changed:         2022-07-03
  *
  * */
 
@@ -12,36 +12,31 @@
 
 #include <ls_std/core/Class.hpp>
 #include <string>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL XmlAttribute : public ls::std::core::Class
   {
-    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);
-      };
-    }
-  }
+    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,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2022-05-11
+ * Changed:         2022-07-03
  *
  * */
 
@@ -12,38 +12,33 @@
 
 #include <ls_std/core/Class.hpp>
 #include "XmlAttribute.hpp"
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL XmlDeclaration : public ls::std::core::Class
   {
-    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);
-      };
-    }
-  }
+    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:         2022-05-11
+ * Changed:         2022-07-03
  *
  * */
 
@@ -14,36 +14,31 @@
 #include <ls_std/core/Class.hpp>
 #include "XmlNode.hpp"
 #include "XmlDeclaration.hpp"
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL XmlDocument : public ls::std::core::Class
   {
-    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);
-      };
-    }
-  }
+    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:         2022-05-11
+ * Changed:         2022-07-03
  *
  * */
 
@@ -14,75 +14,70 @@
 #include <memory>
 #include <ls_std/core/Class.hpp>
 #include "XmlAttribute.hpp"
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL XmlNode : public ls::std::core::Class
   {
-    namespace io
-    {
-      class XmlNode : public ls::std::core::Class
-      {
-        public:
+    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::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();
+      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::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{};
+      ::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::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();
-      };
-    }
-  }
+      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,25 +3,19 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-13
- * Changed:         2022-05-11
+ * Changed:         2022-07-02
  *
  * */
 
 #ifndef LS_STD_XML_PARSE_MODE_HPP
 #define LS_STD_XML_PARSE_MODE_HPP
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  enum XmlParseMode
   {
-    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
-      };
-    }
-  }
+    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:         2022-05-11
+ * Changed:         2022-07-02
  *
  * */
 
@@ -14,19 +14,13 @@
 #include <memory>
 #include "XmlNode.hpp"
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  struct XmlParseParameter
   {
-    namespace io
-    {
-      struct XmlParseParameter
-      {
-        uint8_t level{};
-        ::std::shared_ptr<ls::std::io::XmlNode> node{};
-      };
-    }
-  }
+    uint8_t level{};
+    ::std::shared_ptr<ls::std::io::XmlNode> node{};
+  };
 }
 
 #endif

include/ls_std/io/xml/XmlParser.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-25
- * Changed:         2022-05-13
+ * Changed:         2022-07-03
  *
  * */
 
@@ -16,66 +16,61 @@
 #include "XmlParseMode.hpp"
 #include "XmlParseParameter.hpp"
 #include <list>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL XmlParser : public ls::std::core::Class
   {
-    namespace io
-    {
-      class XmlParser : public ls::std::core::Class
-      {
-        public:
+    public:
 
-          explicit XmlParser(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
-          ~XmlParser() override = default;
+      explicit XmlParser(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
+      ~XmlParser() override = default;
 
-          ::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);
+      ::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::core::type::byte_field &_data);
-          static ::std::list<::std::pair<::std::string, ::std::string>> _readAttributes_(ls::std::core::type::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::io::XmlDocument> document{};
-          uint8_t maxLevel{};
-          ls::std::io::XmlParseMode mode{};
-          ::std::list<ls::std::io::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::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();
-      };
-    }
-  }
+      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,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-08
- * Changed:         2022-05-19
+ * Changed:         2022-07-03
  *
  * */
 
@@ -17,40 +17,35 @@
 #include "XmlParseMode.hpp"
 #include "XmlParseParameter.hpp"
 #include <list>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::io
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL XmlReader : public ls::std::core::Class, public ls::std::core::interface_type::IReader
   {
-    namespace io
-    {
-      class XmlReader : public ls::std::core::Class, public ls::std::core::interface_type::IReader
-      {
-        public:
+    public:
 
-          explicit XmlReader(const ::std::shared_ptr<ls::std::io::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::core::type::byte_field read() override;
+      ls::std::core::type::byte_field read() override;
 
-          // additional functionality
+      // additional functionality
 
-          ::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);
+      ::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::io::XmlDocument> document{};
-          ls::std::io::File xmlFile;
+      ::std::shared_ptr<ls::std::io::XmlDocument> document{};
+      ls::std::io::File xmlFile;
 
-          void _assignDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
-          void _assignFile(ls::std::io::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/State.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-05
- * Changed:         2022-05-12
+ * Changed:         2022-07-15
  *
  * */
 
@@ -16,41 +16,36 @@
 #include <ls_std/core/types/StateMachineTypes.hpp>
 #include "StateConnection.hpp"
 #include <ls_std/core/interface/ISerializable.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::logic
 {
-  namespace std
+  class [[deprecated("consider using ls_game_tool_kit dependency instead!")]] LS_STD_DYNAMIC_GOAL State : public ls::std::core::Class
   {
-    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);
-      };
-    }
-  }
+    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:         2022-05-12
+ * Changed:         2022-07-15
  *
  * */
 
@@ -13,38 +13,33 @@
 #include <memory>
 #include <ls_std/core/Class.hpp>
 #include <ls_std/core/types/StateMachineTypes.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::logic
 {
-  namespace std
+  class [[deprecated("consider using ls_game_tool_kit dependency instead!")]] LS_STD_DYNAMIC_GOAL StateConnection : public ls::std::core::Class
   {
-    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);
-      };
-    }
-  }
+    public:
+
+      explicit StateConnection(const ls::std::core::type::state_connection_id &_connectionId, const ls::std::core::type::state_id &_stateId);
+      ~StateConnection() override = default;
+
+      ls::std::core::type::state_connection_id getConnectionId();
+      ls::std::core::type::state_id getStateId();
+      [[nodiscard]] bool isPassable() const;
+      void setConnectionId(const ls::std::core::type::state_connection_id &_connectionId);
+      void setStateId(const ls::std::core::type::state_id &_stateId);
+      void updatePassCondition(bool _condition);
+
+    private:
+
+      bool condition{};
+      ls::std::core::type::state_connection_id connectionId{};
+      ls::std::core::type::state_id stateId{};
+
+      void _assignConnectionId(const ls::std::core::type::state_connection_id &_connectionId);
+      void _assignStateId(const ls::std::core::type::state_id &_stateId);
+  };
 }
 
 #endif

include/ls_std/logic/StateMachine.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-05
- * Changed:         2022-05-12
+ * Changed:         2022-07-15
  *
  * */
 
@@ -17,46 +17,41 @@
 #include <ls_std/core/Class.hpp>
 #include "State.hpp"
 #include <ls_std/core/types/StateMachineTypes.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::logic
 {
-  namespace std
+  class [[deprecated("consider using ls_game_tool_kit dependency instead!")]] LS_STD_DYNAMIC_GOAL StateMachine : public ls::std::core::Class
   {
-    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);
-      };
-    }
-  }
+    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

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

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

include/ls_std/logic/serialization/SerializableJsonStateMachine.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-17
- * Changed:         2022-05-19
+ * Changed:         2022-07-15
  *
  * */
 
@@ -14,45 +14,40 @@
 #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>
+#include <ls_std/core/types/Types.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::logic
 {
-  namespace std
+  class [[deprecated("consider using ls_game_tool_kit dependency instead!")]] LS_STD_DYNAMIC_GOAL SerializableJsonStateMachine : public ls::std::core::Class, public ls::std::core::interface_type::ISerializable
   {
-    namespace logic
-    {
-      class SerializableJsonStateMachine : public ls::std::core::Class, public ls::std::core::interface_type::ISerializable
-      {
-        public:
+    public:
 
-          explicit SerializableJsonStateMachine(const ::std::shared_ptr<ls::std::logic::StateMachine> &_value);
-          ~SerializableJsonStateMachine() override = default;
+      explicit SerializableJsonStateMachine(const ::std::shared_ptr<ls::std::logic::StateMachine> &_value);
+      ~SerializableJsonStateMachine() override = default;
 
-          // implementation
+      // implementation
 
-          ls::std::core::type::byte_field marshal() override;
-          void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      ls::std::core::type::byte_field marshal() override;
+      void unmarshal(const ls::std::core::type::byte_field &_data) override;
 
-          // additional functionality
+      // additional functionality
 
-          ::std::shared_ptr<ls::std::logic::StateMachine> getValue();
-          void setValue(const ::std::shared_ptr<ls::std::logic::StateMachine> &_value);
+      ::std::shared_ptr<ls::std::logic::StateMachine> getValue();
+      void setValue(const ::std::shared_ptr<ls::std::logic::StateMachine> &_value);
 
-        private:
+    private:
 
-          nlohmann::json jsonObject{};
-          ::std::shared_ptr<ls::std::logic::StateMachine> value{};
+      ls::std::core::type::json jsonObject{};
+      ::std::shared_ptr<ls::std::logic::StateMachine> value{};
 
-          void _assignValue(const ::std::shared_ptr<ls::std::logic::StateMachine> &_value);
-          void _unmarshalCurrentState();
-          void _unmarshalStates();
-          void _update();
-          void _updateCurrentState();
-          void _updateStates();
-      };
-    }
-  }
+      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/os/dynamic_goal.hpp

@@ -0,0 +1,20 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-06-29
+ * Changed:         2022-07-17
+ *
+ * */
+
+#ifndef LS_STD_DYNAMIC_GOAL_HPP
+#define LS_STD_DYNAMIC_GOAL_HPP
+
+#if defined(_WIN32) && defined(_MSC_VER)
+#include <ls_std/os/windows/msvc_dll_definitions.hpp>
+#endif
+#if defined(unix) || defined(__APPLE__) || defined(_WIN32) && defined(__GNUC__)
+#include <ls_std/os/unix/unix_so_definitions.hpp>
+#endif
+
+#endif

include/ls_std/os/unix/unix_so_definitions.hpp

@@ -0,0 +1,15 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-06-29
+ * Changed:         2022-07-03
+ *
+ * */
+
+#ifndef LS_STD_UNIX_SO_DEFINITIONS_HPP
+#define LS_STD_UNIX_SO_DEFINITIONS_HPP
+
+#define LS_STD_DYNAMIC_GOAL
+
+#endif

include/ls_std/os/windows/msvc_dll_definitions.hpp

@@ -0,0 +1,17 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-06-26
+ * Changed:         2022-07-15
+ *
+ * */
+
+#ifndef LS_STD_MSVC_DLL_DEFINITIONS_HPP
+#define LS_STD_MSVC_DLL_DEFINITIONS_HPP
+
+#define LS_STD_DLL_EXPORT        __declspec(dllexport)
+#define LS_STD_DLL_IMPORT        __declspec(dllimport)
+#define LS_STD_DYNAMIC_GOAL      LS_STD_DLL_EXPORT
+
+#endif

include/ls_std/time/Date.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-05-09
+ * Changed:         2022-07-03
  *
  * */
 
@@ -11,53 +11,48 @@
 #define LS_STD_DATE_HPP
 
 #include <ls_std/core/Class.hpp>
+#include <ls_std/os/dynamic_goal.hpp>
 #include <ctime>
 
-namespace ls
+namespace ls::std::time
 {
-  namespace std
+  class LS_STD_DYNAMIC_GOAL Date : public ls::std::core::Class
   {
-    namespace time
-    {
-      class Date : public ls::std::core::Class
-      {
-        public:
-
-          Date();
-          ~Date() override = default;
-
-          // arithmetic operators
-
-          ls::std::time::Date &operator+(int _value);
-          ls::std::time::Date &operator-(int _value);
-          ls::std::time::Date &operator+=(int _value);
-          ls::std::time::Date &operator-=(int _value);
-
-          // additional functionality
-
-          bool after(const ls::std::time::Date &_foreignDate) const;
-          bool before(const ls::std::time::Date &_foreignDate) const;
-          int getDay();
-          int getHour();
-          int getMinute();
-          int getMonth();
-          int getSecond();
-          time_t getTime() const;
-          int getYear();
-          void setTime(time_t _timestamp);
-          ::std::string toString();
-
-        private:
-
-          time_t timestamp{};
-          tm *localTime{};
-
-          void _decrementByDays(int _value);
-          void _incrementByDays(int _value);
-          void _init();
-      };
-    }
-  }
+    public:
+
+      Date();
+      ~Date() override = default;
+
+      // arithmetic operators
+
+      ls::std::time::Date &operator+(int _value);
+      ls::std::time::Date &operator-(int _value);
+      ls::std::time::Date &operator+=(int _value);
+      ls::std::time::Date &operator-=(int _value);
+
+      // additional functionality
+
+      [[nodiscard]] bool after(const ls::std::time::Date &_foreignDate) const;
+      [[nodiscard]] bool before(const ls::std::time::Date &_foreignDate) const;
+      int getDay();
+      int getHour();
+      int getMinute();
+      int getMonth();
+      int getSecond();
+      [[nodiscard]] time_t getTime() const;
+      int getYear();
+      void setTime(time_t _timestamp);
+      ::std::string toString();
+
+    private:
+
+      time_t timestamp{};
+      tm *localTime{};
+
+      void _decrementByDays(int _value);
+      void _incrementByDays(int _value);
+      void _init();
+  };
 }
 
 #endif

source/ls_std/encoding/cli/cli_base64_main.cpp

@@ -0,0 +1,64 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-07-03
+ * Changed:         2022-07-03
+ *
+ * */
+
+#include <iostream>
+#include <vector>
+#include <string>
+#include <ls_std/ls_std_encoding.hpp>
+#include <ls_std/ls_std_core.hpp>
+
+using CLICommand = std::vector<std::string>;
+
+void printHelp();
+bool isValidCommand(const CLICommand &_command);
+
+int main(int argc, char *argv[])
+{
+  CLICommand command(argv, argv + argc);
+
+  if (isValidCommand(command))
+  {
+    if (command[1] == "--encode")
+    {
+      std::cout << ls::std::encoding::Base64{}.encode(command[2]) << std::endl;
+    }
+
+    if (command[1] == "--decode")
+    {
+      std::cout << ls::std::encoding::Base64{}.decode(command[2]) << std::endl;
+    }
+
+    if (command[1] == "--help")
+    {
+      printHelp();
+    }
+  }
+  else
+  {
+    std::cerr << "There is an error in this command. Please use \"--help\" to get more information." << std::endl;
+  }
+
+  exit(0);
+}
+
+void printHelp()
+{
+  std::string help = "Base 64 CLI - " + ls::std::core::getVersion() + "\n\n";
+  help += "(1) encode a string:\t\t";
+  help += "--encode [string]\n";
+  help += "(2) decode a string:\t\t";
+  help += "--decode [string]";
+
+  std::cout << help << std::endl;
+}
+
+bool isValidCommand(const CLICommand &_command)
+{
+  return _command.size() == 3 && _command[1] == "--encode" && !_command[2].empty() || _command.size() == 3 && _command[1] == "--decode" && !_command[2].empty() || _command.size() == 2 && _command[1] == "--help";
+}

source/ls_std/event/serialization/SerializableJsonEvent.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-07
- * Changed:         2022-05-20
+ * Changed:         2022-07-14
  *
  * */
 
@@ -23,7 +23,7 @@ ls::std::core::type::byte_field ls::std::event::SerializableJsonEvent::marshal()
 
 void ls::std::event::SerializableJsonEvent::unmarshal(const ls::std::core::type::byte_field &_data)
 {
-  this->jsonObject = nlohmann::json::parse(_data);
+  this->jsonObject = ls::std::core::type::json::parse(_data);
 
   this->value->setId(this->jsonObject["id"]);
   this->_unmarshalParameterList();
@@ -73,7 +73,7 @@ void ls::std::event::SerializableJsonEvent::_updateEventParameterList()
 
   for (const auto &eventParameter : this->value->getParameterList())
   {
-    nlohmann::json parameterJson = {eventParameter.first, eventParameter.second};
+    ls::std::core::type::json parameterJson = {eventParameter.first, eventParameter.second};
     this->jsonObject["parameterList"][eventParameter.first] = parameterJson;
   }
 }

source/ls_std/logic/serialization/SerializableJsonState.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-15
- * Changed:         2022-05-20
+ * Changed:         2022-07-14
  *
  * */
 
@@ -24,7 +24,7 @@ ls::std::core::type::byte_field ls::std::logic::SerializableJsonState::marshal()
 
 void ls::std::logic::SerializableJsonState::unmarshal(const ls::std::core::type::byte_field &_data)
 {
-  this->jsonObject = nlohmann::json::parse(_data);
+  this->jsonObject = ls::std::core::type::json::parse(_data);
 
   this->_unmarshalStateConnections();
   this->value->setId(this->jsonObject["id"]);
@@ -85,6 +85,6 @@ void ls::std::logic::SerializableJsonState::_updateStateConnections()
   for (const auto &connection : this->value->getConnectedStates())
   {
     jsonString = ls::std::logic::SerializableJsonStateConnection{connection.second}.marshal();
-    this->jsonObject["connectedStates"][connection.first] = nlohmann::json::parse(jsonString);
+    this->jsonObject["connectedStates"][connection.first] = ls::std::core::type::json::parse(jsonString);
   }
 }

source/ls_std/logic/serialization/SerializableJsonStateConnection.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-14
- * Changed:         2022-05-20
+ * Changed:         2022-07-14
  *
  * */
 
@@ -24,7 +24,7 @@ ls::std::core::type::byte_field ls::std::logic::SerializableJsonStateConnection:
 void ls::std::logic::SerializableJsonStateConnection::unmarshal(const ls::std::core::type::byte_field &_data)
 {
   ::std::string jsonString = ::std::string(_data);
-  this->jsonObject = nlohmann::json::parse(jsonString);
+  this->jsonObject = ls::std::core::type::json::parse(jsonString);
 
   this->value->setConnectionId(this->jsonObject["connectionId"]);
   this->value->setStateId(this->jsonObject["stateId"]);

source/ls_std/logic/serialization/SerializableJsonStateMachine.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-17
- * Changed:         2022-05-20
+ * Changed:         2022-07-14
  *
  * */
 
@@ -24,7 +24,7 @@ ls::std::core::type::byte_field ls::std::logic::SerializableJsonStateMachine::ma
 
 void ls::std::logic::SerializableJsonStateMachine::unmarshal(const ls::std::core::type::byte_field &_data)
 {
-  this->jsonObject = nlohmann::json::parse(_data);
+  this->jsonObject = ls::std::core::type::json::parse(_data);
 
   this->_unmarshalStates();
   this->_unmarshalCurrentState();
@@ -94,6 +94,6 @@ void ls::std::logic::SerializableJsonStateMachine::_updateStates()
   for (const auto &state : this->value->getStates())
   {
     jsonString = ls::std::logic::SerializableJsonState{state.second}.marshal();
-    this->jsonObject["states"][state.first] = nlohmann::json::parse(jsonString);
+    this->jsonObject["states"][state.first] = ls::std::core::type::json::parse(jsonString);
   }
 }

test/cases/core/LibraryVersionTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-02
- * Changed:         2022-05-13
+ * Changed:         2022-07-02
  *
  * */
 
@@ -28,6 +28,6 @@ namespace
 
   TEST_F(LibraryVersionTest, getVersion)
   {
-    ASSERT_STREQ("2022.1.0", ls::std::core::getVersion().c_str());
+    ASSERT_STREQ("2022.2.0", ls::std::core::getVersion().c_str());
   }
 }

test/cases/serialization/JsonTest.cpp

@@ -3,12 +3,12 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-05-05
+ * Changed:         2022-07-15
  *
  * */
 
 #include <gtest/gtest.h>
-#include <ls_std/lib/nlohmann_json/include/nlohmann/json.hpp>
+#include <ls_std/core/types/Types.hpp>
 
 namespace
 {
@@ -28,7 +28,7 @@ namespace
 
   TEST_F(JsonTest, simpleSerialization)
   {
-    nlohmann::json jsonObject{};
+    ls::std::core::type::json jsonObject{};
     jsonObject["value"] = 1989;
 
     ASSERT_STREQ(R"({"value":1989})", jsonObject.dump().c_str());

test/classes/event/Colour.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-05-14
- * Changed:         2022-05-14
+ * Changed:         2022-07-02
  *
  * */
 
@@ -21,7 +21,7 @@ namespace ls_std_event_test
       explicit Colour(const ::std::string &_value);
       ~Colour() override = default;
 
-      ::std::string getValue() const;
+      [[nodiscard]] ::std::string getValue() const;
 
     private: