Move types to dedicated "types" directory

- change namespace for library types

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -13,7 +13,7 @@
 #include <memory>
 #include <ls_std/core/Class.hpp>
 #include <ls_std/core/interface/IBoxing.hpp>
-#include <ls_std/core/Types.hpp>
+#include <ls_std/core/types/Types.hpp>
 
 namespace ls
 {
@@ -25,57 +25,57 @@ namespace ls
       {
         public:
 
-          explicit Long(ls::std::core::long_type _value);
+          explicit Long(ls::std::core::type::long_type _value);
           Long();
           ~Long() override = default;
 
           // conversion operator
 
-          operator ls::std::core::long_type() const;
+          operator ls::std::core::type::long_type() const;
 
           // assignment operators
 
-          ls::std::boxing::Long &operator=(ls::std::core::long_type _value);
+          ls::std::boxing::Long &operator=(ls::std::core::type::long_type _value);
 
           // arithmetic operators
 
-          ls::std::core::long_type operator-() const;
-          ls::std::core::long_type operator+(const ls::std::boxing::Long &_long) const;
-          ls::std::core::long_type operator+(ls::std::core::long_type _value) const;
-          ls::std::core::long_type operator*(const ls::std::boxing::Long &_long) const;
-          ls::std::core::long_type operator*(ls::std::core::long_type _value) const;
-          ls::std::core::long_type operator-(const ls::std::boxing::Long &_long) const;
-          ls::std::core::long_type operator-(ls::std::core::long_type _value) const;
-          ls::std::core::long_type operator/(const ls::std::boxing::Long &_long) const;
-          ls::std::core::long_type operator/(ls::std::core::long_type _value) const;
-          ls::std::core::long_type operator%(const ls::std::boxing::Long &_long) const;
-          ls::std::core::long_type operator%(ls::std::core::long_type _value) const;
+          ls::std::core::type::long_type operator-() const;
+          ls::std::core::type::long_type operator+(const ls::std::boxing::Long &_long) const;
+          ls::std::core::type::long_type operator+(ls::std::core::type::long_type _value) const;
+          ls::std::core::type::long_type operator*(const ls::std::boxing::Long &_long) const;
+          ls::std::core::type::long_type operator*(ls::std::core::type::long_type _value) const;
+          ls::std::core::type::long_type operator-(const ls::std::boxing::Long &_long) const;
+          ls::std::core::type::long_type operator-(ls::std::core::type::long_type _value) const;
+          ls::std::core::type::long_type operator/(const ls::std::boxing::Long &_long) const;
+          ls::std::core::type::long_type operator/(ls::std::core::type::long_type _value) const;
+          ls::std::core::type::long_type operator%(const ls::std::boxing::Long &_long) const;
+          ls::std::core::type::long_type operator%(ls::std::core::type::long_type _value) const;
 
           // compound operators
 
           ls::std::boxing::Long &operator+=(const ls::std::boxing::Long &_long);
-          ls::std::boxing::Long &operator+=(ls::std::core::long_type _value);
+          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::long_type _value);
+          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::long_type _value);
+          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::long_type _value);
+          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::long_type _value) 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::long_type _value) 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::long_type _value) 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::long_type _value) 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::long_type _value) 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::long_type _value) const;
+          bool operator<=(ls::std::core::type::long_type _value) const;
 
           // logical operators
 
@@ -85,10 +85,10 @@ namespace ls
           }
 
           bool operator&&(const ls::std::boxing::Long &_long) const;
-          bool operator&&(ls::std::core::long_type _value) 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::long_type _value) const;
+          bool operator||(ls::std::core::type::long_type _value) const;
           bool operator||(bool _expression) const;
 
           // increment / decrement operator
@@ -103,11 +103,11 @@ namespace ls
 
           // additional functionality
 
-          ls::std::core::long_type getValue() const;
+          ls::std::core::type::long_type getValue() const;
 
         private:
 
-          ls::std::core::long_type value{};
+          ls::std::core::type::long_type value{};
       };
     }
   }

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <ls_std/core/interface/IBoxing.hpp>
 #include <ls_std/core/Class.hpp>
-#include <ls_std/core/Types.hpp>
+#include <ls_std/core/types/Types.hpp>
 #include <string>
 #include <memory>
 #include <vector>
@@ -72,7 +72,7 @@ namespace ls
           bool endsWith(const ::std::string &_text);
           bool equalsIgnoreCase(ls::std::boxing::String _string);
           bool equalsIgnoreCase(::std::string _text);
-          ::std::vector<ls::std::core::byte> getByteData();
+          ::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();

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include "Class.hpp"
 #include <ls_std/core/interface/ISerializable.hpp>
-#include "Types.hpp"
+#include "ls_std/core/types/Types.hpp"
 
 namespace ls
 {
@@ -24,29 +24,29 @@ namespace ls
       {
         public:
 
-          explicit Version(ls::std::core::version_type _majorVersion, ls::std::core::version_type _minorVersion, ls::std::core::version_type _patchVersion);
+          explicit Version(ls::std::core::type::version_type _majorVersion, ls::std::core::type::version_type _minorVersion, ls::std::core::type::version_type _patchVersion);
           ~Version() = default;
 
           // implementation
 
-          ls::std::core::byte_field marshal() override;
-          void unmarshal(const ls::std::core::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
 
-          ls::std::core::version_type getMajorVersion() const;
-          ls::std::core::version_type getMinorVersion() const;
-          ls::std::core::version_type getPatchVersion() const;
+          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::version_type _major);
-          void setMinorVersion(ls::std::core::version_type _minor);
-          void setPatchVersion(ls::std::core::version_type _patch);
+          void setMajorVersion(ls::std::core::type::version_type _major);
+          void setMinorVersion(ls::std::core::type::version_type _minor);
+          void setPatchVersion(ls::std::core::type::version_type _patch);
 
         private:
 
-          ls::std::core::version_type majorVersion{};
-          ls::std::core::version_type minorVersion{};
-          ls::std::core::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);
       };

include/ls_std/core/interface/IEventSubscriber.hpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
 #ifndef LS_STD_I_EVENT_SUBSCRIBER_HPP
 #define LS_STD_I_EVENT_SUBSCRIBER_HPP
 
-#include "ls_std/event/EventTypes.hpp"
+#include <ls_std/core/types/EventTypes.hpp>
 #include <memory>
 #include "IListener.hpp"
 
@@ -27,8 +27,8 @@ namespace ls
           IEventSubscriber() = default;
           ~IEventSubscriber() = default;
 
-          virtual void subscribe(const ls::std::event::event_id &_id, const ::std::shared_ptr<ls::std::core::IListener> &_listener) = 0;
-          virtual void unsubscribe(const ls::std::event::event_id &_id, const ::std::shared_ptr<ls::std::core::IListener> &_listener) = 0;
+          virtual void subscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::IListener> &_listener) = 0;
+          virtual void unsubscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::IListener> &_listener) = 0;
       };
     }
   }

include/ls_std/core/interface/IReader.hpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
 #ifndef LS_STD_I_READER_HPP
 #define LS_STD_I_READER_HPP
 
-#include <ls_std/core/Types.hpp>
+#include "ls_std/core/types/Types.hpp"
 
 namespace ls
 {
@@ -25,7 +25,7 @@ namespace ls
           IReader() = default;
           ~IReader() = default;
 
-          virtual ls::std::core::byte_field read() = 0;
+          virtual ls::std::core::type::byte_field read() = 0;
       };
     }
   }

include/ls_std/core/interface/ISerializable.hpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-21
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
 #ifndef LS_STD_SERIALIZABLE_HPP
 #define LS_STD_SERIALIZABLE_HPP
 
-#include <ls_std/core/Types.hpp>
+#include "ls_std/core/types/Types.hpp"
 
 namespace ls
 {
@@ -25,8 +25,8 @@ namespace ls
           ISerializable() = default;
           ~ISerializable() = default;
 
-          virtual ls::std::core::byte_field marshal() = 0;
-          virtual void unmarshal(const ls::std::core::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;
       };
     }
   }

include/ls_std/core/interface/IStorable.hpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
 #ifndef LS_STD_I_STORABLE_HPP
 #define LS_STD_I_STORABLE_HPP
 
-#include <ls_std/core/Types.hpp>
+#include "ls_std/core/types/Types.hpp"
 
 namespace ls
 {
@@ -25,8 +25,8 @@ namespace ls
           IStorable() = default;
           ~IStorable() = default;
 
-          virtual ls::std::core::byte_field load() = 0;
-          virtual void save(const ls::std::core::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;
       };
     }
   }

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -11,7 +11,7 @@
 #define LS_STD_I_WRITER_HPP
 
 #include <vector>
-#include <ls_std/core/Types.hpp>
+#include "ls_std/core/types/Types.hpp"
 
 namespace ls
 {
@@ -26,7 +26,7 @@ namespace ls
           IWriter() = default;
           ~IWriter() = default;
 
-          virtual bool write(const ls::std::core::byte_field &_data) = 0;
+          virtual bool write(const ls::std::core::type::byte_field &_data) = 0;
       };
     }
   }

include/ls_std/core/types/EventTypes.hpp

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

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -16,10 +16,13 @@ namespace ls
 {
   namespace std
   {
-    namespace io
+    namespace core
     {
-      using kv_key = ::std::string;
-      using kv_value = ::std::string;
+      namespace type
+      {
+        using kv_key = ::std::string;
+        using kv_value = ::std::string;
+      }
     }
   }
 }

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-10
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -16,10 +16,13 @@ namespace ls
 {
   namespace std
   {
-    namespace logic
+    namespace core
     {
-      using StateConnectionId = ::std::string;
-      using StateId = ::std::string;
+      namespace type
+      {
+        using StateConnectionId = ::std::string;
+        using StateId = ::std::string;
+      }
     }
   }
 }

include/ls_std/core/Types.hpp → 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-09
+ * Changed:         2022-05-12
  *
  * */
 
@@ -18,10 +18,13 @@ namespace ls
   {
     namespace core
     {
-      using byte = char;
-      using byte_field = ::std::string;
-      using long_type = long long int;
-      using version_type = uint16_t;
+      namespace type
+      {
+        using byte = char;
+        using byte_field = ::std::string;
+        using long_type = long long int;
+        using version_type = uint16_t;
+      }
     }
   }
 }

include/ls_std/core/utils/WindowsUtils.hpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-06
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
 #ifndef LS_STD_WINDOWS_UTILS_HPP
 #define LS_STD_WINDOWS_UTILS_HPP
 
-#include <ls_std/core/Types.hpp>
+#include <ls_std/core/types/Types.hpp>
 #include <string>
 #include <windows.h>
 
@@ -29,7 +29,7 @@ namespace ls
 
           static ::std::string getMessageFromErrorCode(const int &_errorCode)
           {
-            ls::byte messageBuffer[256 + 1];
+            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};

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -13,7 +13,7 @@
 #include <ls_std/core/Class.hpp>
 #include <ls_std/core/interface/ISerializable.hpp>
 #include <memory>
-#include "EventTypes.hpp"
+#include <ls_std/core/types/EventTypes.hpp>
 
 namespace ls
 {
@@ -25,25 +25,25 @@ namespace ls
       {
         public:
 
-          explicit Event(const ls::std::event::event_id &_id);
+          explicit Event(const ls::std::core::type::event_id &_id);
           ~Event() override = default;
 
           // additional functionality
 
-          bool addParameter(const ls::std::event::event_parameter &_eventParameter);
+          bool addParameter(const ls::std::core::type::event_parameter &_eventParameter);
           void clearParameterList();
-          ls::std::event::event_id getId();
-          ls::std::event::event_parameter_list getParameterList();
-          bool removeParameter(const ls::std::event::event_parameter_id &_id);
-          void setId(const ls::std::event::event_id &_id);
+          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::event::event_id id{};
-          ls::std::event::event_parameter_list parameterList{};
+          ls::std::core::type::event_id id{};
+          ls::std::core::type::event_parameter_list parameterList{};
 
-          void _assignId(const ls::std::event::event_id &_id);
-          bool _hasParameter(const ls::std::event::event_id &_id);
+          void _assignId(const ls::std::core::type::event_id &_id);
+          bool _hasParameter(const ls::std::core::type::event_id &_id);
       };
     }
   }

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -15,7 +15,7 @@
 #include <memory>
 #include <ls_std/core/interface/IListener.hpp>
 #include "Event.hpp"
-#include <ls_std/logic/Narrator.hpp>
+#include <ls_std/logic/Narrator.hpp> // FIXME: dependency to "logic" module
 
 namespace ls
 {
@@ -27,16 +27,16 @@ namespace ls
       {
         public:
 
-          explicit EventHandler(const ls::std::event::event_id &_id);
+          explicit EventHandler(const ls::std::core::type::event_id &_id);
           ~EventHandler() override = default;
 
-          ls::std::event::event_id getId();
+          ls::std::core::type::event_id getId();
 
         private:
 
-          ls::std::event::event_id id{};
+          ls::std::core::type::event_id id{};
 
-          void _assignId(const ls::std::event::event_id &_id);
+          void _assignId(const ls::std::core::type::event_id &_id);
       };
     }
   }

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <ls_std/core/Class.hpp>
 #include <map>
-#include <ls_std/event/EventTypes.hpp>
+#include <ls_std/core/types/EventTypes.hpp>
 #include <memory>
 #include "EventHandler.hpp"
 #include <ls_std/core/interface/IEventSubscriber.hpp>
@@ -32,21 +32,21 @@ namespace ls
 
           // implementation
 
-          void subscribe(const ls::std::event::event_id &_id, const ::std::shared_ptr<ls::std::core::IListener> &_listener) override;
-          void unsubscribe(const ls::std::event::event_id &_id, const ::std::shared_ptr<ls::std::core::IListener> &_listener) override;
+          void subscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::IListener> &_listener) override;
+          void unsubscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::IListener> &_listener) override;
 
           // 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::event::event_id &_id);
+          bool hasEventHandler(const ls::std::core::type::event_id &_id);
           bool removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler);
 
         private:
 
-          ::std::map<ls::std::event::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::event::event_id &_id);
+          bool _hasEventHandler(const ls::std::core::type::event_id &_id);
           bool _removeEventHandler(const ::std::shared_ptr<ls::std::event::EventHandler> &_eventHandler);
       };
     }

include/ls_std/event/EventTypes.hpp

@@ -1,32 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-26
- * Changed:         2022-05-08
- *
- * */
-
-#ifndef LS_STD_EVENT_TYPES_HPP
-#define LS_STD_EVENT_TYPES_HPP
-
-#include <string>
-#include <vector>
-#include <map>
-
-namespace ls
-{
-  namespace std
-  {
-    namespace event
-    {
-      using event_id = ::std::string;
-      using event_parameter_id = ::std::string;
-      using event_parameter_value = ::std::string;
-      using event_parameter = ::std::pair<::std::string, ::std::string>;
-      using event_parameter_list = ::std::map<ls::std::event::event_parameter_id, ls::std::event::event_parameter_value>;
-    }
-  }
-}
-
-#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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -31,8 +31,8 @@ namespace ls
 
           // implementation
 
-          ls::std::core::byte_field marshal() override;
-          void unmarshal(const ls::std::core::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
 

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -30,7 +30,7 @@ namespace ls
           ~FileOutputStream() override;
 
           void close();
-          bool write(const ls::std::core::byte_field &_data) override;
+          bool write(const ls::std::core::type::byte_field &_data) override;
 
         private:
 

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -27,7 +27,7 @@ namespace ls
           explicit FileReader(ls::std::io::File &_file);
           ~FileReader() override = default;
 
-          ls::std::core::byte_field read() override;
+          ls::std::core::type::byte_field read() override;
           void reset(ls::std::io::File &_file);
 
         private:

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -28,7 +28,7 @@ namespace ls
           ~FileWriter() override = default;
 
           void reset(ls::std::io::File &_file);
-          bool write(const ls::std::core::byte_field &_data) override;
+          bool write(const ls::std::core::type::byte_field &_data) override;
 
         private:
 

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -25,7 +25,7 @@ namespace ls
           StandardOutputWriter() = default;
           ~StandardOutputWriter() = default;
 
-          bool write(const ls::std::core::byte_field &_data) override;
+          bool write(const ls::std::core::type::byte_field &_data) override;
       };
     }
   }

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -29,9 +29,9 @@ namespace ls
           ~StorableFile() = default;
 
           ::std::shared_ptr<ls::std::io::File> getFile();
-          ls::std::core::byte_field load() override;
+          ls::std::core::type::byte_field load() override;
           void reset(const ::std::string &_path);
-          void save(const ls::std::core::byte_field &_data) override;
+          void save(const ls::std::core::type::byte_field &_data) override;
 
         private:
 

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <ls_std/core/Class.hpp>
 #include "KvPair.hpp"
-#include "KvTypes.hpp"
+#include "ls_std/core/types/KvTypes.hpp"
 #include <map>
 
 namespace ls
@@ -30,15 +30,15 @@ namespace ls
 
           bool addPair(ls::std::io::KvPair _pair);
           void clear();
-          ::std::map<ls::std::io::kv_key, ls::std::io::KvPair> getPairs();
-          bool hasPair(const ls::std::io::kv_key &_key);
-          bool removePair(const ls::std::io::kv_key &_key);
+          ::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:
 
-          ::std::map<ls::std::io::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::io::kv_key &_key);
+          bool _hasPair(const ls::std::core::type::kv_key &_key);
       };
     }
   }

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -31,7 +31,7 @@ namespace ls
 
           // implementation
 
-          ls::std::core::byte_field read() override;
+          ls::std::core::type::byte_field read() override;
 
           // additional functionality
 

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -11,7 +11,7 @@
 #define LS_STD_KV_PAIR_HPP
 
 #include <ls_std/core/Class.hpp>
-#include "KvTypes.hpp"
+#include "ls_std/core/types/KvTypes.hpp"
 
 namespace ls
 {
@@ -23,19 +23,19 @@ namespace ls
       {
         public:
 
-          explicit KvPair(const ls::std::io::kv_key &_key, ls::std::io::kv_value _value);
+          explicit KvPair(const ls::std::core::type::kv_key &_key, ls::std::core::type::kv_value _value);
           ~KvPair() override = default;
 
-          ls::std::io::kv_key getKey();
-          ls::std::io::kv_value getValue();
-          void setValue(const ls::std::io::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:
 
-          ls::std::io::kv_key key{};
-          ls::std::io::kv_value value{};
+          ls::std::core::type::kv_key key{};
+          ls::std::core::type::kv_value value{};
 
-          void _assignKey(const ls::std::io::kv_key &_key);
+          void _assignKey(const ls::std::core::type::kv_key &_key);
       };
     }
   }

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -11,7 +11,7 @@
 #define LS_STD_KV_PARSER_HPP
 
 #include <ls_std/core/Class.hpp>
-#include <ls_std/core/Types.hpp>
+#include "ls_std/core/types/Types.hpp"
 #include "KvDocument.hpp"
 #include "KvParseParameter.hpp"
 #include <memory>
@@ -30,7 +30,7 @@ namespace ls
           ~KvParser() override = default;
 
           ::std::shared_ptr<ls::std::io::KvDocument> getDocument();
-          void parse(const ls::std::core::byte_field &_data);
+          void parse(const ls::std::core::type::byte_field &_data);
           void setDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document);
 
         private:
@@ -39,9 +39,9 @@ namespace ls
 
           void _assignDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document);
           static bool _lineHasPair(ls::std::io::KvParseParameter _parseParameter);
-          void _parse(const ls::std::core::byte_field &_data);
+          void _parse(const ls::std::core::type::byte_field &_data);
           void _parsePair(ls::std::io::KvParseParameter _parseParameter);
-          static ls::std::io::KvParseParameter _readLine(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          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);
       };

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -30,14 +30,14 @@ namespace ls
           explicit Logger(const ::std::shared_ptr<ls::std::core::IWriter> &_writer);
           ~Logger() override = default;
 
-          void debug(const ls::std::core::byte *_data);
-          void error(const ls::std::core::byte *_data);
-          void fatal(const ls::std::core::byte *_data);
+          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::byte *_data);
+          void info(const ls::std::core::type::byte *_data);
           void setLogLevel(const ls::std::io::LogLevelValue &_logLevelValue);
-          void trace(const ls::std::core::byte *_data);
-          void warn(const ls::std::core::byte *_data);
+          void trace(const ls::std::core::type::byte *_data);
+          void warn(const ls::std::core::type::byte *_data);
 
         private:
 
@@ -45,7 +45,7 @@ namespace ls
           ::std::shared_ptr<ls::std::core::IWriter> writer{};
 
           void _assignWriter(const ::std::shared_ptr<ls::std::core::IWriter> &_writer);
-          void _log(const ls::std::core::byte *_data, const ls::std::io::LogLevel &_logLevel);
+          void _log(const ls::std::core::type::byte *_data, const ls::std::io::LogLevel &_logLevel);
       };
     }
   }

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -11,7 +11,7 @@
 #define LS_STD_XML_PARSER_HPP
 
 #include <ls_std/core/Class.hpp>
-#include <ls_std/core/Types.hpp>
+#include <ls_std/core/types/Types.hpp>
 #include "XmlDocument.hpp"
 #include "XmlParseMode.hpp"
 #include "XmlParseParameter.hpp"
@@ -31,13 +31,13 @@ namespace ls
           ~XmlParser() override = default;
 
           ::std::shared_ptr<ls::std::io::XmlDocument> getDocument();
-          void parse(const ls::std::core::byte_field &_data);
+          void parse(const ls::std::core::type::byte_field &_data);
           void setDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
 
         protected:
 
-          static ::std::pair<::std::string, ::std::string> _readAttribute_(const ls::std::core::byte_field &_data);
-          static ::std::list<::std::pair<::std::string, ::std::string>> _readAttributes_(ls::std::core::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:
 
@@ -47,28 +47,28 @@ namespace ls
           ls::std::io::XmlParseMode mode{};
           ::std::list<ls::std::io::XmlParseParameter> parseParameters{};
 
-          void _analyze(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          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 ::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 ::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::byte_field &_data);
-          static ls::std::core::byte_field _getNextTagString(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-          void _isClosingTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-          void _isDeclaration(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-          void _isOpeningTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-          void _isValue(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          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::byte_field &_data);
-          static ::std::pair<::std::string, ::std::string> _parseAttribute(const ls::std::core::byte_field &_data);
-          static ::std::list<::std::pair<::std::string, ::std::string>> _parseAttributes(ls::std::core::byte_field _data);
-          size_t _parseClosingTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-          size_t _parseDeclaration(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-          size_t _parseOpeningTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-          static ls::std::core::byte_field _parseTagName(const ls::std::core::byte_field &_data);
-          size_t _parseValue(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          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();
       };

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -33,7 +33,7 @@ namespace ls
 
           // implementation
 
-          ls::std::core::byte_field read() override;
+          ls::std::core::type::byte_field read() override;
 
           // additional functionality
 

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -13,7 +13,7 @@
 #include <memory>
 #include <unordered_map>
 #include <ls_std/core/Class.hpp>
-#include "StateMachineTypes.hpp"
+#include "ls_std/core/types/StateMachineTypes.hpp"
 #include "StateConnection.hpp"
 #include <ls_std/core/interface/ISerializable.hpp>
 
@@ -27,27 +27,27 @@ namespace ls
       {
         public:
 
-          explicit State(const ls::std::logic::StateId &_id);
+          explicit State(const ls::std::core::type::StateId &_id);
           ~State() override = default;
 
           // additional functionality
 
-          bool addStateConnection(const ls::std::logic::StateConnectionId &_connectionId, const ::std::shared_ptr<ls::std::logic::State> &_connectedState);
+          bool addStateConnection(const ls::std::core::type::StateConnectionId &_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::logic::StateConnectionId, ::std::shared_ptr<ls::std::logic::StateConnection>> getConnectedStates();
-          ls::std::logic::StateId getId();
-          bool hasConnection(const ls::std::logic::StateConnectionId &_connectionId);
-          void setId(const ls::std::logic::StateId &_id);
+          ::std::unordered_map<ls::std::core::type::StateConnectionId, ::std::shared_ptr<ls::std::logic::StateConnection>> getConnectedStates();
+          ls::std::core::type::StateId getId();
+          bool hasConnection(const ls::std::core::type::StateConnectionId &_connectionId);
+          void setId(const ls::std::core::type::StateId &_id);
 
         private:
 
-          ::std::unordered_map<ls::std::logic::StateConnectionId, ::std::shared_ptr<ls::std::logic::StateConnection>> connectedStates{};
-          ls::std::logic::StateId id{};
+          ::std::unordered_map<ls::std::core::type::StateConnectionId, ::std::shared_ptr<ls::std::logic::StateConnection>> connectedStates{};
+          ls::std::core::type::StateId id{};
 
-          void _assignStateId(const ls::std::logic::StateId &_id);
+          void _assignStateId(const ls::std::core::type::StateId &_id);
           void _clearConnections();
-          bool _hasConnection(const ls::std::logic::StateConnectionId &_connectionId);
+          bool _hasConnection(const ls::std::core::type::StateConnectionId &_connectionId);
       };
     }
   }

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <memory>
 #include <ls_std/core/Class.hpp>
-#include "StateMachineTypes.hpp"
+#include "ls_std/core/types/StateMachineTypes.hpp"
 
 namespace ls
 {
@@ -24,24 +24,24 @@ namespace ls
       {
         public:
 
-          explicit StateConnection(const ls::std::logic::StateConnectionId &_connectionId, const ls::std::logic::StateId &_stateId);
+          explicit StateConnection(const ls::std::core::type::StateConnectionId &_connectionId, const ls::std::core::type::StateId &_stateId);
           ~StateConnection() override = default;
 
-          StateConnectionId getConnectionId();
-          ls::std::logic::StateId getStateId();
+          ls::std::core::type::StateConnectionId getConnectionId();
+          ls::std::core::type::StateId getStateId();
           bool isPassable() const;
-          void setConnectionId(const ls::std::logic::StateConnectionId &_connectionId);
-          void setStateId(const ls::std::logic::StateId &_stateId);
+          void setConnectionId(const ls::std::core::type::StateConnectionId &_connectionId);
+          void setStateId(const ls::std::core::type::StateId &_stateId);
           void updatePassCondition(bool _condition);
 
         private:
 
           bool condition{};
-          ls::std::logic::StateConnectionId connectionId{};
-          ls::std::logic::StateId stateId{};
+          ls::std::core::type::StateConnectionId connectionId{};
+          ls::std::core::type::StateId stateId{};
 
-          void _assignConnectionId(const ls::std::logic::StateConnectionId &_connectionId);
-          void _assignStateId(const ls::std::logic::StateId &_stateId);
+          void _assignConnectionId(const ls::std::core::type::StateConnectionId &_connectionId);
+          void _assignStateId(const ls::std::core::type::StateId &_stateId);
       };
     }
   }

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -16,7 +16,7 @@
 #include <vector>
 #include <ls_std/core/Class.hpp>
 #include "State.hpp"
-#include "StateMachineTypes.hpp"
+#include "ls_std/core/types/StateMachineTypes.hpp"
 
 namespace ls
 {
@@ -33,27 +33,27 @@ namespace ls
 
           bool addState(const ::std::shared_ptr<ls::std::logic::State> &_state);
           ::std::shared_ptr<ls::std::logic::State> getCurrentState();
-          ::std::vector<ls::std::logic::StateId> getMemory();
+          ::std::vector<ls::std::core::type::StateId> getMemory();
           ::std::string getName();
-          ::std::unordered_map<ls::std::logic::StateId, ::std::shared_ptr<ls::std::logic::State>> getStates();
-          bool hasState(const ls::std::logic::StateId &_id);
+          ::std::unordered_map<ls::std::core::type::StateId, ::std::shared_ptr<ls::std::logic::State>> getStates();
+          bool hasState(const ls::std::core::type::StateId &_id);
           bool proceed();
-          void setMemory(const ::std::vector<ls::std::logic::StateId> &_memory);
+          void setMemory(const ::std::vector<ls::std::core::type::StateId> &_memory);
           void setName(const ::std::string &_name);
-          bool setStartState(const ls::std::logic::StateId &_id);
+          bool setStartState(const ls::std::core::type::StateId &_id);
 
         private:
 
           ::std::shared_ptr<ls::std::logic::State> currentState{};
-          ::std::vector<ls::std::logic::StateId> memory{};
+          ::std::vector<ls::std::core::type::StateId> memory{};
           ::std::string name{};
-          ::std::unordered_map<ls::std::logic::StateId, ::std::shared_ptr<ls::std::logic::State>> states{};
+          ::std::unordered_map<ls::std::core::type::StateId, ::std::shared_ptr<ls::std::logic::State>> states{};
 
-          void _assignMemory(const ::std::vector<ls::std::logic::StateId> &_memory);
+          void _assignMemory(const ::std::vector<ls::std::core::type::StateId> &_memory);
           void _assignName(const ::std::string &_name);
-          ::std::vector<ls::std::logic::StateId> _getNextValidStates();
-          void _remember(const ls::std::logic::StateId &_id);
-          bool _hasState(const ls::std::logic::StateId &_id);
+          ::std::vector<ls::std::core::type::StateId> _getNextValidStates();
+          void _remember(const ls::std::core::type::StateId &_id);
+          bool _hasState(const ls::std::core::type::StateId &_id);
       };
     }
   }

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -31,8 +31,8 @@ namespace ls
 
           // implementation
 
-          ls::std::core::byte_field marshal() override;
-          void unmarshal(const ls::std::core::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
 

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -31,8 +31,8 @@ namespace ls
 
           // implementation
 
-          ls::std::core::byte_field marshal() override;
-          void unmarshal(const ls::std::core::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
 

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -31,8 +31,8 @@ namespace ls
 
           // implementation
 
-          ls::std::core::byte_field marshal() override;
-          void unmarshal(const ls::std::core::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
 

include/ls_std/ls_std.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-29
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -33,6 +33,10 @@
 #include "core/interface/ISerializable.hpp"
 #include "core/interface/IStorable.hpp"
 #include "core/interface/IWriter.hpp"
+#include "core/types/EventTypes.hpp"
+#include "core/types/KvTypes.hpp"
+#include "core/types/StateMachineTypes.hpp"
+#include "core/types/Types.hpp"
 #include "core/utils/RegexUtils.hpp"
 #include "core/utils/STLUtils.hpp"
 #if _WIN32
@@ -40,21 +44,18 @@
 #endif
 #include "core/Class.hpp"
 #include "core/LibraryVersion.hpp"
-#include "core/Types.hpp"
 #include "core/Version.hpp"
 
 #include "event/serialization/SerializableJsonEvent.hpp"
 #include "event/Event.hpp"
 #include "event/EventHandler.hpp"
 #include "event/EventManager.hpp"
-#include "event/EventTypes.hpp"
 
 #include "io/kv/KvDocument.hpp"
 #include "io/kv/KvFileReader.hpp"
 #include "io/kv/KvPair.hpp"
 #include "io/kv/KvParseParameter.hpp"
 #include "io/kv/KvParser.hpp"
-#include "io/kv/KvTypes.hpp"
 #include "io/logging/Logger.hpp"
 #include "io/logging/LogLevel.hpp"
 #include "io/logging/LogLevelValue.hpp"
@@ -83,7 +84,6 @@
 #include "logic/State.hpp"
 #include "logic/StateConnection.hpp"
 #include "logic/StateMachine.hpp"
-#include "logic/StateMachineTypes.hpp"
 
 #include "time/Date.hpp"
 

source/ls_std/boxing/Long.cpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-09
+ * Changed:         2022-05-12
  *
  * */
 
 #include <ls_std/boxing/Long.hpp>
 #include <ls_std/core/exception/IllegalArithmeticOperationException.hpp>
 
-ls::std::boxing::Long::Long(ls::std::core::long_type _value)
+ls::std::boxing::Long::Long(ls::std::core::type::long_type _value)
     : ls::std::core::Class("Long"),
       value(_value)
 {}
@@ -18,55 +18,55 @@ ls::std::boxing::Long::Long(ls::std::core::long_type _value)
 ls::std::boxing::Long::Long() : ls::std::core::Class("Long")
 {}
 
-ls::std::boxing::Long::operator ls::std::core::long_type() const
+ls::std::boxing::Long::operator ls::std::core::type::long_type() const
 {
   return this->value;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator=(ls::std::core::long_type _value)
+ls::std::boxing::Long &ls::std::boxing::Long::operator=(ls::std::core::type::long_type _value)
 {
   this->value = _value;
   return *this;
 }
 
-ls::std::core::long_type ls::std::boxing::Long::operator-() const
+ls::std::core::type::long_type ls::std::boxing::Long::operator-() const
 {
   return -this->value;
 }
 
-ls::std::core::long_type ls::std::boxing::Long::operator+(const ls::std::boxing::Long &_long) const
+ls::std::core::type::long_type ls::std::boxing::Long::operator+(const ls::std::boxing::Long &_long) const
 {
   return this->value + _long;
 }
 
-ls::std::core::long_type ls::std::boxing::Long::operator+(ls::std::core::long_type _value) const
+ls::std::core::type::long_type ls::std::boxing::Long::operator+(ls::std::core::type::long_type _value) const
 {
   return this->value + _value;
 }
 
-ls::std::core::long_type ls::std::boxing::Long::operator*(const ls::std::boxing::Long &_long) const
+ls::std::core::type::long_type ls::std::boxing::Long::operator*(const ls::std::boxing::Long &_long) const
 {
   return this->value * _long;
 }
 
-ls::std::core::long_type ls::std::boxing::Long::operator*(ls::std::core::long_type _value) const
+ls::std::core::type::long_type ls::std::boxing::Long::operator*(ls::std::core::type::long_type _value) const
 {
   return this->value * _value;
 }
 
-ls::std::core::long_type ls::std::boxing::Long::operator-(const ls::std::boxing::Long &_long) const
+ls::std::core::type::long_type ls::std::boxing::Long::operator-(const ls::std::boxing::Long &_long) const
 {
   return this->value - _long;
 }
 
-ls::std::core::long_type ls::std::boxing::Long::operator-(ls::std::core::long_type _value) const
+ls::std::core::type::long_type ls::std::boxing::Long::operator-(ls::std::core::type::long_type _value) const
 {
   return this->value - _value;
 }
 
-ls::std::core::long_type ls::std::boxing::Long::operator/(const ls::std::boxing::Long &_long) const
+ls::std::core::type::long_type ls::std::boxing::Long::operator/(const ls::std::boxing::Long &_long) const
 {
-  if (_long == (ls::std::core::long_type) 0)
+  if (_long == (ls::std::core::type::long_type) 0)
   {
     throw ls::std::core::IllegalArithmeticOperationException{};
   }
@@ -74,7 +74,7 @@ ls::std::core::long_type ls::std::boxing::Long::operator/(const ls::std::boxing:
   return this->value / _long;
 }
 
-ls::std::core::long_type ls::std::boxing::Long::operator/(ls::std::core::long_type _value) const
+ls::std::core::type::long_type ls::std::boxing::Long::operator/(ls::std::core::type::long_type _value) const
 {
   if (_value == 0)
   {
@@ -84,12 +84,12 @@ ls::std::core::long_type ls::std::boxing::Long::operator/(ls::std::core::long_ty
   return this->value / _value;
 }
 
-ls::std::core::long_type ls::std::boxing::Long::operator%(const ls::std::boxing::Long &_long) const
+ls::std::core::type::long_type ls::std::boxing::Long::operator%(const ls::std::boxing::Long &_long) const
 {
   return this->value % _long;
 }
 
-ls::std::core::long_type ls::std::boxing::Long::operator%(ls::std::core::long_type _value) const
+ls::std::core::type::long_type ls::std::boxing::Long::operator%(ls::std::core::type::long_type _value) const
 {
   return this->value % _value;
 }
@@ -100,7 +100,7 @@ ls::std::boxing::Long &ls::std::boxing::Long::operator+=(const ls::std::boxing::
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator+=(ls::std::core::long_type _value)
+ls::std::boxing::Long &ls::std::boxing::Long::operator+=(ls::std::core::type::long_type _value)
 {
   this->value += _value;
   return *this;
@@ -112,7 +112,7 @@ ls::std::boxing::Long &ls::std::boxing::Long::operator-=(const ls::std::boxing::
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator-=(ls::std::core::long_type _value)
+ls::std::boxing::Long &ls::std::boxing::Long::operator-=(ls::std::core::type::long_type _value)
 {
   this->value -= _value;
   return *this;
@@ -124,7 +124,7 @@ ls::std::boxing::Long &ls::std::boxing::Long::operator*=(const ls::std::boxing::
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator*=(ls::std::core::long_type _value)
+ls::std::boxing::Long &ls::std::boxing::Long::operator*=(ls::std::core::type::long_type _value)
 {
   this->value *= _value;
   return *this;
@@ -132,7 +132,7 @@ ls::std::boxing::Long &ls::std::boxing::Long::operator*=(ls::std::core::long_typ
 
 ls::std::boxing::Long &ls::std::boxing::Long::operator/=(const ls::std::boxing::Long &_long)
 {
-  if (_long == (ls::std::core::long_type) 0)
+  if (_long == (ls::std::core::type::long_type) 0)
   {
     throw ls::std::core::IllegalArithmeticOperationException{};
   }
@@ -141,7 +141,7 @@ ls::std::boxing::Long &ls::std::boxing::Long::operator/=(const ls::std::boxing::
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator/=(ls::std::core::long_type _value)
+ls::std::boxing::Long &ls::std::boxing::Long::operator/=(ls::std::core::type::long_type _value)
 {
   if (_value == 0)
   {
@@ -157,7 +157,7 @@ bool ls::std::boxing::Long::operator==(const ls::std::boxing::Long &_long) const
   return this->value == _long;
 }
 
-bool ls::std::boxing::Long::operator==(ls::std::core::long_type _value) const
+bool ls::std::boxing::Long::operator==(ls::std::core::type::long_type _value) const
 {
   return this->value == _value;
 }
@@ -167,7 +167,7 @@ bool ls::std::boxing::Long::operator!=(const ls::std::boxing::Long &_long) const
   return this->value != _long;
 }
 
-bool ls::std::boxing::Long::operator!=(ls::std::core::long_type _value) const
+bool ls::std::boxing::Long::operator!=(ls::std::core::type::long_type _value) const
 {
   return this->value != _value;
 }
@@ -177,7 +177,7 @@ bool ls::std::boxing::Long::operator>(const ls::std::boxing::Long &_long) const
   return this->value > _long;
 }
 
-bool ls::std::boxing::Long::operator>(ls::std::core::long_type _value) const
+bool ls::std::boxing::Long::operator>(ls::std::core::type::long_type _value) const
 {
   return this->value > _value;
 }
@@ -187,7 +187,7 @@ bool ls::std::boxing::Long::operator>=(const ls::std::boxing::Long &_long) const
   return this->value >= _long;
 }
 
-bool ls::std::boxing::Long::operator>=(ls::std::core::long_type _value) const
+bool ls::std::boxing::Long::operator>=(ls::std::core::type::long_type _value) const
 {
   return this->value >= _value;
 }
@@ -197,7 +197,7 @@ bool ls::std::boxing::Long::operator<(const ls::std::boxing::Long &_long) const
   return this->value < _long;
 }
 
-bool ls::std::boxing::Long::operator<(ls::std::core::long_type _value) const
+bool ls::std::boxing::Long::operator<(ls::std::core::type::long_type _value) const
 {
   return this->value < _value;
 }
@@ -207,7 +207,7 @@ bool ls::std::boxing::Long::operator<=(const ls::std::boxing::Long &_long) const
   return this->value <= _long;
 }
 
-bool ls::std::boxing::Long::operator<=(ls::std::core::long_type _value) const
+bool ls::std::boxing::Long::operator<=(ls::std::core::type::long_type _value) const
 {
   return this->value <= _value;
 }
@@ -217,7 +217,7 @@ bool ls::std::boxing::Long::operator&&(const ls::std::boxing::Long &_long) const
   return this->value && _long;
 }
 
-bool ls::std::boxing::Long::operator&&(ls::std::core::long_type _value) const
+bool ls::std::boxing::Long::operator&&(ls::std::core::type::long_type _value) const
 {
   return this->value && _value;
 }
@@ -232,7 +232,7 @@ bool ls::std::boxing::Long::operator||(const ls::std::boxing::Long &_long) const
   return this->value || _long;
 }
 
-bool ls::std::boxing::Long::operator||(ls::std::core::long_type _value) const
+bool ls::std::boxing::Long::operator||(ls::std::core::type::long_type _value) const
 {
   return this->value || _value;
 }
@@ -262,7 +262,7 @@ std::string ls::std::boxing::Long::toString()
   return ::std::to_string(this->value);
 }
 
-ls::std::core::long_type ls::std::boxing::Long::getValue() const
+ls::std::core::type::long_type ls::std::boxing::Long::getValue() const
 {
   return this->value;
 }

source/ls_std/boxing/String.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-05-09
+ * Changed:         2022-05-12
  *
  * */
 
@@ -128,9 +128,9 @@ bool ls::std::boxing::String::equalsIgnoreCase(::std::string _text)
   return this->toLowerCase() == ls::std::boxing::String{::std::move(_text)}.toLowerCase();
 }
 
-std::vector<ls::std::core::byte> ls::std::boxing::String::getByteData()
+std::vector<ls::std::core::type::byte> ls::std::boxing::String::getByteData()
 {
-  ::std::vector<ls::std::core::byte> byteData(this->value.begin(), this->value.end());
+  ::std::vector<ls::std::core::type::byte> byteData(this->value.begin(), this->value.end());
   byteData.push_back('\0');
 
   return byteData;

source/ls_std/core/Version.cpp

@@ -3,22 +3,22 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-28
- * Changed:         2022-05-09
+ * Changed:         2022-05-12
  *
  * */
 
 #include <regex>
 #include <ls_std/core/Version.hpp>
 
-ls::std::core::Version::Version(ls::std::core::version_type _majorVersion, ls::std::core::version_type _minorVersion, ls::std::core::version_type _patchVersion)
+ls::std::core::Version::Version(ls::std::core::type::version_type _majorVersion, ls::std::core::type::version_type _minorVersion, ls::std::core::type::version_type _patchVersion)
     : majorVersion(_majorVersion),
       minorVersion(_minorVersion),
       patchVersion(_patchVersion)
 {}
 
-ls::std::core::byte_field ls::std::core::Version::marshal()
+ls::std::core::type::byte_field ls::std::core::Version::marshal()
 {
-  ls::std::core::byte_field data{};
+  ls::std::core::type::byte_field data{};
 
   data += ::std::to_string(this->majorVersion) + ".";
   data += ::std::to_string(this->minorVersion) + ".";
@@ -27,7 +27,7 @@ ls::std::core::byte_field ls::std::core::Version::marshal()
   return data;
 }
 
-void ls::std::core::Version::unmarshal(const ls::std::core::byte_field &_data)
+void ls::std::core::Version::unmarshal(const ls::std::core::type::byte_field &_data)
 {
   ::std::string field = _data;
 
@@ -47,17 +47,17 @@ void ls::std::core::Version::unmarshal(const ls::std::core::byte_field &_data)
   }
 }
 
-ls::std::core::version_type ls::std::core::Version::getMajorVersion() const
+ls::std::core::type::version_type ls::std::core::Version::getMajorVersion() const
 {
   return this->majorVersion;
 }
 
-ls::std::core::version_type ls::std::core::Version::getMinorVersion() const
+ls::std::core::type::version_type ls::std::core::Version::getMinorVersion() const
 {
   return this->minorVersion;
 }
 
-ls::std::core::version_type ls::std::core::Version::getPatchVersion() const
+ls::std::core::type::version_type ls::std::core::Version::getPatchVersion() const
 {
   return this->patchVersion;
 }
@@ -67,17 +67,17 @@ bool ls::std::core::Version::isValid(const ::std::string &_versionString)
   return ls::std::core::Version::_isValid(_versionString);
 }
 
-void ls::std::core::Version::setMajorVersion(ls::std::core::version_type _major)
+void ls::std::core::Version::setMajorVersion(ls::std::core::type::version_type _major)
 {
   this->majorVersion = _major;
 }
 
-void ls::std::core::Version::setMinorVersion(ls::std::core::version_type _minor)
+void ls::std::core::Version::setMinorVersion(ls::std::core::type::version_type _minor)
 {
   this->minorVersion = _minor;
 }
 
-void ls::std::core::Version::setPatchVersion(ls::std::core::version_type _patch)
+void ls::std::core::Version::setPatchVersion(ls::std::core::type::version_type _patch)
 {
   this->patchVersion = _patch;
 }

source/ls_std/event/Event.cpp

@@ -3,19 +3,19 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-09
+ * Changed:         2022-05-12
  *
  * */
 
 #include <ls_std/event/Event.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::event::Event::Event(const ls::std::event::event_id &_id) : ls::std::core::Class("Event")
+ls::std::event::Event::Event(const ls::std::core::type::event_id &_id) : ls::std::core::Class("Event")
 {
   this->_assignId(_id);
 }
 
-bool ls::std::event::Event::addParameter(const ls::std::event::event_parameter &_eventParameter)
+bool ls::std::event::Event::addParameter(const ls::std::core::type::event_parameter &_eventParameter)
 {
   bool wasAdded{};
 
@@ -32,27 +32,27 @@ void ls::std::event::Event::clearParameterList()
   this->parameterList.clear();
 }
 
-ls::std::event::event_id ls::std::event::Event::getId()
+ls::std::core::type::event_id ls::std::event::Event::getId()
 {
   return this->id;
 }
 
-ls::std::event::event_parameter_list ls::std::event::Event::getParameterList()
+ls::std::core::type::event_parameter_list ls::std::event::Event::getParameterList()
 {
   return this->parameterList;
 }
 
-bool ls::std::event::Event::removeParameter(const ls::std::event::event_parameter_id &_id)
+bool ls::std::event::Event::removeParameter(const ls::std::core::type::event_parameter_id &_id)
 {
   return this->parameterList.erase(_id) == 1;
 }
 
-void ls::std::event::Event::setId(const ls::std::event::event_id &_id)
+void ls::std::event::Event::setId(const ls::std::core::type::event_id &_id)
 {
   this->_assignId(_id);
 }
 
-void ls::std::event::Event::_assignId(const ls::std::event::event_id &_id)
+void ls::std::event::Event::_assignId(const ls::std::core::type::event_id &_id)
 {
   if (_id.empty())
   {
@@ -62,7 +62,7 @@ void ls::std::event::Event::_assignId(const ls::std::event::event_id &_id)
   this->id = _id;
 }
 
-bool ls::std::event::Event::_hasParameter(const ls::std::event::event_id &_id)
+bool ls::std::event::Event::_hasParameter(const ls::std::core::type::event_id &_id)
 {
   return this->parameterList.find(_id) != this->parameterList.end();
 }

source/ls_std/event/EventHandler.cpp

@@ -3,24 +3,24 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
 #include <ls_std/event/EventHandler.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::event::EventHandler::EventHandler(const ls::std::event::event_id& _id) : ls::std::logic::Narrator()
+ls::std::event::EventHandler::EventHandler(const ls::std::core::type::event_id& _id) : ls::std::logic::Narrator()
 {
   this->_assignId(_id);
 }
 
-ls::std::event::event_id ls::std::event::EventHandler::getId()
+ls::std::core::type::event_id ls::std::event::EventHandler::getId()
 {
   return this->id;
 }
 
-void ls::std::event::EventHandler::_assignId(const ls::std::event::event_id &_id)
+void ls::std::event::EventHandler::_assignId(const ls::std::core::type::event_id &_id)
 {
   if (_id.empty())
   {

source/ls_std/event/EventManager.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -15,7 +15,7 @@
 ls::std::event::EventManager::EventManager() : ls::std::core::Class("EventManager")
 {}
 
-void ls::std::event::EventManager::subscribe(const ls::std::event::event_id &_id, const ::std::shared_ptr<ls::std::core::IListener> &_listener)
+void ls::std::event::EventManager::subscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::IListener> &_listener)
 {
   if (_id.empty() || _listener == nullptr)
   {
@@ -32,7 +32,7 @@ void ls::std::event::EventManager::subscribe(const ls::std::event::event_id &_id
   }
 }
 
-void ls::std::event::EventManager::unsubscribe(const ls::std::event::event_id &_id, const ::std::shared_ptr<ls::std::core::IListener> &_listener)
+void ls::std::event::EventManager::unsubscribe(const ls::std::core::type::event_id &_id, const ::std::shared_ptr<ls::std::core::IListener> &_listener)
 {
   if (_id.empty() || _listener == nullptr)
   {
@@ -56,7 +56,7 @@ bool ls::std::event::EventManager::addEventHandler(const ::std::shared_ptr<ls::s
 
   if (!this->_hasEventHandler(_eventHandler->getId()))
   {
-    ::std::pair<ls::std::event::event_id, ::std::shared_ptr<ls::std::event::EventHandler>> element = ::std::make_pair(_eventHandler->getId(), _eventHandler);
+    ::std::pair<ls::std::core::type::event_id, ::std::shared_ptr<ls::std::event::EventHandler>> element = ::std::make_pair(_eventHandler->getId(), _eventHandler);
     wasAdded = this->eventHandlers.insert(element).second;
   }
 
@@ -75,7 +75,7 @@ void ls::std::event::EventManager::fire(ls::std::event::Event _event)
   }
 }
 
-bool ls::std::event::EventManager::hasEventHandler(const ls::std::event::event_id &_id)
+bool ls::std::event::EventManager::hasEventHandler(const ls::std::core::type::event_id &_id)
 {
   if (_id.empty())
   {
@@ -95,7 +95,7 @@ bool ls::std::event::EventManager::removeEventHandler(const ::std::shared_ptr<ls
   return this->_removeEventHandler(_eventHandler);
 }
 
-bool ls::std::event::EventManager::_hasEventHandler(const ls::std::event::event_id &_id)
+bool ls::std::event::EventManager::_hasEventHandler(const ls::std::core::type::event_id &_id)
 {
   return this->eventHandlers.find(_id) != this->eventHandlers.end();
 }

source/ls_std/event/serialization/SerializableJsonEvent.cpp

@@ -3,11 +3,11 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-07
- * Changed:         2022-05-09
+ * Changed:         2022-05-12
  *
  * */
 
-#include "ls_std/event/serialization/SerializableJsonEvent.hpp"
+#include <ls_std/event/serialization/SerializableJsonEvent.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
 ls::std::event::SerializableJsonEvent::SerializableJsonEvent(const ::std::shared_ptr<ls::std::event::Event> &_value) : ls::std::core::Class("SerializableJsonEvent")
@@ -15,13 +15,13 @@ ls::std::event::SerializableJsonEvent::SerializableJsonEvent(const ::std::shared
   this->_assignValue(_value);
 }
 
-ls::std::core::byte_field ls::std::event::SerializableJsonEvent::marshal()
+ls::std::core::type::byte_field ls::std::event::SerializableJsonEvent::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls::std::event::SerializableJsonEvent::unmarshal(const ls::std::core::byte_field &_data)
+void ls::std::event::SerializableJsonEvent::unmarshal(const ls::std::core::type::byte_field &_data)
 {
   this->jsonObject = nlohmann::json::parse(_data);
 
@@ -55,7 +55,7 @@ void ls::std::event::SerializableJsonEvent::_unmarshalParameterList()
 
   for (const auto &parameterJson : this->jsonObject["parameterList"])
   {
-    ls::std::event::event_parameter parameter = {parameterJson.at(0), parameterJson.at(1)};
+    ls::std::core::type::event_parameter parameter = {parameterJson.at(0), parameterJson.at(1)};
     this->value->addParameter(parameter);
   }
 }

source/ls_std/io/FileOutputStream.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -36,7 +36,7 @@ void ls::std::io::FileOutputStream::close()
   this->_close();
 }
 
-bool ls::std::io::FileOutputStream::write(const ls::std::core::byte_field &_data)
+bool ls::std::io::FileOutputStream::write(const ls::std::core::type::byte_field &_data)
 {
   bool succeeded{};
 

source/ls_std/io/FileReader.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -19,12 +19,12 @@ ls::std::io::FileReader::FileReader(ls::std::io::File &_file)
   ls::std::io::FileReader::_init(_file);
 }
 
-ls::std::core::byte_field ls::std::io::FileReader::read()
+ls::std::core::type::byte_field ls::std::io::FileReader::read()
 {
-  ls::std::core::byte *data;
+  ls::std::core::type::byte *data;
   ::std::ifstream inputStream{this->file.getAbsoluteFilePath(), ::std::ifstream::binary};
   int length = (int) this->file.getSize();
-  data = new ls::std::core::byte[length];
+  data = new ls::std::core::type::byte[length];
   inputStream.read(data, length);
 
   if (inputStream.fail())
@@ -33,7 +33,7 @@ ls::std::core::byte_field ls::std::io::FileReader::read()
   }
 
   inputStream.close();
-  ls::std::core::byte_field readData = ls::std::core::byte_field{data, (size_t) this->file.getSize()};
+  ls::std::core::type::byte_field readData = ls::std::core::type::byte_field{data, (size_t) this->file.getSize()};
   delete[] data;
 
   return readData;

source/ls_std/io/FileWriter.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -25,7 +25,7 @@ void ls::std::io::FileWriter::reset(ls::std::io::File &_file)
   this->file = _file;
 }
 
-bool ls::std::io::FileWriter::write(const ls::std::core::byte_field &_data)
+bool ls::std::io::FileWriter::write(const ls::std::core::type::byte_field &_data)
 {
   ::std::ofstream outputStream{};
   outputStream.open(this->file.getAbsoluteFilePath());

source/ls_std/io/StandardOutputWriter.cpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-06
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
 #include <iostream>
 #include <ls_std/io/StandardOutputWriter.hpp>
 
-bool ls::std::io::StandardOutputWriter::write(const ls::std::core::byte_field &_data)
+bool ls::std::io::StandardOutputWriter::write(const ls::std::core::type::byte_field &_data)
 {
   ::std::cout << _data;
   return !::std::cout.fail();

source/ls_std/io/StorableFile.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -21,7 +21,7 @@ std::shared_ptr<ls::std::io::File> ls::std::io::StorableFile::getFile()
   return this->file;
 }
 
-ls::std::core::byte_field ls::std::io::StorableFile::load()
+ls::std::core::type::byte_field ls::std::io::StorableFile::load()
 {
   ls::std::io::FileReader reader{*this->file};
   return reader.read();
@@ -32,7 +32,7 @@ void ls::std::io::StorableFile::reset(const ::std::string &_path)
   this->_init(_path);
 }
 
-void ls::std::io::StorableFile::save(const ls::std::core::byte_field &_data)
+void ls::std::io::StorableFile::save(const ls::std::core::type::byte_field &_data)
 {
   ls::std::io::FileWriter writer{*this->file};
   writer.write(_data);

source/ls_std/io/kv/KvDocument.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -18,7 +18,7 @@ bool ls::std::io::KvDocument::addPair(ls::std::io::KvPair _pair)
 
   if (!this->_hasPair(_pair.getKey()))
   {
-    ::std::pair<ls::std::io::kv_key, ls::std::io::KvPair> pair = ::std::make_pair(_pair.getKey(), _pair);
+    ::std::pair<ls::std::core::type::kv_key, ls::std::io::KvPair> pair = ::std::make_pair(_pair.getKey(), _pair);
     added = this->pairs.insert(pair).second;
   }
 
@@ -30,22 +30,22 @@ void ls::std::io::KvDocument::clear()
   this->pairs.clear();
 }
 
-std::map<ls::std::io::kv_key, ls::std::io::KvPair> ls::std::io::KvDocument::getPairs()
+std::map<ls::std::core::type::kv_key, ls::std::io::KvPair> ls::std::io::KvDocument::getPairs()
 {
   return this->pairs;
 }
 
-bool ls::std::io::KvDocument::hasPair(const ls::std::io::kv_key &_key)
+bool ls::std::io::KvDocument::hasPair(const ls::std::core::type::kv_key &_key)
 {
   return this->_hasPair(_key);
 }
 
-bool ls::std::io::KvDocument::removePair(const ls::std::io::kv_key &_key)
+bool ls::std::io::KvDocument::removePair(const ls::std::core::type::kv_key &_key)
 {
   return this->pairs.erase(_key) == 1;
 }
 
-bool ls::std::io::KvDocument::_hasPair(const ls::std::io::kv_key &_key)
+bool ls::std::io::KvDocument::_hasPair(const ls::std::core::type::kv_key &_key)
 {
   return this->pairs.find(_key) != this->pairs.end();
 }

source/ls_std/io/kv/KvFileReader.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -20,9 +20,9 @@ ls::std::io::KvFileReader::KvFileReader(const ::std::shared_ptr<ls::std::io::KvD
   this->_assignFile(ls::std::io::File{_absolutePath});
 }
 
-ls::std::core::byte_field ls::std::io::KvFileReader::read()
+ls::std::core::type::byte_field ls::std::io::KvFileReader::read()
 {
-  ls::std::core::byte_field data = ls::std::io::FileReader{this->kvFile}.read();
+  ls::std::core::type::byte_field data = ls::std::io::FileReader{this->kvFile}.read();
   ls::std::io::KvParser{this->document}.parse(data);
 
   return data;

source/ls_std/io/kv/KvPair.cpp

@@ -3,36 +3,36 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
 #include <ls_std/io/kv/KvPair.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::io::KvPair::KvPair(const ls::std::io::kv_key &_key, ls::std::io::kv_value _value)
+ls::std::io::KvPair::KvPair(const ls::std::core::type::kv_key &_key, ls::std::core::type::kv_value _value)
     : ls::std::core::Class("KvPair"),
       value(::std::move(_value))
 {
   this->_assignKey(_key);
 }
 
-ls::std::io::kv_key ls::std::io::KvPair::getKey()
+ls::std::core::type::kv_key ls::std::io::KvPair::getKey()
 {
   return this->key;
 }
 
-ls::std::io::kv_value ls::std::io::KvPair::getValue()
+ls::std::core::type::kv_value ls::std::io::KvPair::getValue()
 {
   return this->value;
 }
 
-void ls::std::io::KvPair::setValue(const ls::std::io::kv_value &_value)
+void ls::std::io::KvPair::setValue(const ls::std::core::type::kv_value &_value)
 {
   this->value = _value;
 }
 
-void ls::std::io::KvPair::_assignKey(const ls::std::io::kv_key &_key)
+void ls::std::io::KvPair::_assignKey(const ls::std::core::type::kv_key &_key)
 {
   if (_key.empty())
   {

source/ls_std/io/kv/KvParser.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -21,7 +21,7 @@ std::shared_ptr<ls::std::io::KvDocument> ls::std::io::KvParser::getDocument()
   return this->document;
 }
 
-void ls::std::io::KvParser::parse(const ls::std::core::byte_field &_data)
+void ls::std::io::KvParser::parse(const ls::std::core::type::byte_field &_data)
 {
   this->_parse(_data);
 }
@@ -46,7 +46,7 @@ bool ls::std::io::KvParser::_lineHasPair(ls::std::io::KvParseParameter _parsePar
   return _parseParameter.line.contains("=") && _parseParameter.line.contains(";");
 }
 
-void ls::std::io::KvParser::_parse(const ls::std::core::byte_field &_data)
+void ls::std::io::KvParser::_parse(const ls::std::core::type::byte_field &_data)
 {
   for (::std::string::size_type index = 0; index < _data.size(); index++)
   {
@@ -61,15 +61,15 @@ void ls::std::io::KvParser::_parsePair(ls::std::io::KvParseParameter _parseParam
   if (ls::std::io::KvParser::_lineHasPair(_parseParameter))
   {
     size_t equalSignPosition = _parseParameter.line.toString().find('=');
-    ls::std::io::kv_key key = _parseParameter.line.toString().substr(0, equalSignPosition);
-    ls::std::io::kv_value value = _parseParameter.line.toString().substr(equalSignPosition + 1);
+    ls::std::core::type::kv_key key = _parseParameter.line.toString().substr(0, equalSignPosition);
+    ls::std::core::type::kv_value value = _parseParameter.line.toString().substr(equalSignPosition + 1);
     value = value.substr(0, value.find(';'));
 
     this->document->addPair(ls::std::io::KvPair{key, value});
   }
 }
 
-ls::std::io::KvParseParameter ls::std::io::KvParser::_readLine(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+ls::std::io::KvParseParameter ls::std::io::KvParser::_readLine(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
 {
   ls::std::io::KvParseParameter parseParameter{};
   parseParameter.line = _data.substr(_index);

source/ls_std/io/logging/Logger.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -20,7 +20,7 @@ ls::std::io::Logger::Logger(const ::std::shared_ptr<ls::std::core::IWriter> &_wr
   this->_assignWriter(_writer);
 }
 
-void ls::std::io::Logger::debug(const ls::std::core::byte *_data)
+void ls::std::io::Logger::debug(const ls::std::core::type::byte *_data)
 {
   if (this->logLevel >= ls::std::io::LogLevelValue::DEBUG)
   {
@@ -28,7 +28,7 @@ void ls::std::io::Logger::debug(const ls::std::core::byte *_data)
   }
 }
 
-void ls::std::io::Logger::error(const ls::std::core::byte *_data)
+void ls::std::io::Logger::error(const ls::std::core::type::byte *_data)
 {
   if (this->logLevel >= ls::std::io::LogLevelValue::ERR)
   {
@@ -36,7 +36,7 @@ void ls::std::io::Logger::error(const ls::std::core::byte *_data)
   }
 }
 
-void ls::std::io::Logger::fatal(const ls::std::core::byte *_data)
+void ls::std::io::Logger::fatal(const ls::std::core::type::byte *_data)
 {
   if (this->logLevel >= ls::std::io::LogLevelValue::FATAL)
   {
@@ -49,7 +49,7 @@ ls::std::io::LogLevel ls::std::io::Logger::getLogLevel()
   return this->logLevel;
 }
 
-void ls::std::io::Logger::info(const ls::std::core::byte *_data)
+void ls::std::io::Logger::info(const ls::std::core::type::byte *_data)
 {
   if (this->logLevel >= ls::std::io::LogLevelValue::INFO)
   {
@@ -62,7 +62,7 @@ void ls::std::io::Logger::setLogLevel(const ls::std::io::LogLevelValue &_logLeve
   this->logLevel = _logLevelValue;
 }
 
-void ls::std::io::Logger::trace(const ls::std::core::byte *_data)
+void ls::std::io::Logger::trace(const ls::std::core::type::byte *_data)
 {
   if (this->logLevel >= ls::std::io::LogLevelValue::TRACE)
   {
@@ -70,7 +70,7 @@ void ls::std::io::Logger::trace(const ls::std::core::byte *_data)
   }
 }
 
-void ls::std::io::Logger::warn(const ls::std::core::byte *_data)
+void ls::std::io::Logger::warn(const ls::std::core::type::byte *_data)
 {
   if (this->logLevel >= ls::std::io::LogLevelValue::WARN)
   {
@@ -88,7 +88,7 @@ void ls::std::io::Logger::_assignWriter(const ::std::shared_ptr<ls::std::core::I
   this->writer = _writer;
 }
 
-void ls::std::io::Logger::_log(const ls::std::core::byte *_data, const ls::std::io::LogLevel &_logLevel)
+void ls::std::io::Logger::_log(const ls::std::core::type::byte *_data, const ls::std::io::LogLevel &_logLevel)
 {
   ls::std::time::Date date{};
   ::std::string message = "[" + date.toString() + "] " + ls::std::boxing::String{_logLevel.toString() + ":"}.padRight(10, ' ') + ::std::string(_data) + ls::std::io::NewLine::getUnixNewLine();

source/ls_std/io/xml/XmlParser.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -22,7 +22,7 @@ ls::std::io::XmlParser::XmlParser(const ::std::shared_ptr<ls::std::io::XmlDocume
   return this->document;
 }
 
-void ls::std::io::XmlParser::parse(const ls::std::core::byte_field &_data)
+void ls::std::io::XmlParser::parse(const ls::std::core::type::byte_field &_data)
 {
   this->_parse(_data);
   this->_mergeNodes();
@@ -34,17 +34,17 @@ void ls::std::io::XmlParser::setDocument(const ::std::shared_ptr<ls::std::io::Xm
   this->_assignDocument(_document);
 }
 
-::std::pair<::std::string, ::std::string> ls::std::io::XmlParser::_readAttribute_(const ls::std::core::byte_field &_data)
+::std::pair<::std::string, ::std::string> ls::std::io::XmlParser::_readAttribute_(const ls::std::core::type::byte_field &_data)
 {
   return ls::std::io::XmlParser::_parseAttribute(_data);
 }
 
-::std::list<::std::pair<::std::string, ::std::string>> ls::std::io::XmlParser::_readAttributes_(ls::std::core::byte_field _data)
+::std::list<::std::pair<::std::string, ::std::string>> ls::std::io::XmlParser::_readAttributes_(ls::std::core::type::byte_field _data)
 {
   return ls::std::io::XmlParser::_parseAttributes(::std::move(_data));
 }
 
-void ls::std::io::XmlParser::_analyze(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+void ls::std::io::XmlParser::_analyze(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
 {
   this->_isDeclaration(_data, _index);
   this->_isClosingTag(_data, _index);
@@ -120,7 +120,7 @@ void ls::std::io::XmlParser::_assignDocument(const ::std::shared_ptr<ls::std::io
   return attribute;
 }
 
-size_t ls::std::io::XmlParser::_findAttributeEndPosition(const ls::std::core::byte_field &_data)
+size_t ls::std::io::XmlParser::_findAttributeEndPosition(const ls::std::core::type::byte_field &_data)
 {
   ::std::string::size_type position = ::std::string::npos;
   ::std::string::size_type counter{};
@@ -143,9 +143,9 @@ size_t ls::std::io::XmlParser::_findAttributeEndPosition(const ls::std::core::by
   return position;
 }
 
-ls::std::core::byte_field ls::std::io::XmlParser::_getNextTagString(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+ls::std::core::type::byte_field ls::std::io::XmlParser::_getNextTagString(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
 {
-  ls::std::core::byte_field tag{};
+  ls::std::core::type::byte_field tag{};
   size_t closingCharacterPosition = _index + _data.substr(_index).find('>');
 
   if (closingCharacterPosition != ::std::string::npos)
@@ -156,7 +156,7 @@ ls::std::core::byte_field ls::std::io::XmlParser::_getNextTagString(const ls::st
   return tag;
 }
 
-void ls::std::io::XmlParser::_isClosingTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+void ls::std::io::XmlParser::_isClosingTag(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
 {
   if (this->mode == XML_PARSE_MODE_ANALYZE && _data.substr(_index, 2) == "</")
   {
@@ -164,7 +164,7 @@ void ls::std::io::XmlParser::_isClosingTag(const ls::std::core::byte_field &_dat
   }
 }
 
-void ls::std::io::XmlParser::_isDeclaration(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+void ls::std::io::XmlParser::_isDeclaration(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
 {
   if (_data.substr(_index, 5) == "<?xml")
   {
@@ -172,7 +172,7 @@ void ls::std::io::XmlParser::_isDeclaration(const ls::std::core::byte_field &_da
   }
 }
 
-void ls::std::io::XmlParser::_isOpeningTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+void ls::std::io::XmlParser::_isOpeningTag(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
 {
   if (this->mode == XML_PARSE_MODE_ANALYZE && _data.substr(_index, 1) == "<")
   {
@@ -180,7 +180,7 @@ void ls::std::io::XmlParser::_isOpeningTag(const ls::std::core::byte_field &_dat
   }
 }
 
-void ls::std::io::XmlParser::_isValue(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+void ls::std::io::XmlParser::_isValue(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
 {
   if (this->mode == XML_PARSE_MODE_ANALYZE)
   {
@@ -248,7 +248,7 @@ void ls::std::io::XmlParser::_mergeNodesOnCurrentLevel()
   }
 }
 
-void ls::std::io::XmlParser::_parse(const ls::std::core::byte_field &_data)
+void ls::std::io::XmlParser::_parse(const ls::std::core::type::byte_field &_data)
 {
   for (::std::string::size_type index = 0; index < _data.size(); index++)
   {
@@ -291,7 +291,7 @@ void ls::std::io::XmlParser::_parse(const ls::std::core::byte_field &_data)
   }
 }
 
-::std::pair<::std::string, ::std::string> ls::std::io::XmlParser::_parseAttribute(const ls::std::core::byte_field &_data)
+::std::pair<::std::string, ::std::string> ls::std::io::XmlParser::_parseAttribute(const ls::std::core::type::byte_field &_data)
 {
   ::std::pair<::std::string, ::std::string> parsedAttribute{};
   parsedAttribute.first = _data.substr(0, _data.find('='));
@@ -301,7 +301,7 @@ void ls::std::io::XmlParser::_parse(const ls::std::core::byte_field &_data)
   return parsedAttribute;
 }
 
-::std::list<::std::pair<::std::string, ::std::string>> ls::std::io::XmlParser::_parseAttributes(ls::std::core::byte_field _data)
+::std::list<::std::pair<::std::string, ::std::string>> ls::std::io::XmlParser::_parseAttributes(ls::std::core::type::byte_field _data)
 {
   ::std::list<::std::pair<::std::string, ::std::string>> attributes{};
   size_t position = _data.find(' ');
@@ -327,14 +327,14 @@ void ls::std::io::XmlParser::_parse(const ls::std::core::byte_field &_data)
   return attributes;
 }
 
-size_t ls::std::io::XmlParser::_parseClosingTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+size_t ls::std::io::XmlParser::_parseClosingTag(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
 {
   ::std::string tagString = ls::std::io::XmlParser::_getNextTagString(_data, _index);
   this->currentLevel -= 1;
   return tagString.empty() ? _index : _index + (tagString.size() - 1);
 }
 
-size_t ls::std::io::XmlParser::_parseDeclaration(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+size_t ls::std::io::XmlParser::_parseDeclaration(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
 {
   ::std::string tagString = ls::std::io::XmlParser::_getNextTagString(_data, _index);
   bool isValidTagString = !tagString.empty();
@@ -348,7 +348,7 @@ size_t ls::std::io::XmlParser::_parseDeclaration(const ls::std::core::byte_field
   return !isValidTagString ? _index : _index + (tagString.size() - 1);
 }
 
-size_t ls::std::io::XmlParser::_parseOpeningTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+size_t ls::std::io::XmlParser::_parseOpeningTag(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
 {
   ls::std::boxing::String tagString{ls::std::io::XmlParser::_getNextTagString(_data, _index)};
   bool isValidTagString = !tagString.toString().empty();
@@ -372,7 +372,7 @@ size_t ls::std::io::XmlParser::_parseOpeningTag(const ls::std::core::byte_field
   return !isValidTagString ? _index : _index + (tagString.toString().size() - 1);
 }
 
-ls::std::core::byte_field ls::std::io::XmlParser::_parseTagName(const ls::std::core::byte_field &_data)
+ls::std::core::type::byte_field ls::std::io::XmlParser::_parseTagName(const ls::std::core::type::byte_field &_data)
 {
   ::std::string::size_type position = _data.find(' ');
 
@@ -384,9 +384,9 @@ ls::std::core::byte_field ls::std::io::XmlParser::_parseTagName(const ls::std::c
   return _data.substr(1, position - 1);
 }
 
-size_t ls::std::io::XmlParser::_parseValue(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+size_t ls::std::io::XmlParser::_parseValue(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
 {
-  ls::std::core::byte_field value = _data.substr(_index, _data.substr(_index).find('<'));
+  ls::std::core::type::byte_field value = _data.substr(_index, _data.substr(_index).find('<'));
   this->parseParameters.back().node->setValue(value);
 
   return _index + (value.size() - 1);

source/ls_std/io/xml/XmlReader.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-10
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -21,9 +21,9 @@ ls::std::io::XmlReader::XmlReader(const ::std::shared_ptr<ls::std::io::XmlDocume
   this->_assignFile(ls::std::io::File{_absolutePath});
 }
 
-ls::std::core::byte_field ls::std::io::XmlReader::read()
+ls::std::core::type::byte_field ls::std::io::XmlReader::read()
 {
-  ls::std::core::byte_field data = ls::std::io::FileReader{this->xmlFile}.read();
+  ls::std::core::type::byte_field data = ls::std::io::FileReader{this->xmlFile}.read();
   ls::std::io::XmlParser{this->document}.parse(data);
 
   return data;

source/ls_std/logic/State.cpp

@@ -3,19 +3,19 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-05
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
 #include <ls_std/logic/State.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::logic::State::State(const ls::std::logic::StateId& _id) : ls::std::core::Class("State")
+ls::std::logic::State::State(const ls::std::core::type::StateId& _id) : ls::std::core::Class("State")
 {
   this->_assignStateId(_id);
 }
 
-bool ls::std::logic::State::addStateConnection(const ls::std::logic::StateConnectionId &_connectionId, const ::std::shared_ptr<ls::std::logic::State> &_connectedState)
+bool ls::std::logic::State::addStateConnection(const ls::std::core::type::StateConnectionId &_connectionId, const ::std::shared_ptr<ls::std::logic::State> &_connectedState)
 {
   bool added{};
   ::std::shared_ptr<ls::std::logic::StateConnection> connection{};
@@ -57,27 +57,27 @@ void ls::std::logic::State::clearConnections()
   this->_clearConnections();
 }
 
-std::unordered_map<ls::std::logic::StateConnectionId, std::shared_ptr<ls::std::logic::StateConnection>> ls::std::logic::State::getConnectedStates()
+std::unordered_map<ls::std::core::type::StateConnectionId, std::shared_ptr<ls::std::logic::StateConnection>> ls::std::logic::State::getConnectedStates()
 {
   return this->connectedStates;
 }
 
-ls::std::logic::StateId ls::std::logic::State::getId()
+ls::std::core::type::StateId ls::std::logic::State::getId()
 {
   return this->id;
 }
 
-bool ls::std::logic::State::hasConnection(const ls::std::logic::StateConnectionId &_connectionId)
+bool ls::std::logic::State::hasConnection(const ls::std::core::type::StateConnectionId &_connectionId)
 {
   return this->_hasConnection(_connectionId);
 }
 
-void ls::std::logic::State::setId(const ls::std::logic::StateId& _id)
+void ls::std::logic::State::setId(const ls::std::core::type::StateId& _id)
 {
   this->_assignStateId(_id);
 }
 
-void ls::std::logic::State::_assignStateId(const ls::std::logic::StateId &_id)
+void ls::std::logic::State::_assignStateId(const ls::std::core::type::StateId &_id)
 {
   if (_id.empty())
   {
@@ -92,7 +92,7 @@ void ls::std::logic::State::_clearConnections()
   this->connectedStates.clear();
 }
 
-bool ls::std::logic::State::_hasConnection(const ls::std::logic::StateConnectionId &_connectionId)
+bool ls::std::logic::State::_hasConnection(const ls::std::core::type::StateConnectionId &_connectionId)
 {
   return this->connectedStates.find(_connectionId) != this->connectedStates.end();
 }

source/ls_std/logic/StateConnection.cpp

@@ -3,25 +3,25 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-10
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
 #include <ls_std/logic/StateConnection.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::logic::StateConnection::StateConnection(const ls::std::logic::StateConnectionId& _connectionId, const ls::std::logic::StateId& _stateId) : ls::std::core::Class("StateConnection")
+ls::std::logic::StateConnection::StateConnection(const ls::std::core::type::StateConnectionId& _connectionId, const ls::std::core::type::StateId& _stateId) : ls::std::core::Class("StateConnection")
 {
   this->_assignConnectionId(_connectionId);
   this->_assignStateId(_stateId);
 }
 
-ls::std::logic::StateConnectionId ls::std::logic::StateConnection::getConnectionId()
+ls::std::core::type::StateConnectionId ls::std::logic::StateConnection::getConnectionId()
 {
   return this->connectionId;
 }
 
-ls::std::logic::StateId ls::std::logic::StateConnection::getStateId()
+ls::std::core::type::StateId ls::std::logic::StateConnection::getStateId()
 {
   return this->stateId;
 }
@@ -31,12 +31,12 @@ bool ls::std::logic::StateConnection::isPassable() const
   return this->condition;
 }
 
-void ls::std::logic::StateConnection::setConnectionId(const ls::std::logic::StateConnectionId& _connectionId)
+void ls::std::logic::StateConnection::setConnectionId(const ls::std::core::type::StateConnectionId& _connectionId)
 {
   this->_assignConnectionId(_connectionId);
 }
 
-void ls::std::logic::StateConnection::setStateId(const ls::std::logic::StateId& _stateId)
+void ls::std::logic::StateConnection::setStateId(const ls::std::core::type::StateId& _stateId)
 {
   this->_assignStateId(_stateId);
 }
@@ -46,7 +46,7 @@ void ls::std::logic::StateConnection::updatePassCondition(bool _condition)
   this->condition = _condition;
 }
 
-void ls::std::logic::StateConnection::_assignConnectionId(const ls::std::logic::StateConnectionId &_connectionId)
+void ls::std::logic::StateConnection::_assignConnectionId(const ls::std::core::type::StateConnectionId &_connectionId)
 {
   if (_connectionId.empty())
   {
@@ -56,7 +56,7 @@ void ls::std::logic::StateConnection::_assignConnectionId(const ls::std::logic::
   this->connectionId = _connectionId;
 }
 
-void ls::std::logic::StateConnection::_assignStateId(const ls::std::logic::StateId &_stateId)
+void ls::std::logic::StateConnection::_assignStateId(const ls::std::core::type::StateId &_stateId)
 {
   if (_stateId.empty())
   {

source/ls_std/logic/StateMachine.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-05
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -39,7 +39,7 @@ std::shared_ptr<ls::std::logic::State> ls::std::logic::StateMachine::getCurrentS
   return this->currentState;
 }
 
-std::vector<ls::std::logic::StateId> ls::std::logic::StateMachine::getMemory()
+std::vector<ls::std::core::type::StateId> ls::std::logic::StateMachine::getMemory()
 {
   return this->memory;
 }
@@ -49,19 +49,19 @@ std::string ls::std::logic::StateMachine::getName()
   return this->name;
 }
 
-std::unordered_map<ls::std::logic::StateId, std::shared_ptr<ls::std::logic::State>> ls::std::logic::StateMachine::getStates()
+std::unordered_map<ls::std::core::type::StateId, std::shared_ptr<ls::std::logic::State>> ls::std::logic::StateMachine::getStates()
 {
   return this->states;
 }
 
-bool ls::std::logic::StateMachine::hasState(const ls::std::logic::StateId &_id)
+bool ls::std::logic::StateMachine::hasState(const ls::std::core::type::StateId &_id)
 {
   return this->_hasState(_id);
 }
 
 bool ls::std::logic::StateMachine::proceed()
 {
-  ::std::vector<ls::std::logic::StateId> nextValidStates = this->_getNextValidStates();
+  ::std::vector<ls::std::core::type::StateId> nextValidStates = this->_getNextValidStates();
   bool onlyOneWayToGo = nextValidStates.size() == 1;
 
   if (onlyOneWayToGo)
@@ -73,7 +73,7 @@ bool ls::std::logic::StateMachine::proceed()
   return onlyOneWayToGo;
 }
 
-void ls::std::logic::StateMachine::setMemory(const ::std::vector<ls::std::logic::StateId>& _memory)
+void ls::std::logic::StateMachine::setMemory(const ::std::vector<ls::std::core::type::StateId>& _memory)
 {
   this->_assignMemory(_memory);
 }
@@ -83,7 +83,7 @@ void ls::std::logic::StateMachine::setName(const ::std::string& _name)
   this->_assignName(_name);
 }
 
-bool ls::std::logic::StateMachine::setStartState(const ls::std::logic::StateId &_id)
+bool ls::std::logic::StateMachine::setStartState(const ls::std::core::type::StateId &_id)
 {
   bool startStateSet{};
 
@@ -104,7 +104,7 @@ bool ls::std::logic::StateMachine::setStartState(const ls::std::logic::StateId &
   return startStateSet;
 }
 
-void ls::std::logic::StateMachine::_assignMemory(const ::std::vector<ls::std::logic::StateId> &_memory)
+void ls::std::logic::StateMachine::_assignMemory(const ::std::vector<ls::std::core::type::StateId> &_memory)
 {
   if (_memory.empty())
   {
@@ -124,9 +124,9 @@ void ls::std::logic::StateMachine::_assignName(const ::std::string &_name)
   this->name = _name;
 }
 
-std::vector<ls::std::logic::StateId> ls::std::logic::StateMachine::_getNextValidStates()
+std::vector<ls::std::core::type::StateId> ls::std::logic::StateMachine::_getNextValidStates()
 {
-  ::std::vector<ls::std::logic::StateId> validStates{};
+  ::std::vector<ls::std::core::type::StateId> validStates{};
 
   for (const auto &state : this->currentState->getConnectedStates())
   {
@@ -139,12 +139,12 @@ std::vector<ls::std::logic::StateId> ls::std::logic::StateMachine::_getNextValid
   return validStates;
 }
 
-void ls::std::logic::StateMachine::_remember(const ls::std::logic::StateId &_id)
+void ls::std::logic::StateMachine::_remember(const ls::std::core::type::StateId &_id)
 {
   this->memory.push_back(_id);
 }
 
-bool ls::std::logic::StateMachine::_hasState(const ls::std::logic::StateId &_id)
+bool ls::std::logic::StateMachine::_hasState(const ls::std::core::type::StateId &_id)
 {
   return this->states.find(_id) != this->states.end();
 }

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -16,13 +16,13 @@ ls::std::logic::SerializableJsonState::SerializableJsonState(const ::std::shared
   this->_assignValue(_value);
 }
 
-ls::std::core::byte_field ls::std::logic::SerializableJsonState::marshal()
+ls::std::core::type::byte_field ls::std::logic::SerializableJsonState::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls::std::logic::SerializableJsonState::unmarshal(const ls::std::core::byte_field &_data)
+void ls::std::logic::SerializableJsonState::unmarshal(const ls::std::core::type::byte_field &_data)
 {
   this->jsonObject = nlohmann::json::parse(_data);
 

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -15,13 +15,13 @@ ls::std::logic::SerializableJsonStateConnection::SerializableJsonStateConnection
   this->_assignValue(_value);
 }
 
-ls::std::core::byte_field ls::std::logic::SerializableJsonStateConnection::marshal()
+ls::std::core::type::byte_field ls::std::logic::SerializableJsonStateConnection::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls::std::logic::SerializableJsonStateConnection::unmarshal(const ls::std::core::byte_field &_data)
+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);

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-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -16,13 +16,13 @@ ls::std::logic::SerializableJsonStateMachine::SerializableJsonStateMachine(const
   this->_assignValue(_value);
 }
 
-ls::std::core::byte_field ls::std::logic::SerializableJsonStateMachine::marshal()
+ls::std::core::type::byte_field ls::std::logic::SerializableJsonStateMachine::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls::std::logic::SerializableJsonStateMachine::unmarshal(const ls::std::core::byte_field &_data)
+void ls::std::logic::SerializableJsonStateMachine::unmarshal(const ls::std::core::type::byte_field &_data)
 {
   this->jsonObject = nlohmann::json::parse(_data);
 

test/cases/boxing/LongTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-09
+ * Changed:         2022-05-12
  *
  * */
 
@@ -41,7 +41,7 @@ namespace
   TEST_F(LongTest, operator_assignment_with_value)
   {
     ls::std::boxing::Long x{13};
-    x = (ls::std::core::long_type) 3;
+    x = (ls::std::core::type::long_type) 3;
 
     ASSERT_EQ(3, x);
   }
@@ -68,7 +68,7 @@ namespace
   TEST_F(LongTest, operator_add_with_value)
   {
     ls::std::boxing::Long x{13};
-    ASSERT_EQ(20, x + (ls::std::core::long_type) 7);
+    ASSERT_EQ(20, x + (ls::std::core::type::long_type) 7);
   }
 
   TEST_F(LongTest, operator_mul_with_reference)
@@ -82,7 +82,7 @@ namespace
   TEST_F(LongTest, operator_mul_with_value)
   {
     ls::std::boxing::Long x{3};
-    ASSERT_EQ(21, x * (ls::std::core::long_type) 7);
+    ASSERT_EQ(21, x * (ls::std::core::type::long_type) 7);
   }
 
   TEST_F(LongTest, operator_sub_with_reference)
@@ -96,7 +96,7 @@ namespace
   TEST_F(LongTest, operator_sub_with_value)
   {
     ls::std::boxing::Long x{51};
-    ASSERT_EQ(34, x - (ls::std::core::long_type) 17);
+    ASSERT_EQ(34, x - (ls::std::core::type::long_type) 17);
   }
 
   TEST_F(LongTest, operator_div_with_reference)
@@ -110,7 +110,7 @@ namespace
   TEST_F(LongTest, operator_div_with_value)
   {
     ls::std::boxing::Long x{81};
-    ASSERT_EQ(9, x / (ls::std::core::long_type) 9);
+    ASSERT_EQ(9, x / (ls::std::core::type::long_type) 9);
   }
 
   TEST_F(LongTest, operator_div_by_zero_with_reference)
@@ -135,7 +135,7 @@ namespace
                    try
                    {
                      ls::std::boxing::Long x{9};
-                     x = x / (ls::std::core::long_type) 0;
+                     x = x / (ls::std::core::type::long_type) 0;
                    } catch (const ls::std::core::IllegalArithmeticOperationException &_exception)
                    {
                      throw;
@@ -154,7 +154,7 @@ namespace
   TEST_F(LongTest, operator_mod_with_value)
   {
     ls::std::boxing::Long x{85};
-    ASSERT_EQ(4, x % (ls::std::core::long_type) 9);
+    ASSERT_EQ(4, x % (ls::std::core::type::long_type) 9);
   }
 
   // compound operators
@@ -171,7 +171,7 @@ namespace
   TEST_F(LongTest, operator_add_equals_with_value)
   {
     ls::std::boxing::Long x{4};
-    x += (ls::std::core::long_type) 2;
+    x += (ls::std::core::type::long_type) 2;
 
     ASSERT_EQ(6, x);
   }
@@ -188,7 +188,7 @@ namespace
   TEST_F(LongTest, operator_sub_equals_with_value)
   {
     ls::std::boxing::Long x{14};
-    x -= (ls::std::core::long_type) 2;
+    x -= (ls::std::core::type::long_type) 2;
 
     ASSERT_EQ(12, x);
   }
@@ -205,7 +205,7 @@ namespace
   TEST_F(LongTest, operator_mul_equals_with_value)
   {
     ls::std::boxing::Long x{6};
-    x *= (ls::std::core::long_type) 3;
+    x *= (ls::std::core::type::long_type) 3;
 
     ASSERT_EQ(18, x);
   }
@@ -222,7 +222,7 @@ namespace
   TEST_F(LongTest, operator_div_equals_with_value)
   {
     ls::std::boxing::Long x{12};
-    x /= (ls::std::core::long_type) 3;
+    x /= (ls::std::core::type::long_type) 3;
 
     ASSERT_EQ(4, x);
   }
@@ -249,7 +249,7 @@ namespace
                    try
                    {
                      ls::std::boxing::Long x{9};
-                     x = x /= (ls::std::core::long_type) 0;
+                     x = x /= (ls::std::core::type::long_type) 0;
                    } catch (const ls::std::core::IllegalArithmeticOperationException &_exception)
                    {
                      throw;
@@ -270,7 +270,7 @@ namespace
   TEST_F(LongTest, operator_equals_with_value)
   {
     ls::std::boxing::Long x{12};
-    ASSERT_TRUE(x == (ls::std::core::long_type) 12);
+    ASSERT_TRUE(x == (ls::std::core::type::long_type) 12);
   }
 
   TEST_F(LongTest, operator_not_equals_with_reference)
@@ -284,7 +284,7 @@ namespace
   TEST_F(LongTest, operator_not_equals_with_value)
   {
     ls::std::boxing::Long x{12};
-    ASSERT_TRUE(x != (ls::std::core::long_type) 3);
+    ASSERT_TRUE(x != (ls::std::core::type::long_type) 3);
   }
 
   TEST_F(LongTest, operator_greater_than_with_reference)
@@ -298,7 +298,7 @@ namespace
   TEST_F(LongTest, operator_greater_than_with_value)
   {
     ls::std::boxing::Long x{12};
-    ASSERT_TRUE(x > (ls::std::core::long_type) 3);
+    ASSERT_TRUE(x > (ls::std::core::type::long_type) 3);
   }
 
   TEST_F(LongTest, operator_greater_than_equals_with_reference)
@@ -312,7 +312,7 @@ namespace
   TEST_F(LongTest, operator_greater_than_equals_with_value)
   {
     ls::std::boxing::Long x{12};
-    ASSERT_TRUE(x >= (ls::std::core::long_type) 12);
+    ASSERT_TRUE(x >= (ls::std::core::type::long_type) 12);
   }
 
   TEST_F(LongTest, operator_less_than_with_reference)
@@ -328,7 +328,7 @@ namespace
     ls::std::boxing::Long x{10};
     ls::std::boxing::Long y{12};
 
-    ASSERT_TRUE(x < (ls::std::core::long_type) 12);
+    ASSERT_TRUE(x < (ls::std::core::type::long_type) 12);
   }
 
   TEST_F(LongTest, operator_less_than_equals_with_reference)
@@ -342,7 +342,7 @@ namespace
   TEST_F(LongTest, operator_less_than_equals_with_value)
   {
     ls::std::boxing::Long x{10};
-    ASSERT_TRUE(x <= (ls::std::core::long_type) 10);
+    ASSERT_TRUE(x <= (ls::std::core::type::long_type) 10);
   }
 
   // logical operators
@@ -364,7 +364,7 @@ namespace
   TEST_F(LongTest, operator_and_with_value)
   {
     ls::std::boxing::Long x{1};
-    ASSERT_TRUE(x && (ls::std::core::long_type) 1);
+    ASSERT_TRUE(x && (ls::std::core::type::long_type) 1);
   }
 
   TEST_F(LongTest, operator_and_with_boolean)
@@ -384,7 +384,7 @@ namespace
   TEST_F(LongTest, operator_or_with_value)
   {
     ls::std::boxing::Long x{};
-    ASSERT_TRUE(x || (ls::std::core::long_type) 1);
+    ASSERT_TRUE(x || (ls::std::core::type::long_type) 1);
   }
 
   TEST_F(LongTest, operator_or_with_boolean)

test/cases/event/EventManagerTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-09
+ * Changed:         2022-05-12
  *
  * */
 
@@ -212,8 +212,8 @@ namespace
   TEST_F(EventManagerTest, production_example)
   {
     std::string news, expectedNews{};
-    ls::std::event::event_id seriousNewsEventId = ls_std_test::SeriousNewsEvent{""}.getId();
-    ls::std::event::event_id gossipNewsEventId = ls_std_test::GossipNewsEvent{""}.getId();
+    ls::std::core::type::event_id seriousNewsEventId = ls_std_test::SeriousNewsEvent{""}.getId();
+    ls::std::core::type::event_id gossipNewsEventId = ls_std_test::GossipNewsEvent{""}.getId();
 
     // create event handler
 

test/cases/event/EventTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-09
+ * Changed:         2022-05-12
  *
  * */
 
@@ -53,8 +53,8 @@ namespace
     ls::std::event::Event event{"TMP_ID"};
     ASSERT_TRUE(event.getParameterList().empty());
 
-    ASSERT_TRUE(event.addParameter(ls::std::event::event_parameter("key", "yes")));
-    ASSERT_TRUE(event.addParameter(ls::std::event::event_parameter("facing_door", "yes")));
+    ASSERT_TRUE(event.addParameter(ls::std::core::type::event_parameter("key", "yes")));
+    ASSERT_TRUE(event.addParameter(ls::std::core::type::event_parameter("facing_door", "yes")));
   }
 
   TEST_F(EventTest, addParameter_element_already_exists)
@@ -62,15 +62,15 @@ namespace
     ls::std::event::Event event{"TMP_ID"};
     ASSERT_TRUE(event.getParameterList().empty());
 
-    ASSERT_TRUE(event.addParameter(ls::std::event::event_parameter("key", "yes")));
-    ASSERT_FALSE(event.addParameter(ls::std::event::event_parameter("key", "yes")));
+    ASSERT_TRUE(event.addParameter(ls::std::core::type::event_parameter("key", "yes")));
+    ASSERT_FALSE(event.addParameter(ls::std::core::type::event_parameter("key", "yes")));
   }
 
   TEST_F(EventTest, clearParameterList)
   {
     ls::std::event::Event event{"OPEN_DOOR_EVENT"};
-    event.addParameter(ls::std::event::event_parameter("key", "yes"));
-    event.addParameter(ls::std::event::event_parameter("facing_door", "yes"));
+    event.addParameter(ls::std::core::type::event_parameter("key", "yes"));
+    event.addParameter(ls::std::core::type::event_parameter("facing_door", "yes"));
     ASSERT_EQ(2, event.getParameterList().size());
 
     event.clearParameterList();
@@ -95,8 +95,8 @@ namespace
     ls::std::event::Event event{"OPEN_DOOR_EVENT"};
     ASSERT_TRUE(event.getParameterList().empty());
 
-    event.addParameter(ls::std::event::event_parameter("key", "yes"));
-    event.addParameter(ls::std::event::event_parameter("facing_door", "yes"));
+    event.addParameter(ls::std::core::type::event_parameter("key", "yes"));
+    event.addParameter(ls::std::core::type::event_parameter("facing_door", "yes"));
 
     ASSERT_TRUE(event.removeParameter("key"));
     ASSERT_TRUE(event.removeParameter("facing_door"));

test/cases/event/serialization/SerializableJsonEventTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-20
- * Changed:         2022-05-09
+ * Changed:         2022-05-12
  *
  * */
 
@@ -43,12 +43,12 @@ namespace
   TEST_F(SerializableJsonEventTest, marshal)
   {
     ls::std::event::Event event{"OPEN_DOOR_EVENT"};
-    event.addParameter(ls::std::event::event_parameter{"key_available", "true"});
-    event.addParameter(ls::std::event::event_parameter{"door_id", "16675"});
+    event.addParameter(ls::std::core::type::event_parameter{"key_available", "true"});
+    event.addParameter(ls::std::core::type::event_parameter{"door_id", "16675"});
 
     ls::std::event::SerializableJsonEvent serializable{std::make_shared<ls::std::event::Event>(event)};
 
-    ls::std::core::byte_field data = serializable.marshal();
+    ls::std::core::type::byte_field data = serializable.marshal();
     ASSERT_FALSE(data.empty());
     std::string expectedString = R"({"id":"OPEN_DOOR_EVENT","parameterList":{"door_id":["door_id","16675"],"key_available":["key_available","true"]}})";
     ASSERT_STREQ(expectedString.c_str(), data.c_str());
@@ -62,7 +62,7 @@ namespace
 
     serializable.unmarshal(jsonString);
     ASSERT_STREQ("OPEN_DOOR_EVENT", serializable.getValue()->getId().c_str());
-    ls::std::event::event_parameter_list parameterList = serializable.getValue()->getParameterList();
+    ls::std::core::type::event_parameter_list parameterList = serializable.getValue()->getParameterList();
 
     ASSERT_FALSE(parameterList.empty());
     ASSERT_EQ(2, parameterList.size());

test/cases/io/FileReaderTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-18
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -50,7 +50,7 @@ namespace
     std::string expectedUnix = "Hello!" + ls::std::io::NewLine::getUnixNewLine();
     std::string expectedWindows = "Hello!" + ls::std::io::NewLine::getWindowsNewLine();
 
-    ls::std::core::byte_field content = reader.read();
+    ls::std::core::type::byte_field content = reader.read();
     ASSERT_TRUE(content == expectedUnix || content == expectedWindows);
   }
 
@@ -64,7 +64,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::core::byte_field content = reader.read();
+                     ls::std::core::type::byte_field content = reader.read();
                    }
                    catch (const ls::std::core::FileOperationException &_exception)
                    {
@@ -80,7 +80,7 @@ namespace
     std::string expectedUnix = "Hello!" + ls::std::io::NewLine::getUnixNewLine();
     std::string expectedWindows = "Hello!" + ls::std::io::NewLine::getWindowsNewLine();
 
-    ls::std::core::byte_field content = reader.read();
+    ls::std::core::type::byte_field content = reader.read();
     ASSERT_TRUE(content == expectedUnix || content == expectedWindows);
 
     ls::std::io::File anotherFile{TestHelper::getResourcesFolderLocation() + "list_test/bla.txt"};

test/cases/io/StorableFileTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -38,7 +38,7 @@ namespace
   TEST_F(StorableFileTest, load)
   {
     ls::std::io::StorableFile storableFile{this->fileLocation};
-    ls::std::core::byte_field content = storableFile.load();
+    ls::std::core::type::byte_field content = storableFile.load();
 
     std::string expectedUnix = "Hello!" + ls::std::io::NewLine::getUnixNewLine();
     std::string expectedWindows = "Hello!" + ls::std::io::NewLine::getWindowsNewLine();
@@ -49,7 +49,7 @@ namespace
   TEST_F(StorableFileTest, reset)
   {
     ls::std::io::StorableFile storableFile{this->fileLocation};
-    ls::std::core::byte_field content = storableFile.load();
+    ls::std::core::type::byte_field content = storableFile.load();
 
     std::string expectedUnix = "Hello!" + ls::std::io::NewLine::getUnixNewLine();
     std::string expectedWindows = "Hello!" + ls::std::io::NewLine::getWindowsNewLine();
@@ -75,11 +75,11 @@ namespace
     file.createNewFile();
 
     ls::std::io::StorableFile storableFile{path};
-    ls::std::core::byte_field textUnix = "Testing save method!" + ls::std::io::NewLine::getUnixNewLine();
-    ls::std::core::byte_field textWindows = "Testing save method!" + ls::std::io::NewLine::getWindowsNewLine();
+    ls::std::core::type::byte_field textUnix = "Testing save method!" + ls::std::io::NewLine::getUnixNewLine();
+    ls::std::core::type::byte_field textWindows = "Testing save method!" + ls::std::io::NewLine::getWindowsNewLine();
 
     storableFile.save(textUnix);
-    ls::std::core::byte_field content = storableFile.load();
+    ls::std::core::type::byte_field content = storableFile.load();
     ASSERT_TRUE(content == textUnix || content == textWindows);
 
     file.remove();

test/cases/io/kv/KvParserTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -50,7 +50,7 @@ namespace
   {
     std::shared_ptr<ls::std::io::KvDocument> document = std::make_shared<ls::std::io::KvDocument>();
     ls::std::io::KvParser parser{document};
-    ls::std::core::byte_field data = "# starting comment\n\nport=8080; # some comment\nhost=localhost;\nservice-name=deamon;";
+    ls::std::core::type::byte_field data = "# starting comment\n\nport=8080; # some comment\nhost=localhost;\nservice-name=deamon;";
     parser.parse(data);
 
     ASSERT_EQ(3, document->getPairs().size());

test/cases/io/xml/XmlParserTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -20,11 +20,11 @@ namespace
       XmlParserTest() = default;
       ~XmlParserTest() override = default;
 
-      static ls::std::core::byte_field readXmlStateMachine()
+      static ls::std::core::type::byte_field readXmlStateMachine()
       {
         std::string xmlPath = TestHelper::getResourcesFolderLocation() + "state_machine_test.xml";
         ls::std::io::File file{xmlPath};
-        ls::std::core::byte_field data = ls::std::io::FileReader{file}.read();
+        ls::std::core::type::byte_field data = ls::std::io::FileReader{file}.read();
 
         return data;
       }
@@ -58,7 +58,7 @@ namespace
     std::list<std::shared_ptr<ls::std::io::XmlNode>> children, statesChildren, memoryChildren, connectionChildren{};
     std::list<std::shared_ptr<ls::std::io::XmlAttribute>> attributes{};
 
-    ls::std::core::byte_field data = readXmlStateMachine();
+    ls::std::core::type::byte_field data = readXmlStateMachine();
     xmlParser.parse(data);
 
     // check declaration

test/cases/logic/StateMachineTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-09
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -172,7 +172,7 @@ namespace
   TEST_F(StateMachineTest, setMemory_no_memory)
   {
     ls::std::logic::StateMachine stateMachine{"test_machine"};
-    std::vector<ls::std::logic::StateId> memory{};
+    std::vector<ls::std::core::type::StateId> memory{};
 
     EXPECT_THROW({
                    try

test/cases/logic/serialization/SerializableJsonStateTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-15
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -47,7 +47,7 @@ namespace
     x->addStateConnection(std::make_shared<ls::std::logic::StateConnection>("AC", "C"));
 
     ls::std::logic::SerializableJsonState serializable{x};
-    ls::std::core::byte_field jsonString = serializable.marshal();
+    ls::std::core::type::byte_field jsonString = serializable.marshal();
 
     ASSERT_TRUE(!jsonString.empty());
     std::string expectedJson = R"({"connectedStates":{"AB":{"condition":false,"connectionId":"AB","stateId":"B"},"AC":{"condition":false,"connectionId":"AC","stateId":"C"}},"id":"A"})";
@@ -90,7 +90,7 @@ namespace
     x->addStateConnection(std::make_shared<ls::std::logic::StateConnection>("AC", "C"));
 
     ls::std::logic::SerializableJsonState serializable{x};
-    ls::std::core::byte_field jsonString = serializable.marshal();
+    ls::std::core::type::byte_field jsonString = serializable.marshal();
 
     std::string expectedJson = R"({"connectedStates":{"AB":{"condition":false,"connectionId":"AB","stateId":"B"},"AC":{"condition":false,"connectionId":"AC","stateId":"C"}},"id":"A"})";
     ASSERT_STREQ(expectedJson.c_str(), jsonString.c_str());

test/classes/event/GossipNewsEvent.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-08
+ * Changed:         2022-05-12
  *
  * */
 
@@ -11,6 +11,6 @@
 
 ls_std_test::GossipNewsEvent::GossipNewsEvent(const std::string &_news) : ls::std::event::Event("GossipNewsEvent")
 {
-  ls::std::event::event_parameter newsParameter = std::make_pair("news", _news);
+  ls::std::core::type::event_parameter newsParameter = std::make_pair("news", _news);
   this->addParameter(newsParameter);
 }

test/classes/event/SeriousNewsEvent.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-08
+ * Changed:         2022-05-12
  *
  * */
 
@@ -11,6 +11,6 @@
 
 ls_std_test::SeriousNewsEvent::SeriousNewsEvent(const std::string &_news) : ls::std::event::Event("SeriousNewsEvent")
 {
-  ls::std::event::event_parameter newsParameter = std::make_pair("news", _news);
+  ls::std::core::type::event_parameter newsParameter = std::make_pair("news", _news);
   this->addParameter(newsParameter);
 }

test/classes/io/xml/XmlParserTestWrapper.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-18
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -12,12 +12,12 @@
 ls_std_test::XmlParserTestWrapper::XmlParserTestWrapper() : ls::std::io::XmlParser(nullptr)
 {}
 
-std::pair<std::string, std::string> ls_std_test::XmlParserTestWrapper::readAttribute(const ls::std::core::byte_field &_data)
+std::pair<std::string, std::string> ls_std_test::XmlParserTestWrapper::readAttribute(const ls::std::core::type::byte_field &_data)
 {
   return ls::std::io::XmlParser::_readAttribute_(_data);
 }
 
-std::list<std::pair<std::string, std::string>> ls_std_test::XmlParserTestWrapper::readAttributes(ls::std::core::byte_field _data)
+std::list<std::pair<std::string, std::string>> ls_std_test::XmlParserTestWrapper::readAttributes(ls::std::core::type::byte_field _data)
 {
   return ls::std::io::XmlParser::_readAttributes_(std::move(_data));
 }

test/classes/io/xml/XmlParserTestWrapper.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-18
- * Changed:         2022-05-11
+ * Changed:         2022-05-12
  *
  * */
 
@@ -21,8 +21,8 @@ namespace ls_std_test
       XmlParserTestWrapper();
       ~XmlParserTestWrapper() override = default;
 
-      static std::pair<std::string, std::string> readAttribute(const ls::std::core::byte_field &_data);
-      static std::list<std::pair<std::string, std::string>> readAttributes(ls::std::core::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);
   };
 }