Merge remote-tracking branch 'origin/dev' into dev

CMakeLists.txt

@@ -3,7 +3,7 @@
 ##########################################################
 
 cmake_minimum_required(VERSION 3.17)
-project(ls_std VERSION 2021.1.0)
+project(ls_std VERSION 1.0.0)
 
 ##########################################################
 # Options
@@ -67,45 +67,43 @@ set(SOURCE_FILES
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/FileOutputStream.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/logging/Logger.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/logging/LogLevel.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/boxing/SerializableJSONInteger.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/boxing/SerializableJSONLong.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/boxing/SerializableJSONString.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/boxing/SerializableJSONFloat.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/boxing/SerializableJSONDouble.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/boxing/SerializableJSONBoolean.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/boxing/SerializableJsonInteger.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/boxing/SerializableJsonLong.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/boxing/SerializableJsonString.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/boxing/SerializableJsonFloat.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/boxing/SerializableJsonDouble.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/boxing/SerializableJsonBoolean.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/logic/StateMachine.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/logic/State.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/logic/StateConnection.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/logic/SerializableJSONStateConnection.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/logic/SerializableJSONState.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/logic/SerializableJSONStateMachine.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XMLAttribute.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XMLNode.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/logic/SerializableJsonStateConnection.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/logic/SerializableJsonState.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/logic/SerializableJsonStateMachine.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlAttribute.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlNode.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/base/Version.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XMLDeclaration.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XMLDocument.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XMLReader.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XMLParserMock.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlDeclaration.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlDocument.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlReader.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/StandardOutputWriter.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/logic/Narrator.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/logic/IListener.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XMLParser.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/xml/XmlParser.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/Event.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/EventHandler.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/event/EventManager.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/event/SerializableJSONEvent.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KVPair.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KVDocument.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KVParser.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KVReader.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/SerializableJSONFactory.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/boxing/SerializableJSONBooleanFactory.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/boxing/SerializableJSONDoubleFactory.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/boxing/SerializableJSONFloatFactory.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/boxing/SerializableJSONIntegerFactory.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/boxing/SerializableJSONLongFactory.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/boxing/SerializableJSONStringFactory.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/event/SerializableJSONEventFactory.cpp)
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/serialization/json/event/SerializableJsonEvent.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KvPair.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KvDocument.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KvParser.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KvReader.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/SerializableJsonFactory.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/boxing/SerializableJsonBooleanFactory.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/boxing/SerializableJsonDoubleFactory.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/boxing/SerializableJsonFloatFactory.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/boxing/SerializableJsonIntegerFactory.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/boxing/SerializableJsonLongFactory.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/boxing/SerializableJsonStringFactory.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/json/event/SerializableJsonEventFactory.cpp)
 
 if (${LS_STD_BUILD_WITH_TESTS})
     set(TEST_FILES
@@ -126,32 +124,32 @@ if (${LS_STD_BUILD_WITH_TESTS})
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/StorableFileTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/FileOutputStreamTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/logging/LoggerTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/JSONTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/boxing/SerializableJSONIntegerTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/boxing/SerializableJSONLongTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/boxing/SerializableJSONStringTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/boxing/SerializableJSONFloatTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/boxing/SerializableJSONDoubleTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/boxing/SerializableJSONBooleanTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/JsonTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/boxing/SerializableJsonIntegerTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/boxing/SerializableJsonLongTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/boxing/SerializableJsonStringTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/boxing/SerializableJsonFloatTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/boxing/SerializableJsonDoubleTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/boxing/SerializableJsonBooleanTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/StateTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/StateMachineTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/StateConnectionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/logic/SerializableJSONStateConnectionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/logic/SerializableJSONStateTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/logic/SerializableJSONStateMachineTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/logic/SerializableJsonStateConnectionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/logic/SerializableJsonStateTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/logic/SerializableJsonStateMachineTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/TestDataFactory.hpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/TestDataFactory.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XMLAttributeTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XMLNodeTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlAttributeTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlNodeTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/base/VersionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XMLDeclarationTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XMLDocumentTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XMLReaderTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XMLParserMockTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlDeclarationTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlDocumentTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlReaderTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlParserTestWrapperTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/observer/TestDataCar.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/observer/TestDataMercedesCar.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/logic/NarratorTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XMLParserTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/xml/XmlParserTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/event/EventTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/NewsAgency.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/DailyNewsAgency.cpp
@@ -160,26 +158,31 @@ if (${LS_STD_BUILD_WITH_TESTS})
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/event/GossipNewsAgency.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/event/EventHandlerTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/event/EventManagerTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/event/SerializableJSONEventTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KVPairTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KVDocumentTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KVParserTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KVReaderTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/serialization/json/event/SerializableJsonEventTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KvPairTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KvDocumentTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KvParserTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KvReaderTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/SerializableFactoryTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/boxing/SerializableJSONBooleanFactoryTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/boxing/SerializableJSONDoubleFactoryTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/boxing/SerializableJSONFloatFactoryTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/boxing/SerializableJSONIntegerFactoryTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/boxing/SerializableJSONLongFactoryTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/boxing/SerializableJSONStringFactoryTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/event/SerializableJSONEventFactoryTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/boxing/SerializableJsonBooleanFactoryTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/boxing/SerializableJsonDoubleFactoryTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/boxing/SerializableJsonFloatFactoryTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/boxing/SerializableJsonIntegerFactoryTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/boxing/SerializableJsonLongFactoryTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/boxing/SerializableJsonStringFactoryTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/json/event/SerializableJsonEventFactoryTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/factory/SerializableTestFactory.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/EventNotHandledExceptionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/EventNotSubscribedExceptionTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/FileNotFoundExceptionTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/FileOperationExceptionTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/IllegalArgumentExceptionTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/IllegalArithmeticOperationExceptionTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/IncompleteJsonExceptionTest.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/NullPointerExceptionTest.cpp)
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/exception/NullPointerExceptionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/io/xml/XmlParserTestWrapper.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/base/LibraryVersionTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/logging/LogLevelTest.cpp)
 endif ()
 
 ##########################################################

README.md

@@ -1,4 +1,4 @@
-# Lynar Studios - Standard Library 2021.1.0 #
+# Lynar Studios - Standard Library 1.0.0 #
 
 This is a cross-platform standard library written in C++ which provides basic functionality and implementation, like:
  

include/ls_std/base/LibraryVersion.hpp

@@ -0,0 +1,23 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-05-02
+ * Changed:         2021-05-24
+ *
+ * */
+
+#ifndef LS_STD_LIBRARY_VERSION_HPP
+#define LS_STD_LIBRARY_VERSION_HPP
+
+#include <string>
+
+namespace ls_std
+{
+  static std::string getVersion()
+  {
+    return "1.0.0";
+  }
+}
+
+#endif

include/ls_std/event/Event.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2021-05-01
+ * Changed:         2021-05-24
  *
  * */
 
@@ -31,13 +31,13 @@ namespace ls_std
 
       // additional functionality
 
-      void addParameter(const ls_std::event_parameter &_eventParameter);
+      bool addParameter(const ls_std::event_parameter &_eventParameter);
       void clearParameterList();
       ls_std::event_id getId();
       ls_std::event_parameter_list getParameterList();
-      void removeParameter(const ls_std::event_parameter_id &_id);
+      bool removeParameter(const ls_std::event_parameter_id &_id);
       void setId(const ls_std::event_id &_id);
-      void setSerializable(std::shared_ptr<ls_std::ISerializable> _serializable);
+      void setSerializable(const std::shared_ptr<ls_std::ISerializable> &_serializable);
 
     private:
 
@@ -46,6 +46,7 @@ namespace ls_std
       std::shared_ptr<ls_std::ISerializable> serializable{};
 
       void _assignId(const ls_std::event_id &_id);
+      void _assignSerializable(const std::shared_ptr<ls_std::ISerializable> &_serializable);
       bool _hasParameter(const ls_std::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:         2021-04-23
+ * Changed:         2021-05-27
  *
  * */
 
@@ -23,7 +23,7 @@ namespace ls_std
   {
     public:
 
-      explicit EventHandler(ls_std::event_id _id);
+      explicit EventHandler(const ls_std::event_id& _id);
       ~EventHandler() override = default;
 
       ls_std::event_id getId();
@@ -31,6 +31,8 @@ namespace ls_std
     private:
 
       ls_std::event_id id{};
+
+      void _assignId(const ls_std::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:         2021-05-01
+ * Changed:         2021-05-27
  *
  * */
 
@@ -33,16 +33,17 @@ namespace ls_std
 
       // additional functionality
 
-      void addEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
+      bool addEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
       void fire(ls_std::Event _event);
-      void removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
+      bool hasEventHandler(const ls_std::event_id &_id);
+      bool removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
 
     private:
 
       std::map<ls_std::event_id, std::shared_ptr<ls_std::EventHandler>> eventHandlers{};
 
       bool _hasEventHandler(const ls_std::event_id &_id);
-      void _removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
+      bool _removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
   };
 }
 

include/ls_std/exception/EventNotHandledException.hpp

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

include/ls_std/exception/EventNotSubscribedException.hpp

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

include/ls_std/factory/serialization/json/SerializableJSONFactory.hpp → include/ls_std/factory/serialization/json/SerializableJsonFactory.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-24
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -18,12 +18,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONFactory : public ls_std::Class
+  class SerializableJsonFactory : public ls_std::Class
   {
     public:
 
-      SerializableJSONFactory();
-      ~SerializableJSONFactory() override = default;
+      SerializableJsonFactory();
+      ~SerializableJsonFactory() override = default;
 
       bool addFactory(const std::pair<std::string, std::shared_ptr<ls_std::IFactory>> &_factoryInsertion);
       std::shared_ptr<ls_std::Class> build(const std::string &_relatedObjectName);

include/ls_std/factory/serialization/json/boxing/SerializableJSONBooleanFactory.hpp → include/ls_std/factory/serialization/json/boxing/SerializableJsonBooleanFactory.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-23
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -15,12 +15,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONBooleanFactory : public ls_std::Class, public ls_std::IFactory
+  class SerializableJsonBooleanFactory : public ls_std::Class, public ls_std::IFactory
   {
     public:
 
-      SerializableJSONBooleanFactory();
-      ~SerializableJSONBooleanFactory() override = default;
+      SerializableJsonBooleanFactory();
+      ~SerializableJsonBooleanFactory() override = default;
 
       std::shared_ptr<ls_std::Class> build() override;
   };

include/ls_std/factory/serialization/json/boxing/SerializableJSONDoubleFactory.hpp → include/ls_std/factory/serialization/json/boxing/SerializableJsonDoubleFactory.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-24
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -15,12 +15,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONDoubleFactory : public ls_std::Class, public ls_std::IFactory
+  class SerializableJsonDoubleFactory : public ls_std::Class, public ls_std::IFactory
   {
     public:
 
-      SerializableJSONDoubleFactory();
-      ~SerializableJSONDoubleFactory() override = default;
+      SerializableJsonDoubleFactory();
+      ~SerializableJsonDoubleFactory() override = default;
 
       std::shared_ptr<ls_std::Class> build() override;
   };

include/ls_std/factory/serialization/json/boxing/SerializableJSONFloatFactory.hpp → include/ls_std/factory/serialization/json/boxing/SerializableJsonFloatFactory.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-24
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -15,12 +15,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONFloatFactory : public ls_std::Class, public ls_std::IFactory
+  class SerializableJsonFloatFactory : public ls_std::Class, public ls_std::IFactory
   {
     public:
 
-      SerializableJSONFloatFactory();
-      ~SerializableJSONFloatFactory() override = default;
+      SerializableJsonFloatFactory();
+      ~SerializableJsonFloatFactory() override = default;
 
       std::shared_ptr<ls_std::Class> build() override;
   };

include/ls_std/factory/serialization/json/boxing/SerializableJSONIntegerFactory.hpp → include/ls_std/factory/serialization/json/boxing/SerializableJsonIntegerFactory.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-24
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -15,12 +15,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONIntegerFactory : public ls_std::Class, public ls_std::IFactory
+  class SerializableJsonIntegerFactory : public ls_std::Class, public ls_std::IFactory
   {
     public:
 
-      SerializableJSONIntegerFactory();
-      ~SerializableJSONIntegerFactory() override = default;
+      SerializableJsonIntegerFactory();
+      ~SerializableJsonIntegerFactory() override = default;
 
       std::shared_ptr<ls_std::Class> build() override;
   };

include/ls_std/factory/serialization/json/boxing/SerializableJSONLongFactory.hpp → include/ls_std/factory/serialization/json/boxing/SerializableJsonLongFactory.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-24
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -15,12 +15,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONLongFactory : public ls_std::Class, public ls_std::IFactory
+  class SerializableJsonLongFactory : public ls_std::Class, public ls_std::IFactory
   {
     public:
 
-      SerializableJSONLongFactory();
-      ~SerializableJSONLongFactory() override = default;
+      SerializableJsonLongFactory();
+      ~SerializableJsonLongFactory() override = default;
 
       std::shared_ptr<ls_std::Class> build() override;
   };

include/ls_std/factory/serialization/json/boxing/SerializableJSONStringFactory.hpp → include/ls_std/factory/serialization/json/boxing/SerializableJsonStringFactory.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-24
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -15,12 +15,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONStringFactory : public ls_std::Class, public ls_std::IFactory
+  class SerializableJsonStringFactory : public ls_std::Class, public ls_std::IFactory
   {
     public:
 
-      SerializableJSONStringFactory();
-      ~SerializableJSONStringFactory() override = default;
+      SerializableJsonStringFactory();
+      ~SerializableJsonStringFactory() override = default;
 
       std::shared_ptr<ls_std::Class> build() override;
   };

include/ls_std/factory/serialization/json/event/SerializableJSONEventFactory.hpp → include/ls_std/factory/serialization/json/event/SerializableJsonEventFactory.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-30
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -15,12 +15,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONEventFactory : public ls_std::Class, public ls_std::IFactory
+  class SerializableJsonEventFactory : public ls_std::Class, public ls_std::IFactory
   {
     public:
 
-      SerializableJSONEventFactory();
-      ~SerializableJSONEventFactory() override = default;
+      SerializableJsonEventFactory();
+      ~SerializableJsonEventFactory() override = default;
 
       std::shared_ptr<ls_std::Class> build() override;
   };

include/ls_std/io/kv/KVParser.hpp

@@ -1,46 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-12-25
- * Changed:         2021-04-23
- *
- * */
-
-#ifndef LS_STD_KV_PARSER_HPP
-#define LS_STD_KV_PARSER_HPP
-
-#include <ls_std/base/Class.hpp>
-#include <ls_std/base/Types.hpp>
-#include "KVDocument.hpp"
-#include "KVParseData.hpp"
-#include <memory>
-
-namespace ls_std
-{
-  class KVParser : public ls_std::Class
-  {
-    public:
-
-      explicit KVParser(const std::shared_ptr<ls_std::KVDocument> &_document);
-      ~KVParser() override = default;
-
-      std::shared_ptr<ls_std::KVDocument> getDocument();
-      void parse(const ls_std::byte_field &_data);
-      void setDocument(const std::shared_ptr<ls_std::KVDocument> &_document);
-
-    private:
-
-      std::shared_ptr<ls_std::KVDocument> document{};
-
-      void _assignDocument(const std::shared_ptr<ls_std::KVDocument> &_document);
-      static bool _lineHasPair(ls_std::KVParseData _parseData);
-      void _parse(const ls_std::byte_field &_data);
-      void _parsePair(ls_std::KVParseData _parseData);
-      static ls_std::KVParseData _readLine(const ls_std::byte_field &_data, std::string::size_type _index);
-      static void _readLineWithUnixLineBreak(ls_std::KVParseData &_parseData);
-      static void _readLineWithWindowsLineBreak(ls_std::KVParseData &_parseData);
-  };
-}
-
-#endif

include/ls_std/io/kv/KVDocument.hpp → include/ls_std/io/kv/KvDocument.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -11,28 +11,28 @@
 #define LS_STD_KV_DOCUMENT_HPP
 
 #include <ls_std/base/Class.hpp>
-#include "KVPair.hpp"
-#include "KVTypes.hpp"
+#include "KvPair.hpp"
+#include "KvTypes.hpp"
 #include <map>
 
 namespace ls_std
 {
-  class KVDocument : public ls_std::Class
+  class KvDocument : public ls_std::Class
   {
     public:
 
-      KVDocument();
-      ~KVDocument() override = default;
+      KvDocument();
+      ~KvDocument() override = default;
 
-      bool addPair(ls_std::KVPair _pair);
+      bool addPair(ls_std::KvPair _pair);
       void clear();
-      std::map<ls_std::kv_key, ls_std::KVPair> getPairs();
+      std::map<ls_std::kv_key, ls_std::KvPair> getPairs();
       bool hasPair(const ls_std::kv_key &_key);
       void removePair(const ls_std::kv_key &_key);
 
     private:
 
-      std::map<ls_std::kv_key, ls_std::KVPair> pairs{};
+      std::map<ls_std::kv_key, ls_std::KvPair> pairs{};
 
       bool _hasPair(const ls_std::kv_key &_key);
   };

include/ls_std/io/kv/KVPair.hpp → include/ls_std/io/kv/KvPair.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -11,16 +11,16 @@
 #define LS_STD_KV_PAIR_HPP
 
 #include <ls_std/base/Class.hpp>
-#include "KVTypes.hpp"
+#include "KvTypes.hpp"
 
 namespace ls_std
 {
-  class KVPair : public ls_std::Class
+  class KvPair : public ls_std::Class
   {
     public:
 
-      explicit KVPair(const ls_std::kv_key &_key, ls_std::kv_value _value);
-      ~KVPair() override = default;
+      explicit KvPair(const ls_std::kv_key &_key, ls_std::kv_value _value);
+      ~KvPair() override = default;
 
       ls_std::kv_key getKey();
       ls_std::kv_value getValue();

include/ls_std/io/kv/KVParseData.hpp → include/ls_std/io/kv/KvParseParameter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -15,7 +15,7 @@
 
 namespace ls_std
 {
-  struct KVParseData
+  struct KvParseParameter
   {
     std::string::size_type index{};
     ls_std::String line{};

include/ls_std/io/kv/KvParser.hpp

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

include/ls_std/io/kv/KVReader.hpp → include/ls_std/io/kv/KvReader.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -12,18 +12,18 @@
 
 #include <ls_std/base/Class.hpp>
 #include <ls_std/io/IReader.hpp>
-#include <ls_std/io/kv/KVDocument.hpp>
+#include <ls_std/io/kv/KvDocument.hpp>
 #include <ls_std/io/File.hpp>
 #include <memory>
 
 namespace ls_std
 {
-  class KVReader : public ls_std::Class, public ls_std::IReader
+  class KvReader : public ls_std::Class, public ls_std::IReader
   {
     public:
 
-      explicit KVReader(const std::shared_ptr<ls_std::KVDocument> &_document, const std::string &_absolutePath);
-      ~KVReader() override = default;
+      explicit KvReader(const std::shared_ptr<ls_std::KvDocument> &_document, const std::string &_absolutePath);
+      ~KvReader() override = default;
 
       // implementation
 
@@ -31,16 +31,16 @@ namespace ls_std
 
       // additional functionality
 
-      std::shared_ptr<ls_std::KVDocument> getDocument();
-      void setDocument(const std::shared_ptr<ls_std::KVDocument> &_document);
+      std::shared_ptr<ls_std::KvDocument> getDocument();
+      void setDocument(const std::shared_ptr<ls_std::KvDocument> &_document);
       void setFile(const ls_std::File &_kvFile);
 
     private:
 
-      std::shared_ptr<ls_std::KVDocument> document{};
+      std::shared_ptr<ls_std::KvDocument> document{};
       ls_std::File kvFile;
 
-      void _assignDocument(const std::shared_ptr<ls_std::KVDocument> &_document);
+      void _assignDocument(const std::shared_ptr<ls_std::KvDocument> &_document);
       void _assignFile(ls_std::File _kvFile);
   };
 }

include/ls_std/io/logging/LogLevel.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -26,8 +26,14 @@ namespace ls_std
 
       operator unsigned char() const;
       ls_std::LogLevel &operator=(const ls_std::LogLevelValue &_value);
+      bool operator<(const ls_std::LogLevelValue &_value);
       bool operator<=(const ls_std::LogLevelValue &_value);
+      bool operator>(const ls_std::LogLevelValue &_value);
+      bool operator>=(const ls_std::LogLevelValue &_value);
+      bool operator==(const ls_std::LogLevelValue &_value);
 
+      void setLogLevel(const ls_std::LogLevelValue &_value);
+      void setLogLevel(const std::string &_value);
       std::string toString() const;
 
     private:
@@ -35,7 +41,9 @@ namespace ls_std
       std::unordered_map<uint8_t, std::string> level{};
       ls_std::LogLevelValue value{};
 
+      ls_std::LogLevelValue _getValueFromString(const std::string &_value);
       void _init();
+      bool _isValidLogLevelString(const std::string &_value);
   };
 }
 

include/ls_std/io/logging/LogLevelValue.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -14,7 +14,7 @@ namespace ls_std
 {
   enum LogLevelValue
   {
-    FATAL = 0, ERR, WARN, INFO, DEBUG, TRACE, OFF
+    FATAL = 0, ERR, WARN, INFO, DEBUG, TRACE
   };
 }
 

include/ls_std/io/xml/XMLDocument.hpp

@@ -1,40 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-27
- * Changed:         2021-05-01
- *
- * */
-
-#ifndef LS_STD_XML_DOCUMENT_HPP
-#define LS_STD_XML_DOCUMENT_HPP
-
-#include <memory>
-#include <ls_std/base/Class.hpp>
-#include "XMLNode.hpp"
-#include "XMLDeclaration.hpp"
-
-namespace ls_std
-{
-  class XMLDocument : public ls_std::Class
-  {
-    public:
-
-      XMLDocument();
-      ~XMLDocument() override = default;
-
-      std::shared_ptr<ls_std::XMLDeclaration> getDeclaration();
-      std::shared_ptr<ls_std::XMLNode> getRootElement();
-      void setDeclaration(const std::shared_ptr<ls_std::XMLDeclaration> &_declaration);
-      void setRootElement(const std::shared_ptr<ls_std::XMLNode> &_root);
-      std::string toXML();
-
-    private:
-
-      std::shared_ptr<ls_std::XMLDeclaration> declaration{};
-      std::shared_ptr<ls_std::XMLNode> rootElement{};
-  };
-}
-
-#endif

include/ls_std/io/xml/XMLNode.hpp

@@ -1,77 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-24
- * Changed:         2021-05-01
- *
- * */
-
-#ifndef LS_STD_XML_NODE_HPP
-#define LS_STD_XML_NODE_HPP
-
-#include <list>
-#include <memory>
-#include <ls_std/base/Class.hpp>
-#include "XMLAttribute.hpp"
-
-namespace ls_std
-{
-  class XMLNode : public ls_std::Class
-  {
-    public:
-
-      explicit XMLNode(std::string _name);
-      ~XMLNode() override = default;
-
-      bool addAttributeAfter(const std::shared_ptr<ls_std::XMLAttribute> &_attribute, const std::string &_name);
-      bool addAttributeBefore(const std::shared_ptr<ls_std::XMLAttribute> &_attribute, const std::string &_name);
-      bool addAttributeToBeginning(const std::shared_ptr<ls_std::XMLAttribute> &_attribute);
-      bool addAttributeToEnd(const std::shared_ptr<ls_std::XMLAttribute> &_attribute);
-      bool addChildAfter(const std::shared_ptr<ls_std::XMLNode> &_child, const std::shared_ptr<ls_std::XMLNode> &_search);
-      bool addChildBefore(const std::shared_ptr<ls_std::XMLNode> &_child, const std::shared_ptr<ls_std::XMLNode> &_search);
-      bool addChildToBeginning(const std::shared_ptr<ls_std::XMLNode> &_child);
-      bool addChildToEnd(const std::shared_ptr<ls_std::XMLNode> &_child);
-      void clearValue();
-      std::list<std::shared_ptr<ls_std::XMLAttribute>> getAttributes();
-      std::list<std::shared_ptr<ls_std::XMLNode>> getChildren();
-      std::list<std::shared_ptr<ls_std::XMLNode>> getChildren(const std::string &_name);
-      std::string getName();
-      std::string getValue();
-      bool hasAttribute(const std::string &_name);
-      bool hasChild(const std::string &_name);
-      bool hasChild(const std::shared_ptr<ls_std::XMLNode> &_child);
-      void removeFirstAttribute();
-      void removeLastAttribute();
-      void removeFirstChild();
-      void removeLastChild();
-      void setName(std::string _name);
-      void setValue(std::string _value);
-      std::string toXML();
-
-    protected:
-
-      std::string _toXML_(uint8_t _tabSize);
-
-    private:
-
-      std::list<std::shared_ptr<ls_std::XMLAttribute>> attributes{};
-      std::list<std::shared_ptr<ls_std::XMLNode>> children{};
-      std::string name{};
-      const static uint8_t TAB_SIZE{4};
-      std::string value{};
-
-      static std::string _getTab(uint8_t _tabSize);
-      bool _hasAttribute(const std::string &_name);
-      bool _hasChild(const std::shared_ptr<ls_std::XMLNode> &_child);
-      bool _hasChild(const std::string &_name);
-      std::string _toXMLAttributes();
-      std::string _toXMLChildren(uint8_t _tabSize);
-      std::string _toXMLCloseTag();
-      std::string _toXMLOpenTag();
-      std::string _toXMLOpenTagClose();
-      std::string _toXMLValue();
-  };
-}
-
-#endif

include/ls_std/io/xml/XMLAttribute.hpp → include/ls_std/io/xml/XmlAttribute.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-23
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -15,18 +15,18 @@
 
 namespace ls_std
 {
-  class XMLAttribute : public ls_std::Class
+  class XmlAttribute : public ls_std::Class
   {
     public:
 
-      explicit XMLAttribute(std::string _name);
-      ~XMLAttribute() override = default;
+      explicit XmlAttribute(std::string _name);
+      ~XmlAttribute() override = default;
 
       std::string getName();
       std::string getValue();
       void setName(std::string _name);
       void setValue(std::string _value);
-      std::string toXML();
+      std::string toXml();
 
     private:
 

include/ls_std/io/xml/XMLDeclaration.hpp → include/ls_std/io/xml/XmlDeclaration.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -11,16 +11,16 @@
 #define LS_STD_XML_DECLARATION_HPP
 
 #include <ls_std/base/Class.hpp>
-#include "XMLAttribute.hpp"
+#include "XmlAttribute.hpp"
 
 namespace ls_std
 {
-  class XMLDeclaration : public ls_std::Class
+  class XmlDeclaration : public ls_std::Class
   {
     public:
 
-      explicit XMLDeclaration(std::string _version);
-      ~XMLDeclaration() override = default;
+      explicit XmlDeclaration(std::string _version);
+      ~XmlDeclaration() override = default;
 
       std::string getEncoding();
       std::string getStandalone();
@@ -28,15 +28,15 @@ namespace ls_std
       void setEncoding(std::string _encoding);
       void setStandalone(std::string _standalone);
       void setVersion(std::string _version);
-      std::string toXML();
+      std::string toXml();
 
     private:
 
-      ls_std::XMLAttribute encoding{"encoding"};
-      ls_std::XMLAttribute standalone{"standalone"};
-      ls_std::XMLAttribute version{"version"};
+      ls_std::XmlAttribute encoding{"encoding"};
+      ls_std::XmlAttribute standalone{"standalone"};
+      ls_std::XmlAttribute version{"version"};
 
-      static std::string _toXMLAttribute(ls_std::XMLAttribute _attribute);
+      static std::string _toXmlAttribute(ls_std::XmlAttribute _attribute);
   };
 }
 

include/ls_std/io/xml/XmlDocument.hpp

@@ -0,0 +1,40 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-09-27
+ * Changed:         2021-05-02
+ *
+ * */
+
+#ifndef LS_STD_XML_DOCUMENT_HPP
+#define LS_STD_XML_DOCUMENT_HPP
+
+#include <memory>
+#include <ls_std/base/Class.hpp>
+#include "XmlNode.hpp"
+#include "XmlDeclaration.hpp"
+
+namespace ls_std
+{
+  class XmlDocument : public ls_std::Class
+  {
+    public:
+
+      XmlDocument();
+      ~XmlDocument() override = default;
+
+      std::shared_ptr<ls_std::XmlDeclaration> getDeclaration();
+      std::shared_ptr<ls_std::XmlNode> getRootElement();
+      void setDeclaration(const std::shared_ptr<ls_std::XmlDeclaration> &_declaration);
+      void setRootElement(const std::shared_ptr<ls_std::XmlNode> &_root);
+      std::string toXml();
+
+    private:
+
+      std::shared_ptr<ls_std::XmlDeclaration> declaration{};
+      std::shared_ptr<ls_std::XmlNode> rootElement{};
+  };
+}
+
+#endif

include/ls_std/io/xml/XmlNode.hpp

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

include/ls_std/io/xml/XMLParseMode.hpp → include/ls_std/io/xml/XmlParseMode.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-13
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -12,7 +12,7 @@
 
 namespace ls_std
 {
-  enum XMLParseMode
+  enum XmlParseMode
   {
     XML_PARSE_MODE_ANALYZE = 0, XML_PARSE_MODE_DECLARATION, XML_PARSE_MODE_OPENING_TAG, XML_PARSE_MODE_VALUE, XML_PARSE_MODE_CLOSING_TAG
   };

include/ls_std/io/xml/XMLParseData.hpp → include/ls_std/io/xml/XmlParseParameter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-17
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -12,14 +12,14 @@
 
 #include <cstdint>
 #include <memory>
-#include "XMLNode.hpp"
+#include "XmlNode.hpp"
 
 namespace ls_std
 {
-  struct XMLParseData
+  struct XmlParseParameter
   {
     uint8_t level{};
-    std::shared_ptr<ls_std::XMLNode> node{};
+    std::shared_ptr<ls_std::XmlNode> node{};
   };
 }
 

include/ls_std/io/xml/XMLParser.hpp → include/ls_std/io/xml/XmlParser.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-25
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -12,23 +12,23 @@
 
 #include <ls_std/base/Class.hpp>
 #include <ls_std/base/Types.hpp>
-#include "XMLDocument.hpp"
-#include "XMLParseMode.hpp"
-#include "XMLParseData.hpp"
+#include "XmlDocument.hpp"
+#include "XmlParseMode.hpp"
+#include "XmlParseParameter.hpp"
 #include <list>
 
 namespace ls_std
 {
-  class XMLParser : public ls_std::Class
+  class XmlParser : public ls_std::Class
   {
     public:
 
-      explicit XMLParser(const std::shared_ptr<ls_std::XMLDocument> &_document);
-      ~XMLParser() override = default;
+      explicit XmlParser(const std::shared_ptr<ls_std::XmlDocument> &_document);
+      ~XmlParser() override = default;
 
-      std::shared_ptr<ls_std::XMLDocument> getDocument();
+      std::shared_ptr<ls_std::XmlDocument> getDocument();
       void parse(const ls_std::byte_field &_data);
-      void setDocument(const std::shared_ptr<ls_std::XMLDocument> &_document);
+      void setDocument(const std::shared_ptr<ls_std::XmlDocument> &_document);
 
     protected:
 
@@ -38,15 +38,15 @@ namespace ls_std
     private:
 
       uint8_t currentLevel{};
-      std::shared_ptr<ls_std::XMLDocument> document{};
+      std::shared_ptr<ls_std::XmlDocument> document{};
       uint8_t maxLevel{};
-      ls_std::XMLParseMode mode{};
-      std::list<ls_std::XMLParseData> parseData{};
+      ls_std::XmlParseMode mode{};
+      std::list<ls_std::XmlParseParameter> parseParameters{};
 
       void _analyze(const ls_std::byte_field &_data, std::string::size_type _index);
-      void _assignDocument(const std::shared_ptr<ls_std::XMLDocument> &_document);
-      static std::shared_ptr<ls_std::XMLDeclaration> _createDeclaration(const std::list<std::pair<std::string, std::string>> &_attributes);
-      static std::shared_ptr<ls_std::XMLNode> _createNode(const std::list<std::pair<std::string, std::string>> &_attributes, const std::string &_name);
+      void _assignDocument(const std::shared_ptr<ls_std::XmlDocument> &_document);
+      static std::shared_ptr<ls_std::XmlDeclaration> _createDeclaration(const std::list<std::pair<std::string, std::string>> &_attributes);
+      static std::shared_ptr<ls_std::XmlNode> _createNode(const std::list<std::pair<std::string, std::string>> &_attributes, const std::string &_name);
       static std::pair<std::string, std::string> _findAttribute(const std::list<std::pair<std::string, std::string>> &_attributes, const std::string &_name);
       static size_t _findAttributeEndPosition(const ls_std::byte_field &_data);
       static ls_std::byte_field _getNextTagString(const ls_std::byte_field &_data, std::string::size_type _index);
@@ -55,7 +55,7 @@ namespace ls_std
       void _isOpeningTag(const ls_std::byte_field &_data, std::string::size_type _index);
       void _isValue(const ls_std::byte_field &_data, std::string::size_type _index);
       void _mergeNodes();
-      void _mergeChildrenToParentNode(const std::shared_ptr<ls_std::XMLNode> &_parent, std::list<ls_std::XMLParseData>::iterator &_iterator, uint8_t _parentLevel);
+      void _mergeChildrenToParentNode(const std::shared_ptr<ls_std::XmlNode> &_parent, std::list<ls_std::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel);
       void _mergeNodesOnCurrentLevel();
       void _parse(const ls_std::byte_field &_data);
       static std::pair<std::string, std::string> _parseAttribute(const ls_std::byte_field &_data);

include/ls_std/io/xml/XMLReader.hpp → include/ls_std/io/xml/XmlReader.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-08
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -11,21 +11,21 @@
 #define LS_STD_XML_READER_HPP
 
 #include <ls_std/base/Class.hpp>
-#include "XMLDocument.hpp"
+#include "XmlDocument.hpp"
 #include <ls_std/io/IReader.hpp>
 #include <ls_std/io/File.hpp>
-#include "XMLParseMode.hpp"
-#include "XMLParseData.hpp"
+#include "XmlParseMode.hpp"
+#include "XmlParseParameter.hpp"
 #include <list>
 
 namespace ls_std
 {
-  class XMLReader : public ls_std::Class, public ls_std::IReader
+  class XmlReader : public ls_std::Class, public ls_std::IReader
   {
     public:
 
-      explicit XMLReader(const std::shared_ptr<ls_std::XMLDocument> &_document, const std::string &_absolutePath);
-      ~XMLReader() override = default;
+      explicit XmlReader(const std::shared_ptr<ls_std::XmlDocument> &_document, const std::string &_absolutePath);
+      ~XmlReader() override = default;
 
       // implementation
 
@@ -33,16 +33,16 @@ namespace ls_std
 
       // additional functionality
 
-      std::shared_ptr<ls_std::XMLDocument> getDocument();
-      void setDocument(const std::shared_ptr<ls_std::XMLDocument> &_document);
+      std::shared_ptr<ls_std::XmlDocument> getDocument();
+      void setDocument(const std::shared_ptr<ls_std::XmlDocument> &_document);
       void setFile(const ls_std::File &_xmlFile);
 
     private:
 
-      std::shared_ptr<ls_std::XMLDocument> document{};
+      std::shared_ptr<ls_std::XmlDocument> document{};
       ls_std::File xmlFile;
 
-      void _assignDocument(const std::shared_ptr<ls_std::XMLDocument> &_document);
+      void _assignDocument(const std::shared_ptr<ls_std::XmlDocument> &_document);
       void _assignFile(ls_std::File _xmlFile);
   };
 }

include/ls_std/logic/IListener.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -14,12 +14,12 @@
 
 namespace ls_std
 {
-  class IListener : public ls_std::Class
+  class IListener
   {
     public:
 
-      IListener();
-      ~IListener() override = default;
+      IListener() = default;
+      ~IListener() = default;
 
       virtual void listen(const ls_std::Class &_info) = 0;
   };

include/ls_std/logic/Narrator.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2021-05-01
+ * Changed:         2021-05-27
  *
  * */
 
@@ -24,10 +24,10 @@ namespace ls_std
       Narrator();
       ~Narrator() override = default;
 
-      void addListener(const std::shared_ptr<ls_std::IListener> &_listener);
+      bool addListener(const std::shared_ptr<ls_std::IListener> &_listener);
       void clear();
       std::list<std::shared_ptr<ls_std::IListener>> getListeners();
-      void removeListener(const std::shared_ptr<ls_std::IListener> &_listener);
+      bool removeListener(const std::shared_ptr<ls_std::IListener> &_listener);
       void tell(const ls_std::Class &_info);
 
     private:

include/ls_std/logic/StateConnection.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-10
- * Changed:         2021-05-01
+ * Changed:         2021-05-27
  *
  * */
 
@@ -20,14 +20,14 @@ namespace ls_std
   {
     public:
 
-      explicit StateConnection(ls_std::StateConnectionId _connectionId, ls_std::StateId _stateId);
+      explicit StateConnection(const ls_std::StateConnectionId& _connectionId, const ls_std::StateId& _stateId);
       ~StateConnection() override = default;
 
       StateConnectionId getConnectionId();
       ls_std::StateId getStateId();
       bool isPassable() const;
-      void setConnectionId(ls_std::StateConnectionId _connectionId);
-      void setStateId(ls_std::StateId _stateId);
+      void setConnectionId(const ls_std::StateConnectionId& _connectionId);
+      void setStateId(const ls_std::StateId& _stateId);
       void updatePassCondition(bool _condition);
 
     private:
@@ -35,6 +35,9 @@ namespace ls_std
       bool condition{};
       ls_std::StateConnectionId connectionId{};
       ls_std::StateId stateId{};
+
+      void _assignConnectionId(const ls_std::StateConnectionId& _connectionId);
+      void _assignStateId(const ls_std::StateId& _stateId);
   };
 }
 

include/ls_std/ls_std.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-29
- * Changed:         2021-05-01
+ * Changed:         2021-05-27
  *
  * */
 
@@ -17,6 +17,7 @@
 #include "base/Class.hpp"
 #include "base/Types.hpp"
 #include "base/Version.hpp"
+#include "base/LibraryVersion.hpp"
 
 #include "boxing/IBoxing.hpp"
 #include "boxing/Boolean.hpp"
@@ -26,6 +27,8 @@
 #include "boxing/Long.hpp"
 #include "boxing/String.hpp"
 
+#include "exception/EventNotHandledException.hpp"
+#include "exception/EventNotSubscribedException.hpp"
 #include "exception/FileNotFoundException.hpp"
 #include "exception/FileOperationException.hpp"
 #include "exception/IllegalArgumentException.hpp"
@@ -36,14 +39,14 @@
 #include "io/logging/LogLevel.hpp"
 #include "io/logging/LogLevelValue.hpp"
 #include "io/logging/Logger.hpp"
-#include "io/xml/XMLReader.hpp"
-#include "io/xml/XMLParseMode.hpp"
-#include "io/xml/XMLParseData.hpp"
-#include "io/xml/XMLNode.hpp"
-#include "io/xml/XMLDocument.hpp"
-#include "io/xml/XMLDeclaration.hpp"
-#include "io/xml/XMLAttribute.hpp"
-#include "io/xml/XMLParser.hpp"
+#include "io/xml/XmlReader.hpp"
+#include "io/xml/XmlParseMode.hpp"
+#include "io/xml/XmlParseParameter.hpp"
+#include "io/xml/XmlNode.hpp"
+#include "io/xml/XmlDocument.hpp"
+#include "io/xml/XmlDeclaration.hpp"
+#include "io/xml/XmlAttribute.hpp"
+#include "io/xml/XmlParser.hpp"
 #include "io/File.hpp"
 #include "io/FileOutputStream.hpp"
 #include "io/FilePathSeparator.hpp"
@@ -55,26 +58,26 @@
 #include "io/IWriter.hpp"
 #include "io/NewLine.hpp"
 #include "io/StorableFile.hpp"
-#include "io/kv/KVPair.hpp"
-#include "io/kv/KVDocument.hpp"
-#include "io/kv/KVParser.hpp"
-#include "io/kv/KVReader.hpp"
+#include "io/kv/KvPair.hpp"
+#include "io/kv/KvDocument.hpp"
+#include "io/kv/KvParser.hpp"
+#include "io/kv/KvReader.hpp"
 
 #include "logic/State.hpp"
 #include "logic/StateConnection.hpp"
 #include "logic/StateMachine.hpp"
 #include "logic/StateMachineTypes.hpp"
 
-#include "serialization/json/boxing/SerializableJSONBoolean.hpp"
-#include "serialization/json/boxing/SerializableJSONDouble.hpp"
-#include "serialization/json/boxing/SerializableJSONFloat.hpp"
-#include "serialization/json/boxing/SerializableJSONInteger.hpp"
-#include "serialization/json/boxing/SerializableJSONLong.hpp"
-#include "serialization/json/boxing/SerializableJSONString.hpp"
-#include "serialization/json/logic/SerializableJSONState.hpp"
-#include "serialization/json/logic/SerializableJSONStateConnection.hpp"
-#include "serialization/json/logic/SerializableJSONStateMachine.hpp"
-#include "serialization/json/event/SerializableJSONEvent.hpp"
+#include "serialization/json/boxing/SerializableJsonBoolean.hpp"
+#include "serialization/json/boxing/SerializableJsonDouble.hpp"
+#include "serialization/json/boxing/SerializableJsonFloat.hpp"
+#include "serialization/json/boxing/SerializableJsonInteger.hpp"
+#include "serialization/json/boxing/SerializableJsonLong.hpp"
+#include "serialization/json/boxing/SerializableJsonString.hpp"
+#include "serialization/json/logic/SerializableJsonState.hpp"
+#include "serialization/json/logic/SerializableJsonStateConnection.hpp"
+#include "serialization/json/logic/SerializableJsonStateMachine.hpp"
+#include "serialization/json/event/SerializableJsonEvent.hpp"
 #include "serialization/ISerializable.hpp"
 
 #include "time/Date.hpp"
@@ -93,13 +96,13 @@
 #include "event/EventManager.hpp"
 
 #include "factory/IFactory.hpp"
-#include "ls_std/factory/serialization/json/SerializableJSONFactory.hpp"
-#include "factory/serialization/json/boxing/SerializableJSONBooleanFactory.hpp"
-#include "factory/serialization/json/boxing/SerializableJSONDoubleFactory.hpp"
-#include "factory/serialization/json/boxing/SerializableJSONFloatFactory.hpp"
-#include "factory/serialization/json/boxing/SerializableJSONIntegerFactory.hpp"
-#include "factory/serialization/json/boxing/SerializableJSONLongFactory.hpp"
-#include "factory/serialization/json/boxing/SerializableJSONStringFactory.hpp"
-#include "factory/serialization/json/event/SerializableJSONEventFactory.hpp"
+#include "ls_std/factory/serialization/json/SerializableJsonFactory.hpp"
+#include "factory/serialization/json/boxing/SerializableJsonBooleanFactory.hpp"
+#include "factory/serialization/json/boxing/SerializableJsonDoubleFactory.hpp"
+#include "factory/serialization/json/boxing/SerializableJsonFloatFactory.hpp"
+#include "factory/serialization/json/boxing/SerializableJsonIntegerFactory.hpp"
+#include "factory/serialization/json/boxing/SerializableJsonLongFactory.hpp"
+#include "factory/serialization/json/boxing/SerializableJsonStringFactory.hpp"
+#include "factory/serialization/json/event/SerializableJsonEventFactory.hpp"
 
 #endif

include/ls_std/serialization/json/boxing/SerializableJSONBoolean.hpp → include/ls_std/serialization/json/boxing/SerializableJsonBoolean.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-04
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -18,12 +18,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONBoolean : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonBoolean : public ls_std::Class, public ls_std::ISerializable
   {
     public:
 
-      explicit SerializableJSONBoolean(const std::shared_ptr<ls_std::Boolean> &_value);
-      ~SerializableJSONBoolean() override = default;
+      explicit SerializableJsonBoolean(const std::shared_ptr<ls_std::Boolean> &_value);
+      ~SerializableJsonBoolean() override = default;
 
       // implementation
 

include/ls_std/serialization/json/boxing/SerializableJSONDouble.hpp → include/ls_std/serialization/json/boxing/SerializableJsonDouble.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-04
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -18,12 +18,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONDouble : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonDouble : public ls_std::Class, public ls_std::ISerializable
   {
     public:
 
-      explicit SerializableJSONDouble(const std::shared_ptr<ls_std::Double> &_value);
-      ~SerializableJSONDouble() override = default;
+      explicit SerializableJsonDouble(const std::shared_ptr<ls_std::Double> &_value);
+      ~SerializableJsonDouble() override = default;
 
       // implementation
 

include/ls_std/serialization/json/boxing/SerializableJSONFloat.hpp → include/ls_std/serialization/json/boxing/SerializableJsonFloat.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-04
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -18,12 +18,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONFloat : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonFloat : public ls_std::Class, public ls_std::ISerializable
   {
     public:
 
-      explicit SerializableJSONFloat(const std::shared_ptr<ls_std::Float> &_value);
-      ~SerializableJSONFloat() override = default;
+      explicit SerializableJsonFloat(const std::shared_ptr<ls_std::Float> &_value);
+      ~SerializableJsonFloat() override = default;
 
       // implementation
 

include/ls_std/serialization/json/boxing/SerializableJSONInteger.hpp → include/ls_std/serialization/json/boxing/SerializableJsonInteger.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-21
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -17,12 +17,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONInteger : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonInteger : public ls_std::Class, public ls_std::ISerializable
   {
     public:
 
-      explicit SerializableJSONInteger(const std::shared_ptr<ls_std::Integer> &_value);
-      ~SerializableJSONInteger() override = default;
+      explicit SerializableJsonInteger(const std::shared_ptr<ls_std::Integer> &_value);
+      ~SerializableJsonInteger() override = default;
 
       // implementation
 

include/ls_std/serialization/json/boxing/SerializableJSONLong.hpp → include/ls_std/serialization/json/boxing/SerializableJsonLong.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-25
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -17,12 +17,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONLong : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonLong : public ls_std::Class, public ls_std::ISerializable
   {
     public:
 
-      explicit SerializableJSONLong(const std::shared_ptr<ls_std::Long> &_value);
-      ~SerializableJSONLong() override = default;
+      explicit SerializableJsonLong(const std::shared_ptr<ls_std::Long> &_value);
+      ~SerializableJsonLong() override = default;
 
       // implementation
 

include/ls_std/serialization/json/boxing/SerializableJSONString.hpp → include/ls_std/serialization/json/boxing/SerializableJsonString.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-30
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -17,12 +17,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONString : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonString : public ls_std::Class, public ls_std::ISerializable
   {
     public:
 
-      explicit SerializableJSONString(const std::shared_ptr<ls_std::String> &_value);
-      ~SerializableJSONString() override = default;
+      explicit SerializableJsonString(const std::shared_ptr<ls_std::String> &_value);
+      ~SerializableJsonString() override = default;
 
       // implementation
 

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-07
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -18,12 +18,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONEvent : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonEvent : public ls_std::Class, public ls_std::ISerializable
   {
     public:
 
-      explicit SerializableJSONEvent(const std::shared_ptr<ls_std::Event> &_value);
-      ~SerializableJSONEvent() override = default;
+      explicit SerializableJsonEvent(const std::shared_ptr<ls_std::Event> &_value);
+      ~SerializableJsonEvent() override = default;
 
       // implementation
 

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-15
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -18,12 +18,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONState : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonState : public ls_std::Class, public ls_std::ISerializable
   {
     public:
 
-      explicit SerializableJSONState(const std::shared_ptr<ls_std::State> &_value);
-      ~SerializableJSONState() override = default;
+      explicit SerializableJsonState(const std::shared_ptr<ls_std::State> &_value);
+      ~SerializableJsonState() override = default;
 
       // implementation
 

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-14
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -18,12 +18,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONStateConnection : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonStateConnection : public ls_std::Class, public ls_std::ISerializable
   {
     public:
 
-      explicit SerializableJSONStateConnection(const std::shared_ptr<ls_std::StateConnection> &_value);
-      ~SerializableJSONStateConnection() override = default;
+      explicit SerializableJsonStateConnection(const std::shared_ptr<ls_std::StateConnection> &_value);
+      ~SerializableJsonStateConnection() override = default;
 
       // implementation
 

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-17
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
@@ -18,12 +18,12 @@
 
 namespace ls_std
 {
-  class SerializableJSONStateMachine : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonStateMachine : public ls_std::Class, public ls_std::ISerializable
   {
     public:
 
-      explicit SerializableJSONStateMachine(const std::shared_ptr<ls_std::StateMachine> &_value);
-      ~SerializableJSONStateMachine() override = default;
+      explicit SerializableJsonStateMachine(const std::shared_ptr<ls_std::StateMachine> &_value);
+      ~SerializableJsonStateMachine() override = default;
 
       // implementation
 

include/ls_std/time/Date.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2021-05-01
+ * Changed:         2021-05-22
  *
  * */
 
@@ -26,6 +26,8 @@ namespace ls_std
 
       ls_std::Date &operator+(int _value);
       ls_std::Date &operator-(int _value);
+      ls_std::Date &operator+=(int _value);
+      ls_std::Date &operator-=(int _value);
 
       // additional functionality
 
@@ -46,6 +48,8 @@ namespace ls_std
       time_t timestamp{};
       tm *localTime{};
 
+      void _decrementByDays(int _value);
+      void _incrementByDays(int _value);
       void _init();
   };
 }

source/ls_std/event/Event.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2021-05-01
+ * Changed:         2021-05-24
  *
  * */
 
@@ -35,12 +35,16 @@ void ls_std::Event::unmarshal(const ls_std::byte_field &_data)
   }
 }
 
-void ls_std::Event::addParameter(const ls_std::event_parameter &_eventParameter)
+bool ls_std::Event::addParameter(const ls_std::event_parameter &_eventParameter)
 {
+  bool wasAdded{};
+
   if (!this->_hasParameter(_eventParameter.first))
   {
-    this->parameterList.insert(_eventParameter);
+    wasAdded = this->parameterList.insert(_eventParameter).second;
   }
+
+  return wasAdded;
 }
 
 void ls_std::Event::clearParameterList()
@@ -58,12 +62,9 @@ ls_std::event_parameter_list ls_std::Event::getParameterList()
   return this->parameterList;
 }
 
-void ls_std::Event::removeParameter(const ls_std::event_parameter_id &_id)
+bool ls_std::Event::removeParameter(const ls_std::event_parameter_id &_id)
 {
-  if (this->_hasParameter(_id))
-  {
-    this->parameterList.erase(_id);
-  }
+  return this->parameterList.erase(_id) == 1;
 }
 
 void ls_std::Event::setId(const ls_std::event_id &_id)
@@ -71,6 +72,11 @@ void ls_std::Event::setId(const ls_std::event_id &_id)
   this->_assignId(_id);
 }
 
+void ls_std::Event::setSerializable(const std::shared_ptr<ls_std::ISerializable> &_serializable)
+{
+  this->_assignSerializable(_serializable);
+}
+
 void ls_std::Event::_assignId(const ls_std::event_id &_id)
 {
   if (_id.empty())
@@ -81,12 +87,17 @@ void ls_std::Event::_assignId(const ls_std::event_id &_id)
   this->id = _id;
 }
 
-bool ls_std::Event::_hasParameter(const ls_std::event_id &_id)
+void ls_std::Event::_assignSerializable(const std::shared_ptr<ls_std::ISerializable> &_serializable)
 {
-  return this->parameterList.find(_id) != this->parameterList.end();
+  if (_serializable == nullptr)
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+
+  this->serializable = _serializable;
 }
 
-void ls_std::Event::setSerializable(std::shared_ptr<ls_std::ISerializable> _serializable)
+bool ls_std::Event::_hasParameter(const ls_std::event_id &_id)
 {
-  this->serializable = std::move(_serializable);
+  return this->parameterList.find(_id) != this->parameterList.end();
 }

source/ls_std/event/EventHandler.cpp

@@ -3,18 +3,29 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2021-04-23
+ * Changed:         2021-05-27
  *
  * */
 
 #include <ls_std/event/EventHandler.hpp>
+#include <ls_std/exception/IllegalArgumentException.hpp>
 
-ls_std::EventHandler::EventHandler(ls_std::event_id _id)
-    : ls_std::Narrator(),
-      id(std::move(_id))
-{}
+ls_std::EventHandler::EventHandler(const ls_std::event_id& _id) : ls_std::Narrator()
+{
+  this->_assignId(_id);
+}
 
 ls_std::event_id ls_std::EventHandler::getId()
 {
   return this->id;
 }
+
+void ls_std::EventHandler::_assignId(const ls_std::event_id &_id)
+{
+  if (_id.empty())
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+
+  this->id = _id;
+}

source/ls_std/event/EventManager.cpp

@@ -3,38 +3,64 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2021-05-01
+ * Changed:         2021-05-27
  *
  * */
 
 #include <ls_std/event/EventManager.hpp>
+#include <ls_std/exception/EventNotSubscribedException.hpp>
+#include <ls_std/exception/EventNotHandledException.hpp>
+#include <ls_std/exception/IllegalArgumentException.hpp>
 
 ls_std::EventManager::EventManager() : ls_std::Class("EventManager")
 {}
 
 void ls_std::EventManager::subscribe(const ls_std::event_id &_id, const std::shared_ptr<ls_std::IListener> &_listener)
 {
+  if (_id.empty() || _listener == nullptr)
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+
   if (this->_hasEventHandler(_id))
   {
     this->eventHandlers.at(_id)->addListener(_listener);
   }
+  else
+  {
+    throw ls_std::EventNotSubscribedException{};
+  }
 }
 
 void ls_std::EventManager::unsubscribe(const ls_std::event_id &_id, const std::shared_ptr<ls_std::IListener> &_listener)
 {
+  if (_id.empty() || _listener == nullptr)
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+
   if (this->_hasEventHandler(_id))
   {
     this->eventHandlers.at(_id)->removeListener(_listener);
   }
 }
 
-void ls_std::EventManager::addEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
+bool ls_std::EventManager::addEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
 {
+  bool wasAdded{};
+
+  if (_eventHandler == nullptr)
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+
   if (!this->_hasEventHandler(_eventHandler->getId()))
   {
     std::pair<ls_std::event_id, std::shared_ptr<ls_std::EventHandler>> element = std::make_pair(_eventHandler->getId(), _eventHandler);
-    this->eventHandlers.insert(element);
+    wasAdded = this->eventHandlers.insert(element).second;
   }
+
+  return wasAdded;
 }
 
 void ls_std::EventManager::fire(ls_std::Event _event)
@@ -43,11 +69,30 @@ void ls_std::EventManager::fire(ls_std::Event _event)
   {
     this->eventHandlers.at(_event.getId())->tell(_event);
   }
+  else
+  {
+    throw ls_std::EventNotHandledException{};
+  }
+}
+
+bool ls_std::EventManager::hasEventHandler(const ls_std::event_id &_id)
+{
+  if (_id.empty())
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+
+  return this->_hasEventHandler(_id);
 }
 
-void ls_std::EventManager::removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
+bool ls_std::EventManager::removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
 {
-  this->_removeEventHandler(_eventHandler);
+  if (_eventHandler == nullptr)
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+
+  return this->_removeEventHandler(_eventHandler);
 }
 
 bool ls_std::EventManager::_hasEventHandler(const ls_std::event_id &_id)
@@ -55,7 +100,7 @@ bool ls_std::EventManager::_hasEventHandler(const ls_std::event_id &_id)
   return this->eventHandlers.find(_id) != this->eventHandlers.end();
 }
 
-void ls_std::EventManager::_removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
+bool ls_std::EventManager::_removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
 {
-  this->eventHandlers.erase(_eventHandler->getId());
+  return this->eventHandlers.erase(_eventHandler->getId()) == 1;
 }

source/ls_std/factory/serialization/json/SerializableJSONFactory.cpp → source/ls_std/factory/serialization/json/SerializableJsonFactory.cpp

@@ -3,32 +3,32 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-24
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/factory/serialization/json/SerializableJSONFactory.hpp>
+#include <ls_std/factory/serialization/json/SerializableJsonFactory.hpp>
 #include <ls_std/boxing/Boolean.hpp>
 #include <ls_std/boxing/Double.hpp>
 #include <ls_std/boxing/Float.hpp>
 #include <ls_std/boxing/Integer.hpp>
 #include <ls_std/boxing/Long.hpp>
 #include <ls_std/boxing/String.hpp>
-#include <ls_std/factory/serialization/json/boxing/SerializableJSONBooleanFactory.hpp>
-#include <ls_std/factory/serialization/json/boxing/SerializableJSONDoubleFactory.hpp>
-#include <ls_std/factory/serialization/json/boxing/SerializableJSONFloatFactory.hpp>
-#include <ls_std/factory/serialization/json/boxing/SerializableJSONIntegerFactory.hpp>
-#include <ls_std/factory/serialization/json/boxing/SerializableJSONLongFactory.hpp>
-#include <ls_std/factory/serialization/json/boxing/SerializableJSONStringFactory.hpp>
+#include <ls_std/factory/serialization/json/boxing/SerializableJsonBooleanFactory.hpp>
+#include <ls_std/factory/serialization/json/boxing/SerializableJsonDoubleFactory.hpp>
+#include <ls_std/factory/serialization/json/boxing/SerializableJsonFloatFactory.hpp>
+#include <ls_std/factory/serialization/json/boxing/SerializableJsonIntegerFactory.hpp>
+#include <ls_std/factory/serialization/json/boxing/SerializableJsonLongFactory.hpp>
+#include <ls_std/factory/serialization/json/boxing/SerializableJsonStringFactory.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 #include <ls_std/exception/NullPointerException.hpp>
 
-ls_std::SerializableJSONFactory::SerializableJSONFactory() : ls_std::Class("SerializableJSONFactory")
+ls_std::SerializableJsonFactory::SerializableJsonFactory() : ls_std::Class("SerializableJsonFactory")
 {
   this->_init();
 }
 
-bool ls_std::SerializableJSONFactory::addFactory(const std::pair<std::string, std::shared_ptr<ls_std::IFactory>> &_factoryInsertion)
+bool ls_std::SerializableJsonFactory::addFactory(const std::pair<std::string, std::shared_ptr<ls_std::IFactory>> &_factoryInsertion)
 {
   bool factoryAdded{};
 
@@ -50,7 +50,7 @@ bool ls_std::SerializableJSONFactory::addFactory(const std::pair<std::string, st
   return factoryAdded;
 }
 
-std::shared_ptr<ls_std::Class> ls_std::SerializableJSONFactory::build(const std::string &_relatedObjectName)
+std::shared_ptr<ls_std::Class> ls_std::SerializableJsonFactory::build(const std::string &_relatedObjectName)
 {
   std::shared_ptr<ls_std::Class> requestedBuiltObject{};
 
@@ -62,18 +62,18 @@ std::shared_ptr<ls_std::Class> ls_std::SerializableJSONFactory::build(const std:
   return requestedBuiltObject;
 }
 
-bool ls_std::SerializableJSONFactory::clear()
+bool ls_std::SerializableJsonFactory::clear()
 {
   this->factories.clear();
   return factories.empty();
 }
 
-bool ls_std::SerializableJSONFactory::hasFactory(const std::string &_relatedObjectName)
+bool ls_std::SerializableJsonFactory::hasFactory(const std::string &_relatedObjectName)
 {
   return this->_hasFactory(_relatedObjectName);
 }
 
-bool ls_std::SerializableJSONFactory::removeFactory(const std::string &_relatedObjectName)
+bool ls_std::SerializableJsonFactory::removeFactory(const std::string &_relatedObjectName)
 {
   bool wasRemoved{};
 
@@ -86,17 +86,17 @@ bool ls_std::SerializableJSONFactory::removeFactory(const std::string &_relatedO
   return wasRemoved;
 }
 
-bool ls_std::SerializableJSONFactory::_hasFactory(const std::string &_relatedObjectName)
+bool ls_std::SerializableJsonFactory::_hasFactory(const std::string &_relatedObjectName)
 {
   return this->factories.find(_relatedObjectName) != this->factories.end();
 }
 
-void ls_std::SerializableJSONFactory::_init()
+void ls_std::SerializableJsonFactory::_init()
 {
-  this->factories.insert({ls_std::Boolean{}.getClassName(), std::make_shared<ls_std::SerializableJSONBooleanFactory>()});
-  this->factories.insert({ls_std::Double{}.getClassName(), std::make_shared<ls_std::SerializableJSONDoubleFactory>()});
-  this->factories.insert({ls_std::Float{}.getClassName(), std::make_shared<ls_std::SerializableJSONFloatFactory>()});
-  this->factories.insert({ls_std::Integer{}.getClassName(), std::make_shared<ls_std::SerializableJSONIntegerFactory>()});
-  this->factories.insert({ls_std::Long{}.getClassName(), std::make_shared<ls_std::SerializableJSONLongFactory>()});
-  this->factories.insert({ls_std::String{}.getClassName(), std::make_shared<ls_std::SerializableJSONStringFactory>()});
+  this->factories.insert({ls_std::Boolean{}.getClassName(), std::make_shared<ls_std::SerializableJsonBooleanFactory>()});
+  this->factories.insert({ls_std::Double{}.getClassName(), std::make_shared<ls_std::SerializableJsonDoubleFactory>()});
+  this->factories.insert({ls_std::Float{}.getClassName(), std::make_shared<ls_std::SerializableJsonFloatFactory>()});
+  this->factories.insert({ls_std::Integer{}.getClassName(), std::make_shared<ls_std::SerializableJsonIntegerFactory>()});
+  this->factories.insert({ls_std::Long{}.getClassName(), std::make_shared<ls_std::SerializableJsonLongFactory>()});
+  this->factories.insert({ls_std::String{}.getClassName(), std::make_shared<ls_std::SerializableJsonStringFactory>()});
 }

source/ls_std/factory/serialization/json/boxing/SerializableJSONBooleanFactory.cpp → source/ls_std/factory/serialization/json/boxing/SerializableJsonBooleanFactory.cpp

@@ -3,21 +3,21 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-23
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/factory/serialization/json/boxing/SerializableJSONBooleanFactory.hpp>
+#include <ls_std/factory/serialization/json/boxing/SerializableJsonBooleanFactory.hpp>
 #include <ls_std/boxing/Boolean.hpp>
-#include <ls_std/serialization/json/boxing/SerializableJSONBoolean.hpp>
+#include <ls_std/serialization/json/boxing/SerializableJsonBoolean.hpp>
 
-ls_std::SerializableJSONBooleanFactory::SerializableJSONBooleanFactory() : ls_std::Class("SerializableJSONBooleanFactory")
+ls_std::SerializableJsonBooleanFactory::SerializableJsonBooleanFactory() : ls_std::Class("SerializableJsonBooleanFactory")
 {}
 
-std::shared_ptr<ls_std::Class> ls_std::SerializableJSONBooleanFactory::build()
+std::shared_ptr<ls_std::Class> ls_std::SerializableJsonBooleanFactory::build()
 {
   std::shared_ptr<ls_std::Boolean> requestedObject = std::make_shared<ls_std::Boolean>();
-  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJSONBoolean>(requestedObject);
+  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJsonBoolean>(requestedObject);
   requestedObject->setSerializable(serializable);
 
   return std::dynamic_pointer_cast<ls_std::Class>(requestedObject);

source/ls_std/factory/serialization/json/boxing/SerializableJSONDoubleFactory.cpp → source/ls_std/factory/serialization/json/boxing/SerializableJsonDoubleFactory.cpp

@@ -3,21 +3,21 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-24
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/factory/serialization/json/boxing/SerializableJSONDoubleFactory.hpp>
+#include <ls_std/factory/serialization/json/boxing/SerializableJsonDoubleFactory.hpp>
 #include <ls_std/boxing/Double.hpp>
-#include <ls_std/serialization/json/boxing/SerializableJSONDouble.hpp>
+#include <ls_std/serialization/json/boxing/SerializableJsonDouble.hpp>
 
-ls_std::SerializableJSONDoubleFactory::SerializableJSONDoubleFactory() : ls_std::Class("SerializableJSONDoubleFactory")
+ls_std::SerializableJsonDoubleFactory::SerializableJsonDoubleFactory() : ls_std::Class("SerializableJsonDoubleFactory")
 {}
 
-std::shared_ptr<ls_std::Class> ls_std::SerializableJSONDoubleFactory::build()
+std::shared_ptr<ls_std::Class> ls_std::SerializableJsonDoubleFactory::build()
 {
   std::shared_ptr<ls_std::Double> requestedObject = std::make_shared<ls_std::Double>();
-  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJSONDouble>(requestedObject);
+  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJsonDouble>(requestedObject);
   requestedObject->setSerializable(serializable);
 
   return std::dynamic_pointer_cast<ls_std::Class>(requestedObject);

source/ls_std/factory/serialization/json/boxing/SerializableJSONFloatFactory.cpp → source/ls_std/factory/serialization/json/boxing/SerializableJsonFloatFactory.cpp

@@ -3,21 +3,21 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-25
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/factory/serialization/json/boxing/SerializableJSONFloatFactory.hpp>
+#include <ls_std/factory/serialization/json/boxing/SerializableJsonFloatFactory.hpp>
 #include <ls_std/boxing/Float.hpp>
-#include <ls_std/serialization/json/boxing/SerializableJSONFloat.hpp>
+#include <ls_std/serialization/json/boxing/SerializableJsonFloat.hpp>
 
-ls_std::SerializableJSONFloatFactory::SerializableJSONFloatFactory() : ls_std::Class("SerializableJSONFloatFactory")
+ls_std::SerializableJsonFloatFactory::SerializableJsonFloatFactory() : ls_std::Class("SerializableJsonFloatFactory")
 {}
 
-std::shared_ptr<ls_std::Class> ls_std::SerializableJSONFloatFactory::build()
+std::shared_ptr<ls_std::Class> ls_std::SerializableJsonFloatFactory::build()
 {
   std::shared_ptr<ls_std::Float> requestedObject = std::make_shared<ls_std::Float>();
-  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJSONFloat>(requestedObject);
+  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJsonFloat>(requestedObject);
   requestedObject->setSerializable(serializable);
 
   return std::dynamic_pointer_cast<ls_std::Class>(requestedObject);

source/ls_std/factory/serialization/json/boxing/SerializableJSONIntegerFactory.cpp → source/ls_std/factory/serialization/json/boxing/SerializableJsonIntegerFactory.cpp

@@ -3,21 +3,21 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-25
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/factory/serialization/json/boxing/SerializableJSONIntegerFactory.hpp>
+#include <ls_std/factory/serialization/json/boxing/SerializableJsonIntegerFactory.hpp>
 #include <ls_std/boxing/Integer.hpp>
-#include <ls_std/serialization/json/boxing/SerializableJSONInteger.hpp>
+#include <ls_std/serialization/json/boxing/SerializableJsonInteger.hpp>
 
-ls_std::SerializableJSONIntegerFactory::SerializableJSONIntegerFactory() : ls_std::Class("SerializableJSONIntegerFactory")
+ls_std::SerializableJsonIntegerFactory::SerializableJsonIntegerFactory() : ls_std::Class("SerializableJsonIntegerFactory")
 {}
 
-std::shared_ptr<ls_std::Class> ls_std::SerializableJSONIntegerFactory::build()
+std::shared_ptr<ls_std::Class> ls_std::SerializableJsonIntegerFactory::build()
 {
   std::shared_ptr<ls_std::Integer> requestedObject = std::make_shared<ls_std::Integer>();
-  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJSONInteger>(requestedObject);
+  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJsonInteger>(requestedObject);
   requestedObject->setSerializable(serializable);
 
   return std::dynamic_pointer_cast<ls_std::Class>(requestedObject);

source/ls_std/factory/serialization/json/boxing/SerializableJSONLongFactory.cpp → source/ls_std/factory/serialization/json/boxing/SerializableJsonLongFactory.cpp

@@ -3,21 +3,21 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-25
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/factory/serialization/json/boxing/SerializableJSONLongFactory.hpp>
+#include <ls_std/factory/serialization/json/boxing/SerializableJsonLongFactory.hpp>
 #include <ls_std/boxing/Long.hpp>
-#include <ls_std/serialization/json/boxing/SerializableJSONLong.hpp>
+#include <ls_std/serialization/json/boxing/SerializableJsonLong.hpp>
 
-ls_std::SerializableJSONLongFactory::SerializableJSONLongFactory() : ls_std::Class("SerializableJSONLongFactory")
+ls_std::SerializableJsonLongFactory::SerializableJsonLongFactory() : ls_std::Class("SerializableJsonLongFactory")
 {}
 
-std::shared_ptr<ls_std::Class> ls_std::SerializableJSONLongFactory::build()
+std::shared_ptr<ls_std::Class> ls_std::SerializableJsonLongFactory::build()
 {
   std::shared_ptr<ls_std::Long> requestedObject = std::make_shared<ls_std::Long>();
-  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJSONLong>(requestedObject);
+  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJsonLong>(requestedObject);
   requestedObject->setSerializable(serializable);
 
   return std::dynamic_pointer_cast<ls_std::Class>(requestedObject);

source/ls_std/factory/serialization/json/boxing/SerializableJSONStringFactory.cpp → source/ls_std/factory/serialization/json/boxing/SerializableJsonStringFactory.cpp

@@ -3,21 +3,21 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-25
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/factory/serialization/json/boxing/SerializableJSONStringFactory.hpp>
+#include <ls_std/factory/serialization/json/boxing/SerializableJsonStringFactory.hpp>
 #include <ls_std/boxing/String.hpp>
-#include <ls_std/serialization/json/boxing/SerializableJSONString.hpp>
+#include <ls_std/serialization/json/boxing/SerializableJsonString.hpp>
 
-ls_std::SerializableJSONStringFactory::SerializableJSONStringFactory() : ls_std::Class("SerializableJSONStringFactory")
+ls_std::SerializableJsonStringFactory::SerializableJsonStringFactory() : ls_std::Class("SerializableJsonStringFactory")
 {}
 
-std::shared_ptr<ls_std::Class> ls_std::SerializableJSONStringFactory::build()
+std::shared_ptr<ls_std::Class> ls_std::SerializableJsonStringFactory::build()
 {
   std::shared_ptr<ls_std::String> requestedObject = std::make_shared<ls_std::String>();
-  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJSONString>(requestedObject);
+  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJsonString>(requestedObject);
   requestedObject->setSerializable(serializable);
 
   return std::dynamic_pointer_cast<ls_std::Class>(requestedObject);

source/ls_std/factory/serialization/json/event/SerializableJSONEventFactory.cpp → source/ls_std/factory/serialization/json/event/SerializableJsonEventFactory.cpp

@@ -3,21 +3,21 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-30
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/factory/serialization/json/event/SerializableJSONEventFactory.hpp>
+#include <ls_std/factory/serialization/json/event/SerializableJsonEventFactory.hpp>
 #include <ls_std/event/Event.hpp>
-#include <ls_std/serialization/json/event/SerializableJSONEvent.hpp>
+#include <ls_std/serialization/json/event/SerializableJsonEvent.hpp>
 
-ls_std::SerializableJSONEventFactory::SerializableJSONEventFactory() : ls_std::Class("SerializableJSONEventFactory")
+ls_std::SerializableJsonEventFactory::SerializableJsonEventFactory() : ls_std::Class("SerializableJsonEventFactory")
 {}
 
-std::shared_ptr<ls_std::Class> ls_std::SerializableJSONEventFactory::build()
+std::shared_ptr<ls_std::Class> ls_std::SerializableJsonEventFactory::build()
 {
   std::shared_ptr<ls_std::Event> requestedObject = std::make_shared<ls_std::Event>("TMP_ID");
-  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJSONEvent>(requestedObject);
+  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJsonEvent>(requestedObject);
   requestedObject->setSerializable(serializable);
 
   return std::dynamic_pointer_cast<ls_std::Class>(requestedObject);

source/ls_std/io/kv/KVParser.cpp

@@ -1,103 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-12-25
- * Changed:         2021-04-23
- *
- * */
-
-#include <ls_std/io/kv/KVParser.hpp>
-#include <ls_std/exception/NullPointerException.hpp>
-#include <ls_std/io/NewLine.hpp>
-
-ls_std::KVParser::KVParser(const std::shared_ptr<ls_std::KVDocument> &_document) : ls_std::Class("KVParser")
-{
-  this->_assignDocument(_document);
-}
-
-std::shared_ptr<ls_std::KVDocument> ls_std::KVParser::getDocument()
-{
-  return this->document;
-}
-
-void ls_std::KVParser::parse(const ls_std::byte_field &_data)
-{
-  this->_parse(_data);
-}
-
-void ls_std::KVParser::setDocument(const std::shared_ptr<ls_std::KVDocument> &_document)
-{
-  this->_assignDocument(_document);
-}
-
-void ls_std::KVParser::_assignDocument(const std::shared_ptr<ls_std::KVDocument> &_document)
-{
-  if (_document == nullptr)
-  {
-    throw ls_std::NullPointerException{};
-  }
-
-  this->document = _document;
-}
-
-bool ls_std::KVParser::_lineHasPair(ls_std::KVParseData _parseData)
-{
-  return _parseData.line.contains("=") && _parseData.line.contains(";");
-}
-
-void ls_std::KVParser::_parse(const ls_std::byte_field &_data)
-{
-  for (std::string::size_type index = 0; index < _data.size(); index++)
-  {
-    ls_std::KVParseData parseData = ls_std::KVParser::_readLine(_data, index);
-    this->_parsePair(parseData);
-    index = parseData.index;
-  }
-}
-
-void ls_std::KVParser::_parsePair(ls_std::KVParseData _parseData)
-{
-  if (ls_std::KVParser::_lineHasPair(_parseData))
-  {
-    size_t equalSignPosition = _parseData.line.toString().find('=');
-    ls_std::kv_key key = _parseData.line.toString().substr(0, equalSignPosition);
-    ls_std::kv_value value = _parseData.line.toString().substr(equalSignPosition + 1);
-    value = value.substr(0, value.find(';'));
-
-    this->document->addPair(ls_std::KVPair{key, value});
-  }
-}
-
-ls_std::KVParseData ls_std::KVParser::_readLine(const ls_std::byte_field &_data, std::string::size_type _index)
-{
-  ls_std::KVParseData parseData{};
-  parseData.line = _data.substr(_index);
-
-  if (parseData.line.contains(ls_std::NewLine::getWindowsNewLine()))
-  {
-    ls_std::KVParser::_readLineWithWindowsLineBreak(parseData);
-  }
-  else
-  {
-    if (parseData.line.contains(ls_std::NewLine::getUnixNewLine()))
-    {
-      ls_std::KVParser::_readLineWithUnixLineBreak(parseData);
-    }
-  }
-
-  parseData.index = _index + parseData.line.toString().size();
-  return parseData;
-}
-
-void ls_std::KVParser::_readLineWithUnixLineBreak(ls_std::KVParseData &_parseData)
-{
-  size_t newLinePosition = _parseData.line.toString().find(ls_std::NewLine::getUnixNewLine());
-  _parseData.line = _parseData.line.toString().substr(0, newLinePosition);
-}
-
-void ls_std::KVParser::_readLineWithWindowsLineBreak(ls_std::KVParseData &_parseData)
-{
-  size_t newLinePosition = _parseData.line.toString().find(ls_std::NewLine::getWindowsNewLine());
-  _parseData.line = _parseData.line.toString().substr(0, newLinePosition + 1);
-}

source/ls_std/io/kv/KVDocument.cpp → source/ls_std/io/kv/KvDocument.cpp

@@ -3,44 +3,44 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/io/kv/KVDocument.hpp>
+#include <ls_std/io/kv/KvDocument.hpp>
 
-ls_std::KVDocument::KVDocument() : ls_std::Class("KVDocument")
+ls_std::KvDocument::KvDocument() : ls_std::Class("KvDocument")
 {}
 
-bool ls_std::KVDocument::addPair(ls_std::KVPair _pair)
+bool ls_std::KvDocument::addPair(ls_std::KvPair _pair)
 {
   bool added{};
 
   if (!this->_hasPair(_pair.getKey()))
   {
-    std::pair<ls_std::kv_key, ls_std::KVPair> pair = std::make_pair(_pair.getKey(), _pair);
+    std::pair<ls_std::kv_key, ls_std::KvPair> pair = std::make_pair(_pair.getKey(), _pair);
     added = this->pairs.insert(pair).second;
   }
 
   return added;
 }
 
-void ls_std::KVDocument::clear()
+void ls_std::KvDocument::clear()
 {
   this->pairs.clear();
 }
 
-std::map<ls_std::kv_key, ls_std::KVPair> ls_std::KVDocument::getPairs()
+std::map<ls_std::kv_key, ls_std::KvPair> ls_std::KvDocument::getPairs()
 {
   return this->pairs;
 }
 
-bool ls_std::KVDocument::hasPair(const ls_std::kv_key &_key)
+bool ls_std::KvDocument::hasPair(const ls_std::kv_key &_key)
 {
   return this->_hasPair(_key);
 }
 
-void ls_std::KVDocument::removePair(const ls_std::kv_key &_key)
+void ls_std::KvDocument::removePair(const ls_std::kv_key &_key)
 {
   if (_hasPair(_key))
   {
@@ -48,7 +48,7 @@ void ls_std::KVDocument::removePair(const ls_std::kv_key &_key)
   }
 }
 
-bool ls_std::KVDocument::_hasPair(const ls_std::kv_key &_key)
+bool ls_std::KvDocument::_hasPair(const ls_std::kv_key &_key)
 {
   return this->pairs.find(_key) != this->pairs.end();
 }

source/ls_std/io/kv/KVPair.cpp → source/ls_std/io/kv/KvPair.cpp

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

source/ls_std/io/kv/KvParser.cpp

@@ -0,0 +1,103 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-12-25
+ * Changed:         2021-05-02
+ *
+ * */
+
+#include <ls_std/io/kv/KvParser.hpp>
+#include <ls_std/exception/NullPointerException.hpp>
+#include <ls_std/io/NewLine.hpp>
+
+ls_std::KvParser::KvParser(const std::shared_ptr<ls_std::KvDocument> &_document) : ls_std::Class("KvParser")
+{
+  this->_assignDocument(_document);
+}
+
+std::shared_ptr<ls_std::KvDocument> ls_std::KvParser::getDocument()
+{
+  return this->document;
+}
+
+void ls_std::KvParser::parse(const ls_std::byte_field &_data)
+{
+  this->_parse(_data);
+}
+
+void ls_std::KvParser::setDocument(const std::shared_ptr<ls_std::KvDocument> &_document)
+{
+  this->_assignDocument(_document);
+}
+
+void ls_std::KvParser::_assignDocument(const std::shared_ptr<ls_std::KvDocument> &_document)
+{
+  if (_document == nullptr)
+  {
+    throw ls_std::NullPointerException{};
+  }
+
+  this->document = _document;
+}
+
+bool ls_std::KvParser::_lineHasPair(ls_std::KvParseParameter _parseParameter)
+{
+  return _parseParameter.line.contains("=") && _parseParameter.line.contains(";");
+}
+
+void ls_std::KvParser::_parse(const ls_std::byte_field &_data)
+{
+  for (std::string::size_type index = 0; index < _data.size(); index++)
+  {
+    ls_std::KvParseParameter parseParameter = ls_std::KvParser::_readLine(_data, index);
+    this->_parsePair(parseParameter);
+    index = parseParameter.index;
+  }
+}
+
+void ls_std::KvParser::_parsePair(ls_std::KvParseParameter _parseParameter)
+{
+  if (ls_std::KvParser::_lineHasPair(_parseParameter))
+  {
+    size_t equalSignPosition = _parseParameter.line.toString().find('=');
+    ls_std::kv_key key = _parseParameter.line.toString().substr(0, equalSignPosition);
+    ls_std::kv_value value = _parseParameter.line.toString().substr(equalSignPosition + 1);
+    value = value.substr(0, value.find(';'));
+
+    this->document->addPair(ls_std::KvPair{key, value});
+  }
+}
+
+ls_std::KvParseParameter ls_std::KvParser::_readLine(const ls_std::byte_field &_data, std::string::size_type _index)
+{
+  ls_std::KvParseParameter parseParameter{};
+  parseParameter.line = _data.substr(_index);
+
+  if (parseParameter.line.contains(ls_std::NewLine::getWindowsNewLine()))
+  {
+    ls_std::KvParser::_readLineWithWindowsLineBreak(parseParameter);
+  }
+  else
+  {
+    if (parseParameter.line.contains(ls_std::NewLine::getUnixNewLine()))
+    {
+      ls_std::KvParser::_readLineWithUnixLineBreak(parseParameter);
+    }
+  }
+
+  parseParameter.index = _index + parseParameter.line.toString().size();
+  return parseParameter;
+}
+
+void ls_std::KvParser::_readLineWithUnixLineBreak(ls_std::KvParseParameter &_parseParameter)
+{
+  size_t newLinePosition = _parseParameter.line.toString().find(ls_std::NewLine::getUnixNewLine());
+  _parseParameter.line = _parseParameter.line.toString().substr(0, newLinePosition);
+}
+
+void ls_std::KvParser::_readLineWithWindowsLineBreak(ls_std::KvParseParameter &_parseParameter)
+{
+  size_t newLinePosition = _parseParameter.line.toString().find(ls_std::NewLine::getWindowsNewLine());
+  _parseParameter.line = _parseParameter.line.toString().substr(0, newLinePosition + 1);
+}

source/ls_std/io/kv/KVReader.cpp → source/ls_std/io/kv/KvReader.cpp

@@ -3,47 +3,47 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/io/kv/KVReader.hpp>
+#include <ls_std/io/kv/KvReader.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 #include <ls_std/io/FileReader.hpp>
-#include <ls_std/io/kv/KVParser.hpp>
+#include <ls_std/io/kv/KvParser.hpp>
 
-ls_std::KVReader::KVReader(const std::shared_ptr<ls_std::KVDocument> &_document, const std::string &_absolutePath)
-    : ls_std::Class("KVReader"),
+ls_std::KvReader::KvReader(const std::shared_ptr<ls_std::KvDocument> &_document, const std::string &_absolutePath)
+    : ls_std::Class("KvReader"),
       kvFile(ls_std::File{""})
 {
   this->_assignDocument(_document);
   this->_assignFile(ls_std::File{_absolutePath});
 }
 
-ls_std::byte_field ls_std::KVReader::read()
+ls_std::byte_field ls_std::KvReader::read()
 {
   ls_std::byte_field data = ls_std::FileReader{this->kvFile}.read();
-  ls_std::KVParser{this->document}.parse(data);
+  ls_std::KvParser{this->document}.parse(data);
 
   return data;
 }
 
-std::shared_ptr<ls_std::KVDocument> ls_std::KVReader::getDocument()
+std::shared_ptr<ls_std::KvDocument> ls_std::KvReader::getDocument()
 {
   return this->document;
 }
 
-void ls_std::KVReader::setDocument(const std::shared_ptr<ls_std::KVDocument> &_document)
+void ls_std::KvReader::setDocument(const std::shared_ptr<ls_std::KvDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-void ls_std::KVReader::setFile(const ls_std::File &_kvFile)
+void ls_std::KvReader::setFile(const ls_std::File &_kvFile)
 {
   this->_assignFile(_kvFile);
 }
 
-void ls_std::KVReader::_assignDocument(const std::shared_ptr<ls_std::KVDocument> &_document)
+void ls_std::KvReader::_assignDocument(const std::shared_ptr<ls_std::KvDocument> &_document)
 {
   if (_document == nullptr)
   {
@@ -53,7 +53,7 @@ void ls_std::KVReader::_assignDocument(const std::shared_ptr<ls_std::KVDocument>
   this->document = _document;
 }
 
-void ls_std::KVReader::_assignFile(ls_std::File _kvFile)
+void ls_std::KvReader::_assignFile(ls_std::File _kvFile)
 {
   if (!_kvFile.exists())
   {

source/ls_std/io/logging/LogLevel.cpp

@@ -3,11 +3,12 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
 #include <ls_std/io/logging/LogLevel.hpp>
+#include <ls_std/exception/IllegalArgumentException.hpp>
 
 ls_std::LogLevel::LogLevel(const ls_std::LogLevelValue &_value)
     : ls_std::Class("LogLevel"),
@@ -16,8 +17,10 @@ ls_std::LogLevel::LogLevel(const ls_std::LogLevelValue &_value)
   this->_init();
 }
 
-ls_std::LogLevel::LogLevel() : Class("LogLevel")
-{}
+ls_std::LogLevel::LogLevel() : ls_std::Class("LogLevel")
+{
+  this->_init();
+}
 
 ls_std::LogLevel::operator unsigned char() const
 {
@@ -30,16 +33,69 @@ ls_std::LogLevel &ls_std::LogLevel::operator=(const ls_std::LogLevelValue &_valu
   return *this;
 }
 
+bool ls_std::LogLevel::operator<(const ls_std::LogLevelValue &_value)
+{
+  return this->value < _value;
+}
+
 bool ls_std::LogLevel::operator<=(const ls_std::LogLevelValue &_value)
 {
   return this->value <= _value;
 }
 
+bool ls_std::LogLevel::operator>(const ls_std::LogLevelValue &_value)
+{
+  return this->value > _value;
+}
+
+bool ls_std::LogLevel::operator>=(const ls_std::LogLevelValue &_value)
+{
+  return this->value >= _value;
+}
+
+bool ls_std::LogLevel::operator==(const ls_std::LogLevelValue &_value)
+{
+  return this->value == _value;
+}
+
+void ls_std::LogLevel::setLogLevel(const ls_std::LogLevelValue &_value)
+{
+  this->value = _value;
+}
+
+void ls_std::LogLevel::setLogLevel(const std::string &_value)
+{
+  if (this->_isValidLogLevelString(_value))
+  {
+    this->value = _getValueFromString(_value);
+  }
+  else
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+}
+
 std::string ls_std::LogLevel::toString() const
 {
   return this->level.at(this->value);
 }
 
+ls_std::LogLevelValue ls_std::LogLevel::_getValueFromString(const std::string &_value)
+{
+  ls_std::LogLevelValue logLevelValue{};
+
+  for (const auto &logLevelString : this->level)
+  {
+    if (logLevelString.second == _value)
+    {
+      logLevelValue = (ls_std::LogLevelValue) logLevelString.first;
+      break;
+    }
+  }
+
+  return logLevelValue;
+}
+
 void ls_std::LogLevel::_init()
 {
   this->level.insert({ls_std::LogLevelValue::FATAL, "FATAL"});
@@ -48,5 +104,21 @@ void ls_std::LogLevel::_init()
   this->level.insert({ls_std::LogLevelValue::INFO, "INFO"});
   this->level.insert({ls_std::LogLevelValue::DEBUG, "DEBUG"});
   this->level.insert({ls_std::LogLevelValue::TRACE, "TRACE"});
-  this->level.insert({ls_std::LogLevelValue::OFF, "OFF"});
+}
+
+bool ls_std::LogLevel::_isValidLogLevelString(const std::string &_value)
+{
+  bool isValidString{};
+
+  for (const auto &logLevelString : this->level)
+  {
+    isValidString = logLevelString.second == _value;
+
+    if (isValidString)
+    {
+      break;
+    }
+  }
+
+  return isValidString;
 }

source/ls_std/io/xml/XMLAttribute.cpp

@@ -1,40 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-23
- * Changed:         2021-04-23
- *
- * */
-
-#include <ls_std/io/xml/XMLAttribute.hpp>
-
-ls_std::XMLAttribute::XMLAttribute(std::string _name)
-    : ls_std::Class("XMLAttribute"),
-      name(std::move(_name))
-{}
-
-std::string ls_std::XMLAttribute::getName()
-{
-  return this->name;
-}
-
-std::string ls_std::XMLAttribute::getValue()
-{
-  return this->value;
-}
-
-void ls_std::XMLAttribute::setName(std::string _name)
-{
-  this->name = std::move(_name);
-}
-
-void ls_std::XMLAttribute::setValue(std::string _value)
-{
-  this->value = std::move(_value);
-}
-
-std::string ls_std::XMLAttribute::toXML()
-{
-  return this->name + "=\"" + this->value + "\"";
-}

source/ls_std/io/xml/XMLDeclaration.cpp

@@ -1,68 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-29
- * Changed:         2021-04-23
- *
- * */
-
-#include <ls_std/io/xml/XMLDeclaration.hpp>
-
-ls_std::XMLDeclaration::XMLDeclaration(std::string _version) : ls_std::Class("XMLDeclaration")
-{
-  this->version.setValue(std::move(_version));
-}
-
-std::string ls_std::XMLDeclaration::getEncoding()
-{
-  return this->encoding.getValue();
-}
-
-std::string ls_std::XMLDeclaration::getStandalone()
-{
-  return this->standalone.getValue();
-}
-
-std::string ls_std::XMLDeclaration::getVersion()
-{
-  return this->version.getValue();
-}
-
-void ls_std::XMLDeclaration::setEncoding(std::string _encoding)
-{
-  this->encoding.setValue(std::move(_encoding));
-}
-
-void ls_std::XMLDeclaration::setStandalone(std::string _standalone)
-{
-  this->standalone.setValue(std::move(_standalone));
-}
-
-void ls_std::XMLDeclaration::setVersion(std::string _version)
-{
-  this->version.setValue(std::move(_version));
-}
-
-std::string ls_std::XMLDeclaration::toXML()
-{
-  std::string declaration = "<?xml";
-
-  declaration += ls_std::XMLDeclaration::_toXMLAttribute(this->version);
-  declaration += ls_std::XMLDeclaration::_toXMLAttribute(this->encoding);
-  declaration += ls_std::XMLDeclaration::_toXMLAttribute(this->standalone);
-
-  return declaration + " ?>";
-}
-
-std::string ls_std::XMLDeclaration::_toXMLAttribute(ls_std::XMLAttribute _attribute)
-{
-  std::string xmlString{};
-
-  if (!_attribute.getValue().empty())
-  {
-    xmlString = " " + _attribute.toXML();
-  }
-
-  return xmlString;
-}

source/ls_std/io/xml/XMLDocument.cpp

@@ -1,50 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-09-30
- * Changed:         2021-04-23
- *
- * */
-
-#include <ls_std/io/xml/XMLDocument.hpp>
-
-ls_std::XMLDocument::XMLDocument() : ls_std::Class("XMLDocument")
-{}
-
-std::shared_ptr<ls_std::XMLDeclaration> ls_std::XMLDocument::getDeclaration()
-{
-  return this->declaration;
-}
-
-std::shared_ptr<ls_std::XMLNode> ls_std::XMLDocument::getRootElement()
-{
-  return this->rootElement;
-}
-
-void ls_std::XMLDocument::setDeclaration(const std::shared_ptr<ls_std::XMLDeclaration> &_declaration)
-{
-  this->declaration = _declaration;
-}
-
-void ls_std::XMLDocument::setRootElement(const std::shared_ptr<ls_std::XMLNode> &_root)
-{
-  this->rootElement = _root;
-}
-
-std::string ls_std::XMLDocument::toXML()
-{
-  std::string xmlString{};
-
-  if (this->declaration != nullptr)
-  {
-    xmlString = this->declaration->toXML();
-
-    if (!xmlString.empty())
-    {
-      xmlString += "\n";
-    }
-  }
-
-  return xmlString + this->rootElement->toXML();
-}

source/ls_std/io/xml/XMLParserMock.cpp

@@ -1,23 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-10-18
- * Changed:         2020-11-26
- *
- * */
-
-#include <ls_std/io/xml/XMLParserMock.hpp>
-
-ls_std::XMLParserMock::XMLParserMock() : ls_std::XMLParser(nullptr)
-{}
-
-std::pair<std::string, std::string> ls_std::XMLParserMock::readAttribute(const ls_std::byte_field &_data)
-{
-  return ls_std::XMLParser::_readAttribute_(_data);
-}
-
-std::list<std::pair<std::string, std::string>> ls_std::XMLParserMock::readAttributes(ls_std::byte_field _data)
-{
-  return ls_std::XMLParser::_readAttributes_(std::move(_data));
-}

source/ls_std/io/xml/XmlAttribute.cpp

@@ -0,0 +1,40 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-09-23
+ * Changed:         2021-05-02
+ *
+ * */
+
+#include <ls_std/io/xml/XmlAttribute.hpp>
+
+ls_std::XmlAttribute::XmlAttribute(std::string _name)
+    : ls_std::Class("XmlAttribute"),
+      name(std::move(_name))
+{}
+
+std::string ls_std::XmlAttribute::getName()
+{
+  return this->name;
+}
+
+std::string ls_std::XmlAttribute::getValue()
+{
+  return this->value;
+}
+
+void ls_std::XmlAttribute::setName(std::string _name)
+{
+  this->name = std::move(_name);
+}
+
+void ls_std::XmlAttribute::setValue(std::string _value)
+{
+  this->value = std::move(_value);
+}
+
+std::string ls_std::XmlAttribute::toXml()
+{
+  return this->name + "=\"" + this->value + "\"";
+}

source/ls_std/io/xml/XmlDeclaration.cpp

@@ -0,0 +1,68 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-09-29
+ * Changed:         2021-05-02
+ *
+ * */
+
+#include <ls_std/io/xml/XmlDeclaration.hpp>
+
+ls_std::XmlDeclaration::XmlDeclaration(std::string _version) : ls_std::Class("XmlDeclaration")
+{
+  this->version.setValue(std::move(_version));
+}
+
+std::string ls_std::XmlDeclaration::getEncoding()
+{
+  return this->encoding.getValue();
+}
+
+std::string ls_std::XmlDeclaration::getStandalone()
+{
+  return this->standalone.getValue();
+}
+
+std::string ls_std::XmlDeclaration::getVersion()
+{
+  return this->version.getValue();
+}
+
+void ls_std::XmlDeclaration::setEncoding(std::string _encoding)
+{
+  this->encoding.setValue(std::move(_encoding));
+}
+
+void ls_std::XmlDeclaration::setStandalone(std::string _standalone)
+{
+  this->standalone.setValue(std::move(_standalone));
+}
+
+void ls_std::XmlDeclaration::setVersion(std::string _version)
+{
+  this->version.setValue(std::move(_version));
+}
+
+std::string ls_std::XmlDeclaration::toXml()
+{
+  std::string declaration = "<?xml";
+
+  declaration += ls_std::XmlDeclaration::_toXmlAttribute(this->version);
+  declaration += ls_std::XmlDeclaration::_toXmlAttribute(this->encoding);
+  declaration += ls_std::XmlDeclaration::_toXmlAttribute(this->standalone);
+
+  return declaration + " ?>";
+}
+
+std::string ls_std::XmlDeclaration::_toXmlAttribute(ls_std::XmlAttribute _attribute)
+{
+  std::string xmlString{};
+
+  if (!_attribute.getValue().empty())
+  {
+    xmlString = " " + _attribute.toXml();
+  }
+
+  return xmlString;
+}

source/ls_std/io/xml/XmlDocument.cpp

@@ -0,0 +1,50 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-09-30
+ * Changed:         2021-05-02
+ *
+ * */
+
+#include <ls_std/io/xml/XmlDocument.hpp>
+
+ls_std::XmlDocument::XmlDocument() : ls_std::Class("XmlDocument")
+{}
+
+std::shared_ptr<ls_std::XmlDeclaration> ls_std::XmlDocument::getDeclaration()
+{
+  return this->declaration;
+}
+
+std::shared_ptr<ls_std::XmlNode> ls_std::XmlDocument::getRootElement()
+{
+  return this->rootElement;
+}
+
+void ls_std::XmlDocument::setDeclaration(const std::shared_ptr<ls_std::XmlDeclaration> &_declaration)
+{
+  this->declaration = _declaration;
+}
+
+void ls_std::XmlDocument::setRootElement(const std::shared_ptr<ls_std::XmlNode> &_root)
+{
+  this->rootElement = _root;
+}
+
+std::string ls_std::XmlDocument::toXml()
+{
+  std::string xmlString{};
+
+  if (this->declaration != nullptr)
+  {
+    xmlString = this->declaration->toXml();
+
+    if (!xmlString.empty())
+    {
+      xmlString += "\n";
+    }
+  }
+
+  return xmlString + this->rootElement->toXml();
+}

source/ls_std/io/xml/XMLNode.cpp → source/ls_std/io/xml/XmlNode.cpp

@@ -3,19 +3,19 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-24
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/io/xml/XMLNode.hpp>
+#include <ls_std/io/xml/XmlNode.hpp>
 #include <ls_std/utils/STLUtils.hpp>
 
-ls_std::XMLNode::XMLNode(std::string _name)
-    : ls_std::Class("XMLNode"),
+ls_std::XmlNode::XmlNode(std::string _name)
+    : ls_std::Class("XmlNode"),
       name(std::move(_name))
 {}
 
-bool ls_std::XMLNode::addAttributeAfter(const std::shared_ptr<ls_std::XMLAttribute> &_attribute, const std::string &_name)
+bool ls_std::XmlNode::addAttributeAfter(const std::shared_ptr<ls_std::XmlAttribute> &_attribute, const std::string &_name)
 {
   bool added{};
   auto iterator = this->attributes.begin();
@@ -39,7 +39,7 @@ bool ls_std::XMLNode::addAttributeAfter(const std::shared_ptr<ls_std::XMLAttribu
   return added;
 }
 
-bool ls_std::XMLNode::addAttributeBefore(const std::shared_ptr<ls_std::XMLAttribute> &_attribute, const std::string &_name)
+bool ls_std::XmlNode::addAttributeBefore(const std::shared_ptr<ls_std::XmlAttribute> &_attribute, const std::string &_name)
 {
   bool added{};
   auto iterator = this->attributes.begin();
@@ -62,7 +62,7 @@ bool ls_std::XMLNode::addAttributeBefore(const std::shared_ptr<ls_std::XMLAttrib
   return added;
 }
 
-bool ls_std::XMLNode::addAttributeToBeginning(const std::shared_ptr<ls_std::XMLAttribute> &_attribute)
+bool ls_std::XmlNode::addAttributeToBeginning(const std::shared_ptr<ls_std::XmlAttribute> &_attribute)
 {
   bool added{};
 
@@ -75,7 +75,7 @@ bool ls_std::XMLNode::addAttributeToBeginning(const std::shared_ptr<ls_std::XMLA
   return added;
 }
 
-bool ls_std::XMLNode::addAttributeToEnd(const std::shared_ptr<ls_std::XMLAttribute> &_attribute)
+bool ls_std::XmlNode::addAttributeToEnd(const std::shared_ptr<ls_std::XmlAttribute> &_attribute)
 {
   bool added{};
 
@@ -88,7 +88,7 @@ bool ls_std::XMLNode::addAttributeToEnd(const std::shared_ptr<ls_std::XMLAttribu
   return added;
 }
 
-bool ls_std::XMLNode::addChildAfter(const std::shared_ptr<ls_std::XMLNode> &_child, const std::shared_ptr<ls_std::XMLNode> &_search)
+bool ls_std::XmlNode::addChildAfter(const std::shared_ptr<ls_std::XmlNode> &_child, const std::shared_ptr<ls_std::XmlNode> &_search)
 {
   bool added{};
   auto iterator = this->children.begin();
@@ -112,7 +112,7 @@ bool ls_std::XMLNode::addChildAfter(const std::shared_ptr<ls_std::XMLNode> &_chi
   return added;
 }
 
-bool ls_std::XMLNode::addChildBefore(const std::shared_ptr<ls_std::XMLNode> &_child, const std::shared_ptr<ls_std::XMLNode> &_search)
+bool ls_std::XmlNode::addChildBefore(const std::shared_ptr<ls_std::XmlNode> &_child, const std::shared_ptr<ls_std::XmlNode> &_search)
 {
   bool added{};
   auto iterator = this->children.begin();
@@ -135,7 +135,7 @@ bool ls_std::XMLNode::addChildBefore(const std::shared_ptr<ls_std::XMLNode> &_ch
   return added;
 }
 
-bool ls_std::XMLNode::addChildToBeginning(const std::shared_ptr<ls_std::XMLNode> &_child)
+bool ls_std::XmlNode::addChildToBeginning(const std::shared_ptr<ls_std::XmlNode> &_child)
 {
   bool added{};
 
@@ -148,7 +148,7 @@ bool ls_std::XMLNode::addChildToBeginning(const std::shared_ptr<ls_std::XMLNode>
   return added;
 }
 
-bool ls_std::XMLNode::addChildToEnd(const std::shared_ptr<ls_std::XMLNode> &_child)
+bool ls_std::XmlNode::addChildToEnd(const std::shared_ptr<ls_std::XmlNode> &_child)
 {
   bool added{};
 
@@ -161,24 +161,24 @@ bool ls_std::XMLNode::addChildToEnd(const std::shared_ptr<ls_std::XMLNode> &_chi
   return added;
 }
 
-void ls_std::XMLNode::clearValue()
+void ls_std::XmlNode::clearValue()
 {
   this->value.clear();
 }
 
-std::list<std::shared_ptr<ls_std::XMLAttribute>> ls_std::XMLNode::getAttributes()
+std::list<std::shared_ptr<ls_std::XmlAttribute>> ls_std::XmlNode::getAttributes()
 {
   return this->attributes;
 }
 
-std::list<std::shared_ptr<ls_std::XMLNode>> ls_std::XMLNode::getChildren()
+std::list<std::shared_ptr<ls_std::XmlNode>> ls_std::XmlNode::getChildren()
 {
   return this->children;
 }
 
-std::list<std::shared_ptr<ls_std::XMLNode>> ls_std::XMLNode::getChildren(const std::string &_name)
+std::list<std::shared_ptr<ls_std::XmlNode>> ls_std::XmlNode::getChildren(const std::string &_name)
 {
-  std::list<std::shared_ptr<ls_std::XMLNode>> childrenWithName{};
+  std::list<std::shared_ptr<ls_std::XmlNode>> childrenWithName{};
 
   for (const auto &child : this->children)
   {
@@ -191,32 +191,32 @@ std::list<std::shared_ptr<ls_std::XMLNode>> ls_std::XMLNode::getChildren(const s
   return childrenWithName;
 }
 
-std::string ls_std::XMLNode::getName()
+std::string ls_std::XmlNode::getName()
 {
   return this->name;
 }
 
-std::string ls_std::XMLNode::getValue()
+std::string ls_std::XmlNode::getValue()
 {
   return this->value;
 }
 
-bool ls_std::XMLNode::hasAttribute(const std::string &_name)
+bool ls_std::XmlNode::hasAttribute(const std::string &_name)
 {
   return this->_hasAttribute(_name);
 }
 
-bool ls_std::XMLNode::hasChild(const std::string &_name)
+bool ls_std::XmlNode::hasChild(const std::string &_name)
 {
   return this->_hasChild(_name);
 }
 
-bool ls_std::XMLNode::hasChild(const std::shared_ptr<ls_std::XMLNode> &_child)
+bool ls_std::XmlNode::hasChild(const std::shared_ptr<ls_std::XmlNode> &_child)
 {
   return this->_hasChild(_child);
 }
 
-void ls_std::XMLNode::removeFirstAttribute()
+void ls_std::XmlNode::removeFirstAttribute()
 {
   if (!this->attributes.empty())
   {
@@ -224,7 +224,7 @@ void ls_std::XMLNode::removeFirstAttribute()
   }
 }
 
-void ls_std::XMLNode::removeLastAttribute()
+void ls_std::XmlNode::removeLastAttribute()
 {
   if (!this->attributes.empty())
   {
@@ -232,7 +232,7 @@ void ls_std::XMLNode::removeLastAttribute()
   }
 }
 
-void ls_std::XMLNode::removeFirstChild()
+void ls_std::XmlNode::removeFirstChild()
 {
   if (!this->children.empty())
   {
@@ -240,7 +240,7 @@ void ls_std::XMLNode::removeFirstChild()
   }
 }
 
-void ls_std::XMLNode::removeLastChild()
+void ls_std::XmlNode::removeLastChild()
 {
   if (!this->children.empty())
   {
@@ -248,38 +248,38 @@ void ls_std::XMLNode::removeLastChild()
   }
 }
 
-void ls_std::XMLNode::setName(std::string _name)
+void ls_std::XmlNode::setName(std::string _name)
 {
   this->name = std::move(_name);
 }
 
-void ls_std::XMLNode::setValue(std::string _value)
+void ls_std::XmlNode::setValue(std::string _value)
 {
   this->value = std::move(_value);
 }
 
-std::string ls_std::XMLNode::toXML()
+std::string ls_std::XmlNode::toXml()
 {
-  return this->_toXML_(0);
+  return this->_toXml_(0);
 }
 
-std::string ls_std::XMLNode::_toXML_(uint8_t _tabSize)
+std::string ls_std::XmlNode::_toXml_(uint8_t _tabSize)
 {
   std::string xmlStream{};
 
-  xmlStream += ls_std::XMLNode::_getTab(_tabSize);
-  xmlStream += this->_toXMLOpenTag();
-  xmlStream += this->_toXMLAttributes();
-  xmlStream += this->_toXMLOpenTagClose();
-  xmlStream += this->_toXMLValue();
-  xmlStream += this->_toXMLChildren(_tabSize + TAB_SIZE);
-  xmlStream += this->value.empty() ? ls_std::XMLNode::_getTab(_tabSize) : "";
-  xmlStream += this->_toXMLCloseTag() + "\n";
+  xmlStream += ls_std::XmlNode::_getTab(_tabSize);
+  xmlStream += this->_toXmlOpenTag();
+  xmlStream += this->_toXmlAttributes();
+  xmlStream += this->_toXmlOpenTagClose();
+  xmlStream += this->_toXmlValue();
+  xmlStream += this->_toXmlChildren(_tabSize + TAB_SIZE);
+  xmlStream += this->value.empty() ? ls_std::XmlNode::_getTab(_tabSize) : "";
+  xmlStream += this->_toXmlCloseTag() + "\n";
 
   return xmlStream;
 }
 
-std::string ls_std::XMLNode::_getTab(uint8_t _tabSize)
+std::string ls_std::XmlNode::_getTab(uint8_t _tabSize)
 {
   std::string tab{};
 
@@ -291,7 +291,7 @@ std::string ls_std::XMLNode::_getTab(uint8_t _tabSize)
   return tab;
 }
 
-bool ls_std::XMLNode::_hasAttribute(const std::string &_name)
+bool ls_std::XmlNode::_hasAttribute(const std::string &_name)
 {
   bool exists{};
 
@@ -307,12 +307,12 @@ bool ls_std::XMLNode::_hasAttribute(const std::string &_name)
   return exists;
 }
 
-bool ls_std::XMLNode::_hasChild(const std::shared_ptr<ls_std::XMLNode> &_child)
+bool ls_std::XmlNode::_hasChild(const std::shared_ptr<ls_std::XmlNode> &_child)
 {
   return ls_std::STLUtils::contains(this->children, _child);
 }
 
-bool ls_std::XMLNode::_hasChild(const std::string &_name)
+bool ls_std::XmlNode::_hasChild(const std::string &_name)
 {
   bool exists{};
 
@@ -328,19 +328,19 @@ bool ls_std::XMLNode::_hasChild(const std::string &_name)
   return exists;
 }
 
-std::string ls_std::XMLNode::_toXMLAttributes()
+std::string ls_std::XmlNode::_toXmlAttributes()
 {
   std::string stream{};
 
   for (const auto &_attribute : this->attributes)
   {
-    stream += " " + _attribute->toXML();
+    stream += " " + _attribute->toXml();
   }
 
   return stream;
 }
 
-std::string ls_std::XMLNode::_toXMLChildren(uint8_t _tabSize)
+std::string ls_std::XmlNode::_toXmlChildren(uint8_t _tabSize)
 {
   std::string stream{};
 
@@ -348,14 +348,14 @@ std::string ls_std::XMLNode::_toXMLChildren(uint8_t _tabSize)
   {
     for (const auto &_child : this->children)
     {
-      stream += _child->_toXML_(_tabSize);
+      stream += _child->_toXml_(_tabSize);
     }
   }
 
   return stream;
 }
 
-std::string ls_std::XMLNode::_toXMLCloseTag()
+std::string ls_std::XmlNode::_toXmlCloseTag()
 {
   std::string stream{};
 
@@ -367,12 +367,12 @@ std::string ls_std::XMLNode::_toXMLCloseTag()
   return stream;
 }
 
-std::string ls_std::XMLNode::_toXMLOpenTag()
+std::string ls_std::XmlNode::_toXmlOpenTag()
 {
   return "<" + this->name;
 }
 
-std::string ls_std::XMLNode::_toXMLOpenTagClose()
+std::string ls_std::XmlNode::_toXmlOpenTagClose()
 {
   std::string stream{};
 
@@ -388,7 +388,7 @@ std::string ls_std::XMLNode::_toXMLOpenTagClose()
   return stream;
 }
 
-std::string ls_std::XMLNode::_toXMLValue()
+std::string ls_std::XmlNode::_toXmlValue()
 {
   return this->value.empty() ? "\n" : this->value;
 }

source/ls_std/io/xml/XMLParser.cpp → source/ls_std/io/xml/XmlParser.cpp

@@ -3,48 +3,48 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/io/xml/XMLParser.hpp>
+#include <ls_std/io/xml/XmlParser.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 #include <ls_std/boxing/String.hpp>
 
-ls_std::XMLParser::XMLParser(const std::shared_ptr<ls_std::XMLDocument> &_document) : ls_std::Class("XMLParser")
+ls_std::XmlParser::XmlParser(const std::shared_ptr<ls_std::XmlDocument> &_document) : ls_std::Class("XmlParser")
 {
   this->_assignDocument(_document);
   this->_reset();
 }
 
-std::shared_ptr<ls_std::XMLDocument> ls_std::XMLParser::getDocument()
+std::shared_ptr<ls_std::XmlDocument> ls_std::XmlParser::getDocument()
 {
   return this->document;
 }
 
-void ls_std::XMLParser::parse(const ls_std::byte_field &_data)
+void ls_std::XmlParser::parse(const ls_std::byte_field &_data)
 {
   this->_parse(_data);
   this->_mergeNodes();
   this->_reset();
 }
 
-void ls_std::XMLParser::setDocument(const std::shared_ptr<ls_std::XMLDocument> &_document)
+void ls_std::XmlParser::setDocument(const std::shared_ptr<ls_std::XmlDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-std::pair<std::string, std::string> ls_std::XMLParser::_readAttribute_(const ls_std::byte_field &_data)
+std::pair<std::string, std::string> ls_std::XmlParser::_readAttribute_(const ls_std::byte_field &_data)
 {
-  return ls_std::XMLParser::_parseAttribute(_data);
+  return ls_std::XmlParser::_parseAttribute(_data);
 }
 
-std::list<std::pair<std::string, std::string>> ls_std::XMLParser::_readAttributes_(ls_std::byte_field _data)
+std::list<std::pair<std::string, std::string>> ls_std::XmlParser::_readAttributes_(ls_std::byte_field _data)
 {
-  return ls_std::XMLParser::_parseAttributes(std::move(_data));
+  return ls_std::XmlParser::_parseAttributes(std::move(_data));
 }
 
-void ls_std::XMLParser::_analyze(const ls_std::byte_field &_data, std::string::size_type _index)
+void ls_std::XmlParser::_analyze(const ls_std::byte_field &_data, std::string::size_type _index)
 {
   this->_isDeclaration(_data, _index);
   this->_isClosingTag(_data, _index);
@@ -52,7 +52,7 @@ void ls_std::XMLParser::_analyze(const ls_std::byte_field &_data, std::string::s
   this->_isValue(_data, _index);
 }
 
-void ls_std::XMLParser::_assignDocument(const std::shared_ptr<ls_std::XMLDocument> &_document)
+void ls_std::XmlParser::_assignDocument(const std::shared_ptr<ls_std::XmlDocument> &_document)
 {
   if (_document == nullptr)
   {
@@ -62,24 +62,24 @@ void ls_std::XMLParser::_assignDocument(const std::shared_ptr<ls_std::XMLDocumen
   this->document = _document;
 }
 
-std::shared_ptr<ls_std::XMLDeclaration> ls_std::XMLParser::_createDeclaration(const std::list<std::pair<std::string, std::string>> &_attributes)
+std::shared_ptr<ls_std::XmlDeclaration> ls_std::XmlParser::_createDeclaration(const std::list<std::pair<std::string, std::string>> &_attributes)
 {
-  std::shared_ptr<ls_std::XMLDeclaration> declaration = std::make_shared<ls_std::XMLDeclaration>("1.0");
-  std::pair<std::string, std::string> attribute = ls_std::XMLParser::_findAttribute(_attributes, "version");
+  std::shared_ptr<ls_std::XmlDeclaration> declaration = std::make_shared<ls_std::XmlDeclaration>("1.0");
+  std::pair<std::string, std::string> attribute = ls_std::XmlParser::_findAttribute(_attributes, "version");
 
   if (!attribute.first.empty())
   {
     declaration->setVersion(attribute.second);
   }
 
-  attribute = ls_std::XMLParser::_findAttribute(_attributes, "encoding");
+  attribute = ls_std::XmlParser::_findAttribute(_attributes, "encoding");
 
   if (!attribute.first.empty())
   {
     declaration->setEncoding(attribute.second);
   }
 
-  attribute = ls_std::XMLParser::_findAttribute(_attributes, "standalone");
+  attribute = ls_std::XmlParser::_findAttribute(_attributes, "standalone");
 
   if (!attribute.first.empty())
   {
@@ -89,14 +89,14 @@ std::shared_ptr<ls_std::XMLDeclaration> ls_std::XMLParser::_createDeclaration(co
   return declaration;
 }
 
-std::shared_ptr<ls_std::XMLNode> ls_std::XMLParser::_createNode(const std::list<std::pair<std::string, std::string>> &_attributes, const std::string &_name)
+std::shared_ptr<ls_std::XmlNode> ls_std::XmlParser::_createNode(const std::list<std::pair<std::string, std::string>> &_attributes, const std::string &_name)
 {
-  std::shared_ptr<ls_std::XMLNode> node = std::make_shared<ls_std::XMLNode>(_name);
-  std::shared_ptr<ls_std::XMLAttribute> attribute{};
+  std::shared_ptr<ls_std::XmlNode> node = std::make_shared<ls_std::XmlNode>(_name);
+  std::shared_ptr<ls_std::XmlAttribute> attribute{};
 
   for (const auto &parsedAttribute : _attributes)
   {
-    attribute = std::make_shared<ls_std::XMLAttribute>(parsedAttribute.first);
+    attribute = std::make_shared<ls_std::XmlAttribute>(parsedAttribute.first);
     attribute->setValue(parsedAttribute.second);
     node->addAttributeToEnd(attribute);
   }
@@ -104,7 +104,7 @@ std::shared_ptr<ls_std::XMLNode> ls_std::XMLParser::_createNode(const std::list<
   return node;
 }
 
-std::pair<std::string, std::string> ls_std::XMLParser::_findAttribute(const std::list<std::pair<std::string, std::string>> &_attributes, const std::string &_name)
+std::pair<std::string, std::string> ls_std::XmlParser::_findAttribute(const std::list<std::pair<std::string, std::string>> &_attributes, const std::string &_name)
 {
   std::pair<std::string, std::string> attribute{};
 
@@ -120,7 +120,7 @@ std::pair<std::string, std::string> ls_std::XMLParser::_findAttribute(const std:
   return attribute;
 }
 
-size_t ls_std::XMLParser::_findAttributeEndPosition(const ls_std::byte_field &_data)
+size_t ls_std::XmlParser::_findAttributeEndPosition(const ls_std::byte_field &_data)
 {
   std::string::size_type position = std::string::npos;
   std::string::size_type counter{};
@@ -143,7 +143,7 @@ size_t ls_std::XMLParser::_findAttributeEndPosition(const ls_std::byte_field &_d
   return position;
 }
 
-ls_std::byte_field ls_std::XMLParser::_getNextTagString(const ls_std::byte_field &_data, std::string::size_type _index)
+ls_std::byte_field ls_std::XmlParser::_getNextTagString(const ls_std::byte_field &_data, std::string::size_type _index)
 {
   ls_std::byte_field tag{};
   size_t closingCharacterPosition = _index + _data.substr(_index).find('>');
@@ -156,7 +156,7 @@ ls_std::byte_field ls_std::XMLParser::_getNextTagString(const ls_std::byte_field
   return tag;
 }
 
-void ls_std::XMLParser::_isClosingTag(const ls_std::byte_field &_data, std::string::size_type _index)
+void ls_std::XmlParser::_isClosingTag(const ls_std::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::XMLParser::_isClosingTag(const ls_std::byte_field &_data, std::stri
   }
 }
 
-void ls_std::XMLParser::_isDeclaration(const ls_std::byte_field &_data, std::string::size_type _index)
+void ls_std::XmlParser::_isDeclaration(const ls_std::byte_field &_data, std::string::size_type _index)
 {
   if (_data.substr(_index, 5) == "<?xml")
   {
@@ -172,7 +172,7 @@ void ls_std::XMLParser::_isDeclaration(const ls_std::byte_field &_data, std::str
   }
 }
 
-void ls_std::XMLParser::_isOpeningTag(const ls_std::byte_field &_data, std::string::size_type _index)
+void ls_std::XmlParser::_isOpeningTag(const ls_std::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::XMLParser::_isOpeningTag(const ls_std::byte_field &_data, std::stri
   }
 }
 
-void ls_std::XMLParser::_isValue(const ls_std::byte_field &_data, std::string::size_type _index)
+void ls_std::XmlParser::_isValue(const ls_std::byte_field &_data, std::string::size_type _index)
 {
   if (this->mode == XML_PARSE_MODE_ANALYZE)
   {
@@ -199,7 +199,7 @@ void ls_std::XMLParser::_isValue(const ls_std::byte_field &_data, std::string::s
   }
 }
 
-void ls_std::XMLParser::_mergeNodes()
+void ls_std::XmlParser::_mergeNodes()
 {
   while (this->maxLevel > 1)
   {
@@ -207,16 +207,16 @@ void ls_std::XMLParser::_mergeNodes()
     this->maxLevel -= 1;
   }
 
-  this->document->setRootElement(this->parseData.front().node);
+  this->document->setRootElement(this->parseParameters.front().node);
 }
 
-void ls_std::XMLParser::_mergeChildrenToParentNode(const std::shared_ptr<ls_std::XMLNode> &_parent, std::list<ls_std::XMLParseData>::iterator &_iterator, uint8_t _parentLevel)
+void ls_std::XmlParser::_mergeChildrenToParentNode(const std::shared_ptr<ls_std::XmlNode> &_parent, std::list<ls_std::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel)
 {
   do
   {
     _iterator++;
 
-    if (_iterator == this->parseData.end())
+    if (_iterator == this->parseParameters.end())
     {
       break;
     }
@@ -230,12 +230,12 @@ void ls_std::XMLParser::_mergeChildrenToParentNode(const std::shared_ptr<ls_std:
   } while (_iterator->level > _parentLevel);
 }
 
-void ls_std::XMLParser::_mergeNodesOnCurrentLevel()
+void ls_std::XmlParser::_mergeNodesOnCurrentLevel()
 {
-  auto iterator = this->parseData.begin();
+  auto iterator = this->parseParameters.begin();
   uint8_t parentLevel = this->maxLevel - 1;
 
-  while (iterator != this->parseData.end())
+  while (iterator != this->parseParameters.end())
   {
     if (iterator->level == parentLevel)
     {
@@ -248,7 +248,7 @@ void ls_std::XMLParser::_mergeNodesOnCurrentLevel()
   }
 }
 
-void ls_std::XMLParser::_parse(const ls_std::byte_field &_data)
+void ls_std::XmlParser::_parse(const ls_std::byte_field &_data)
 {
   for (std::string::size_type index = 0; index < _data.size(); index++)
   {
@@ -269,21 +269,21 @@ void ls_std::XMLParser::_parse(const ls_std::byte_field &_data)
       case XML_PARSE_MODE_OPENING_TAG:
       {
         --index;
-        index = ls_std::XMLParser::_parseOpeningTag(_data, index);
+        index = ls_std::XmlParser::_parseOpeningTag(_data, index);
         this->mode = XML_PARSE_MODE_ANALYZE;
       }
         break;
       case XML_PARSE_MODE_VALUE:
       {
         --index;
-        index = ls_std::XMLParser::_parseValue(_data, index);
+        index = ls_std::XmlParser::_parseValue(_data, index);
         this->mode = XML_PARSE_MODE_ANALYZE;
       }
         break;
       case XML_PARSE_MODE_CLOSING_TAG:
       {
         --index;
-        index = ls_std::XMLParser::_parseClosingTag(_data, index);
+        index = ls_std::XmlParser::_parseClosingTag(_data, index);
         this->mode = XML_PARSE_MODE_ANALYZE;
       }
         break;
@@ -291,7 +291,7 @@ void ls_std::XMLParser::_parse(const ls_std::byte_field &_data)
   }
 }
 
-std::pair<std::string, std::string> ls_std::XMLParser::_parseAttribute(const ls_std::byte_field &_data)
+std::pair<std::string, std::string> ls_std::XmlParser::_parseAttribute(const ls_std::byte_field &_data)
 {
   std::pair<std::string, std::string> parsedAttribute{};
   parsedAttribute.first = _data.substr(0, _data.find('='));
@@ -301,7 +301,7 @@ std::pair<std::string, std::string> ls_std::XMLParser::_parseAttribute(const ls_
   return parsedAttribute;
 }
 
-std::list<std::pair<std::string, std::string>> ls_std::XMLParser::_parseAttributes(ls_std::byte_field _data)
+std::list<std::pair<std::string, std::string>> ls_std::XmlParser::_parseAttributes(ls_std::byte_field _data)
 {
   std::list<std::pair<std::string, std::string>> attributes{};
   size_t position = _data.find(' ');
@@ -319,48 +319,48 @@ std::list<std::pair<std::string, std::string>> ls_std::XMLParser::_parseAttribut
       break;
     }
 
-    std::string attributeString = _data.substr(position, ls_std::XMLParser::_findAttributeEndPosition(_data) + 1);
-    attributes.push_back(ls_std::XMLParser::_parseAttribute(attributeString));
+    std::string attributeString = _data.substr(position, ls_std::XmlParser::_findAttributeEndPosition(_data) + 1);
+    attributes.push_back(ls_std::XmlParser::_parseAttribute(attributeString));
     _data = _data.substr(position + attributeString.size());
   }
 
   return attributes;
 }
 
-size_t ls_std::XMLParser::_parseClosingTag(const ls_std::byte_field &_data, std::string::size_type _index)
+size_t ls_std::XmlParser::_parseClosingTag(const ls_std::byte_field &_data, std::string::size_type _index)
 {
-  std::string tagString = ls_std::XMLParser::_getNextTagString(_data, _index);
+  std::string tagString = ls_std::XmlParser::_getNextTagString(_data, _index);
   this->currentLevel -= 1;
   return tagString.empty() ? _index : _index + (tagString.size() - 1);
 }
 
-size_t ls_std::XMLParser::_parseDeclaration(const ls_std::byte_field &_data, std::string::size_type _index)
+size_t ls_std::XmlParser::_parseDeclaration(const ls_std::byte_field &_data, std::string::size_type _index)
 {
-  std::string tagString = ls_std::XMLParser::_getNextTagString(_data, _index);
+  std::string tagString = ls_std::XmlParser::_getNextTagString(_data, _index);
   bool isValidTagString = !tagString.empty();
 
   if (isValidTagString)
   {
-    std::shared_ptr<ls_std::XMLDeclaration> declaration = this->_createDeclaration(ls_std::XMLParser::_parseAttributes(tagString));
+    std::shared_ptr<ls_std::XmlDeclaration> declaration = this->_createDeclaration(ls_std::XmlParser::_parseAttributes(tagString));
     this->document->setDeclaration(declaration);
   }
 
   return !isValidTagString ? _index : _index + (tagString.size() - 1);
 }
 
-size_t ls_std::XMLParser::_parseOpeningTag(const ls_std::byte_field &_data, std::string::size_type _index)
+size_t ls_std::XmlParser::_parseOpeningTag(const ls_std::byte_field &_data, std::string::size_type _index)
 {
-  ls_std::String tagString{ls_std::XMLParser::_getNextTagString(_data, _index)};
+  ls_std::String tagString{ls_std::XmlParser::_getNextTagString(_data, _index)};
   bool isValidTagString = !tagString.toString().empty();
-  ls_std::XMLParseData singleParseData{};
+  ls_std::XmlParseParameter singleParseParameter{};
 
   if (isValidTagString)
   {
-    std::shared_ptr<ls_std::XMLNode> node = ls_std::XMLParser::_createNode(ls_std::XMLParser::_parseAttributes(tagString), ls_std::XMLParser::_parseTagName(tagString));
+    std::shared_ptr<ls_std::XmlNode> node = ls_std::XmlParser::_createNode(ls_std::XmlParser::_parseAttributes(tagString), ls_std::XmlParser::_parseTagName(tagString));
 
-    singleParseData.level = this->currentLevel;
-    singleParseData.node = node;
-    this->parseData.push_back(singleParseData);
+    singleParseParameter.level = this->currentLevel;
+    singleParseParameter.node = node;
+    this->parseParameters.push_back(singleParseParameter);
 
     if (!tagString.endsWith("/>"))
     {
@@ -372,7 +372,7 @@ size_t ls_std::XMLParser::_parseOpeningTag(const ls_std::byte_field &_data, std:
   return !isValidTagString ? _index : _index + (tagString.toString().size() - 1);
 }
 
-ls_std::byte_field ls_std::XMLParser::_parseTagName(const ls_std::byte_field &_data)
+ls_std::byte_field ls_std::XmlParser::_parseTagName(const ls_std::byte_field &_data)
 {
   std::string::size_type position = _data.find(' ');
 
@@ -384,23 +384,23 @@ ls_std::byte_field ls_std::XMLParser::_parseTagName(const ls_std::byte_field &_d
   return _data.substr(1, position - 1);
 }
 
-size_t ls_std::XMLParser::_parseValue(const ls_std::byte_field &_data, std::string::size_type _index)
+size_t ls_std::XmlParser::_parseValue(const ls_std::byte_field &_data, std::string::size_type _index)
 {
   ls_std::byte_field value = _data.substr(_index, _data.substr(_index).find('<'));
-  this->parseData.back().node->setValue(value);
+  this->parseParameters.back().node->setValue(value);
 
   return _index + (value.size() - 1);
 }
 
-void ls_std::XMLParser::_reset()
+void ls_std::XmlParser::_reset()
 {
   this->currentLevel = 1;
   this->maxLevel = 1;
   this->mode = XML_PARSE_MODE_ANALYZE;
-  this->parseData.clear();
+  this->parseParameters.clear();
 }
 
-void ls_std::XMLParser::_setMaxLevel()
+void ls_std::XmlParser::_setMaxLevel()
 {
   if (this->currentLevel > this->maxLevel)
   {

source/ls_std/io/xml/XMLReader.cpp → source/ls_std/io/xml/XmlReader.cpp

@@ -3,48 +3,48 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-10
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/io/xml/XMLReader.hpp>
+#include <ls_std/io/xml/XmlReader.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 #include <ls_std/io/FileReader.hpp>
 #include <ls_std/boxing/String.hpp>
-#include <ls_std/io/xml/XMLParser.hpp>
+#include <ls_std/io/xml/XmlParser.hpp>
 
-ls_std::XMLReader::XMLReader(const std::shared_ptr<ls_std::XMLDocument> &_document, const std::string &_absolutePath)
-    : ls_std::Class("XMLReader"),
+ls_std::XmlReader::XmlReader(const std::shared_ptr<ls_std::XmlDocument> &_document, const std::string &_absolutePath)
+    : ls_std::Class("XmlReader"),
       xmlFile(ls_std::File{""})
 {
   this->_assignDocument(_document);
   this->_assignFile(ls_std::File{_absolutePath});
 }
 
-ls_std::byte_field ls_std::XMLReader::read()
+ls_std::byte_field ls_std::XmlReader::read()
 {
   ls_std::byte_field data = ls_std::FileReader{this->xmlFile}.read();
-  ls_std::XMLParser{this->document}.parse(data);
+  ls_std::XmlParser{this->document}.parse(data);
 
   return data;
 }
 
-std::shared_ptr<ls_std::XMLDocument> ls_std::XMLReader::getDocument()
+std::shared_ptr<ls_std::XmlDocument> ls_std::XmlReader::getDocument()
 {
   return this->document;
 }
 
-void ls_std::XMLReader::setDocument(const std::shared_ptr<ls_std::XMLDocument> &_document)
+void ls_std::XmlReader::setDocument(const std::shared_ptr<ls_std::XmlDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-void ls_std::XMLReader::setFile(const ls_std::File &_xmlFile)
+void ls_std::XmlReader::setFile(const ls_std::File &_xmlFile)
 {
   this->_assignFile(_xmlFile);
 }
 
-void ls_std::XMLReader::_assignDocument(const std::shared_ptr<ls_std::XMLDocument> &_document)
+void ls_std::XmlReader::_assignDocument(const std::shared_ptr<ls_std::XmlDocument> &_document)
 {
   if (_document == nullptr)
   {
@@ -54,7 +54,7 @@ void ls_std::XMLReader::_assignDocument(const std::shared_ptr<ls_std::XMLDocumen
   this->document = _document;
 }
 
-void ls_std::XMLReader::_assignFile(ls_std::File _xmlFile)
+void ls_std::XmlReader::_assignFile(ls_std::File _xmlFile)
 {
   if (!_xmlFile.exists())
   {

source/ls_std/logic/IListener.cpp

@@ -1,13 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-11-14
- * Changed:         2020-11-26
- *
- * */
-
-#include "../../../include/ls_std/logic/IListener.hpp"
-
-ls_std::IListener::IListener() : ls_std::Class("IListener")
-{}

source/ls_std/logic/Narrator.cpp

@@ -3,22 +3,35 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2021-04-23
+ * Changed:         2021-05-27
  *
  * */
 
 #include <ls_std/utils/STLUtils.hpp>
-#include "../../../include/ls_std/logic/Narrator.hpp"
+#include <ls_std/logic/Narrator.hpp>
+#include <ls_std/exception/IllegalArgumentException.hpp>
 
 ls_std::Narrator::Narrator() : ls_std::Class("Narrator")
 {}
 
-void ls_std::Narrator::addListener(const std::shared_ptr<ls_std::IListener> &_listener)
+bool ls_std::Narrator::addListener(const std::shared_ptr<ls_std::IListener> &_listener)
 {
-  if (!ls_std::STLUtils::contains(this->listeners, _listener))
+  bool wasAdded{};
+
+  if (_listener == nullptr)
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+  else
   {
-    this->listeners.push_back(_listener);
+    if (!ls_std::STLUtils::contains(this->listeners, _listener))
+    {
+      this->listeners.push_back(_listener);
+      wasAdded = true;
+    }
   }
+
+  return wasAdded;
 }
 
 void ls_std::Narrator::clear()
@@ -31,12 +44,24 @@ std::list<std::shared_ptr<ls_std::IListener>> ls_std::Narrator::getListeners()
   return this->listeners;
 }
 
-void ls_std::Narrator::removeListener(const std::shared_ptr<ls_std::IListener> &_listener)
+bool ls_std::Narrator::removeListener(const std::shared_ptr<ls_std::IListener> &_listener)
 {
-  if (ls_std::STLUtils::contains(this->listeners, _listener))
+  bool wasRemoved{};
+
+  if (_listener == nullptr)
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+  else
   {
-    this->listeners.remove(_listener);
+    if (ls_std::STLUtils::contains(this->listeners, _listener))
+    {
+      this->listeners.remove(_listener);
+      wasRemoved = true;
+    }
   }
+
+  return wasRemoved;
 }
 
 void ls_std::Narrator::tell(const ls_std::Class &_info)

source/ls_std/logic/StateConnection.cpp

@@ -3,17 +3,18 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-10
- * Changed:         2021-04-23
+ * Changed:         2021-05-27
  *
  * */
 
 #include <ls_std/logic/StateConnection.hpp>
+#include <ls_std/exception/IllegalArgumentException.hpp>
 
-ls_std::StateConnection::StateConnection(ls_std::StateConnectionId _connectionId, ls_std::StateId _stateId)
-    : ls_std::Class("StateConnection"),
-      connectionId(std::move(_connectionId)),
-      stateId(std::move(_stateId))
-{}
+ls_std::StateConnection::StateConnection(const ls_std::StateConnectionId& _connectionId, const ls_std::StateId& _stateId) : ls_std::Class("StateConnection")
+{
+  this->_assignConnectionId(_connectionId);
+  this->_assignStateId(_stateId);
+}
 
 ls_std::StateConnectionId ls_std::StateConnection::getConnectionId()
 {
@@ -30,17 +31,37 @@ bool ls_std::StateConnection::isPassable() const
   return this->condition;
 }
 
-void ls_std::StateConnection::setConnectionId(ls_std::StateConnectionId _connectionId)
+void ls_std::StateConnection::setConnectionId(const ls_std::StateConnectionId& _connectionId)
 {
-  this->connectionId = std::move(_connectionId);
+  this->_assignConnectionId(_connectionId);
 }
 
-void ls_std::StateConnection::setStateId(ls_std::StateId _stateId)
+void ls_std::StateConnection::setStateId(const ls_std::StateId& _stateId)
 {
-  this->stateId = std::move(_stateId);
+  this->_assignStateId(_stateId);
 }
 
 void ls_std::StateConnection::updatePassCondition(bool _condition)
 {
   this->condition = _condition;
 }
+
+void ls_std::StateConnection::_assignConnectionId(const ls_std::StateConnectionId &_connectionId)
+{
+  if (_connectionId.empty())
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+
+  this->connectionId = _connectionId;
+}
+
+void ls_std::StateConnection::_assignStateId(const ls_std::StateId &_stateId)
+{
+  if (_stateId.empty())
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+
+  this->stateId = _stateId;
+}

source/ls_std/serialization/json/boxing/SerializableJSONBoolean.cpp → source/ls_std/serialization/json/boxing/SerializableJsonBoolean.cpp

@@ -3,25 +3,25 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-04
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/serialization/json/boxing/SerializableJSONBoolean.hpp>
+#include <ls_std/serialization/json/boxing/SerializableJsonBoolean.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
-ls_std::SerializableJSONBoolean::SerializableJSONBoolean(const std::shared_ptr<ls_std::Boolean> &_value) : ls_std::Class("SerializableJSONBoolean")
+ls_std::SerializableJsonBoolean::SerializableJsonBoolean(const std::shared_ptr<ls_std::Boolean> &_value) : ls_std::Class("SerializableJsonBoolean")
 {
   this->_assignValue(_value);
 }
 
-ls_std::byte_field ls_std::SerializableJSONBoolean::marshal()
+ls_std::byte_field ls_std::SerializableJsonBoolean::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls_std::SerializableJSONBoolean::unmarshal(const ls_std::byte_field &_data)
+void ls_std::SerializableJsonBoolean::unmarshal(const ls_std::byte_field &_data)
 {
   this->jsonObject = nlohmann::json::parse(_data);
 
@@ -31,17 +31,17 @@ void ls_std::SerializableJSONBoolean::unmarshal(const ls_std::byte_field &_data)
   }
 }
 
-std::shared_ptr<ls_std::Boolean> ls_std::SerializableJSONBoolean::getValue()
+std::shared_ptr<ls_std::Boolean> ls_std::SerializableJsonBoolean::getValue()
 {
   return this->value;
 }
 
-void ls_std::SerializableJSONBoolean::setValue(const std::shared_ptr<ls_std::Boolean> &_value)
+void ls_std::SerializableJsonBoolean::setValue(const std::shared_ptr<ls_std::Boolean> &_value)
 {
   this->_assignValue(_value);
 }
 
-void ls_std::SerializableJSONBoolean::_assignValue(const std::shared_ptr<ls_std::Boolean> &_value)
+void ls_std::SerializableJsonBoolean::_assignValue(const std::shared_ptr<ls_std::Boolean> &_value)
 {
   if (_value == nullptr)
   {
@@ -51,7 +51,7 @@ void ls_std::SerializableJSONBoolean::_assignValue(const std::shared_ptr<ls_std:
   this->value = _value;
 }
 
-void ls_std::SerializableJSONBoolean::_update()
+void ls_std::SerializableJsonBoolean::_update()
 {
   this->jsonObject = {{"value", this->value->getValue()}};
 }

source/ls_std/serialization/json/boxing/SerializableJSONDouble.cpp → source/ls_std/serialization/json/boxing/SerializableJsonDouble.cpp

@@ -3,25 +3,25 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-04
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/serialization/json/boxing/SerializableJSONDouble.hpp>
+#include <ls_std/serialization/json/boxing/SerializableJsonDouble.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
-ls_std::SerializableJSONDouble::SerializableJSONDouble(const std::shared_ptr<ls_std::Double> &_value) : ls_std::Class("SerializableJSONDouble")
+ls_std::SerializableJsonDouble::SerializableJsonDouble(const std::shared_ptr<ls_std::Double> &_value) : ls_std::Class("SerializableJsonDouble")
 {
   this->_assignValue(_value);
 }
 
-ls_std::byte_field ls_std::SerializableJSONDouble::marshal()
+ls_std::byte_field ls_std::SerializableJsonDouble::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls_std::SerializableJSONDouble::unmarshal(const ls_std::byte_field &_data)
+void ls_std::SerializableJsonDouble::unmarshal(const ls_std::byte_field &_data)
 {
   std::string jsonString = std::string(_data);
   this->jsonObject = nlohmann::json::parse(jsonString);
@@ -32,17 +32,17 @@ void ls_std::SerializableJSONDouble::unmarshal(const ls_std::byte_field &_data)
   }
 }
 
-std::shared_ptr<ls_std::Double> ls_std::SerializableJSONDouble::getValue()
+std::shared_ptr<ls_std::Double> ls_std::SerializableJsonDouble::getValue()
 {
   return this->value;
 }
 
-void ls_std::SerializableJSONDouble::setValue(const std::shared_ptr<ls_std::Double> &_value)
+void ls_std::SerializableJsonDouble::setValue(const std::shared_ptr<ls_std::Double> &_value)
 {
   this->_assignValue(_value);
 }
 
-void ls_std::SerializableJSONDouble::_assignValue(const std::shared_ptr<ls_std::Double> &_value)
+void ls_std::SerializableJsonDouble::_assignValue(const std::shared_ptr<ls_std::Double> &_value)
 {
   if (_value == nullptr)
   {
@@ -52,7 +52,7 @@ void ls_std::SerializableJSONDouble::_assignValue(const std::shared_ptr<ls_std::
   this->value = _value;
 }
 
-void ls_std::SerializableJSONDouble::_update()
+void ls_std::SerializableJsonDouble::_update()
 {
   this->jsonObject = {{"value", this->value->getValue()}};
 }

source/ls_std/serialization/json/boxing/SerializableJSONFloat.cpp → source/ls_std/serialization/json/boxing/SerializableJsonFloat.cpp

@@ -3,25 +3,25 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-04
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/serialization/json/boxing/SerializableJSONFloat.hpp>
+#include <ls_std/serialization/json/boxing/SerializableJsonFloat.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
-ls_std::SerializableJSONFloat::SerializableJSONFloat(const std::shared_ptr<ls_std::Float> &_value) : ls_std::Class("SerializableJSONFloat")
+ls_std::SerializableJsonFloat::SerializableJsonFloat(const std::shared_ptr<ls_std::Float> &_value) : ls_std::Class("SerializableJsonFloat")
 {
   this->_assignValue(_value);
 }
 
-ls_std::byte_field ls_std::SerializableJSONFloat::marshal()
+ls_std::byte_field ls_std::SerializableJsonFloat::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls_std::SerializableJSONFloat::unmarshal(const ls_std::byte_field &_data)
+void ls_std::SerializableJsonFloat::unmarshal(const ls_std::byte_field &_data)
 {
   std::string jsonString = std::string(_data);
   this->jsonObject = nlohmann::json::parse(jsonString);
@@ -32,17 +32,17 @@ void ls_std::SerializableJSONFloat::unmarshal(const ls_std::byte_field &_data)
   }
 }
 
-std::shared_ptr<ls_std::Float> ls_std::SerializableJSONFloat::getValue()
+std::shared_ptr<ls_std::Float> ls_std::SerializableJsonFloat::getValue()
 {
   return this->value;
 }
 
-void ls_std::SerializableJSONFloat::setValue(const std::shared_ptr<ls_std::Float> &_value)
+void ls_std::SerializableJsonFloat::setValue(const std::shared_ptr<ls_std::Float> &_value)
 {
   this->_assignValue(_value);
 }
 
-void ls_std::SerializableJSONFloat::_assignValue(const std::shared_ptr<ls_std::Float> &_value)
+void ls_std::SerializableJsonFloat::_assignValue(const std::shared_ptr<ls_std::Float> &_value)
 {
   if (_value == nullptr)
   {
@@ -52,7 +52,7 @@ void ls_std::SerializableJSONFloat::_assignValue(const std::shared_ptr<ls_std::F
   this->value = _value;
 }
 
-void ls_std::SerializableJSONFloat::_update()
+void ls_std::SerializableJsonFloat::_update()
 {
   this->jsonObject = {{"value", this->value->getValue()}};
 }

source/ls_std/serialization/json/boxing/SerializableJSONInteger.cpp → source/ls_std/serialization/json/boxing/SerializableJsonInteger.cpp

@@ -3,25 +3,25 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-21
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/serialization/json/boxing/SerializableJSONInteger.hpp>
+#include <ls_std/serialization/json/boxing/SerializableJsonInteger.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
-ls_std::SerializableJSONInteger::SerializableJSONInteger(const std::shared_ptr<ls_std::Integer> &_value) : ls_std::Class("SerializableJSONInteger")
+ls_std::SerializableJsonInteger::SerializableJsonInteger(const std::shared_ptr<ls_std::Integer> &_value) : ls_std::Class("SerializableJsonInteger")
 {
   this->_assignValue(_value);
 }
 
-ls_std::byte_field ls_std::SerializableJSONInteger::marshal()
+ls_std::byte_field ls_std::SerializableJsonInteger::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls_std::SerializableJSONInteger::unmarshal(const ls_std::byte_field &_data)
+void ls_std::SerializableJsonInteger::unmarshal(const ls_std::byte_field &_data)
 {
   std::string jsonString = std::string(_data);
   this->jsonObject = nlohmann::json::parse(jsonString);
@@ -32,17 +32,17 @@ void ls_std::SerializableJSONInteger::unmarshal(const ls_std::byte_field &_data)
   }
 }
 
-std::shared_ptr<ls_std::Integer> ls_std::SerializableJSONInteger::getValue()
+std::shared_ptr<ls_std::Integer> ls_std::SerializableJsonInteger::getValue()
 {
   return this->value;
 }
 
-void ls_std::SerializableJSONInteger::setValue(const std::shared_ptr<ls_std::Integer> &_value)
+void ls_std::SerializableJsonInteger::setValue(const std::shared_ptr<ls_std::Integer> &_value)
 {
   this->_assignValue(_value);
 }
 
-void ls_std::SerializableJSONInteger::_assignValue(const std::shared_ptr<ls_std::Integer> &_value)
+void ls_std::SerializableJsonInteger::_assignValue(const std::shared_ptr<ls_std::Integer> &_value)
 {
   if (_value == nullptr)
   {
@@ -52,7 +52,7 @@ void ls_std::SerializableJSONInteger::_assignValue(const std::shared_ptr<ls_std:
   this->value = _value;
 }
 
-void ls_std::SerializableJSONInteger::_update()
+void ls_std::SerializableJsonInteger::_update()
 {
   this->jsonObject = {{"value", this->value->getValue()}};
 }

source/ls_std/serialization/json/boxing/SerializableJSONLong.cpp → source/ls_std/serialization/json/boxing/SerializableJsonLong.cpp

@@ -3,25 +3,25 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-25
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/serialization/json/boxing/SerializableJSONLong.hpp>
+#include <ls_std/serialization/json/boxing/SerializableJsonLong.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
-ls_std::SerializableJSONLong::SerializableJSONLong(const std::shared_ptr<ls_std::Long> &_value) : ls_std::Class("SerializableJSONLong")
+ls_std::SerializableJsonLong::SerializableJsonLong(const std::shared_ptr<ls_std::Long> &_value) : ls_std::Class("SerializableJsonLong")
 {
   this->_assignValue(_value);
 }
 
-ls_std::byte_field ls_std::SerializableJSONLong::marshal()
+ls_std::byte_field ls_std::SerializableJsonLong::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls_std::SerializableJSONLong::unmarshal(const ls_std::byte_field &_data)
+void ls_std::SerializableJsonLong::unmarshal(const ls_std::byte_field &_data)
 {
   std::string jsonString = std::string(_data);
   this->jsonObject = nlohmann::json::parse(jsonString);
@@ -32,17 +32,17 @@ void ls_std::SerializableJSONLong::unmarshal(const ls_std::byte_field &_data)
   }
 }
 
-std::shared_ptr<ls_std::Long> ls_std::SerializableJSONLong::getValue()
+std::shared_ptr<ls_std::Long> ls_std::SerializableJsonLong::getValue()
 {
   return this->value;
 }
 
-void ls_std::SerializableJSONLong::setValue(const std::shared_ptr<ls_std::Long> &_value)
+void ls_std::SerializableJsonLong::setValue(const std::shared_ptr<ls_std::Long> &_value)
 {
   this->_assignValue(_value);
 }
 
-void ls_std::SerializableJSONLong::_assignValue(const std::shared_ptr<ls_std::Long> &_value)
+void ls_std::SerializableJsonLong::_assignValue(const std::shared_ptr<ls_std::Long> &_value)
 {
   if (_value == nullptr)
   {
@@ -52,7 +52,7 @@ void ls_std::SerializableJSONLong::_assignValue(const std::shared_ptr<ls_std::Lo
   this->value = _value;
 }
 
-void ls_std::SerializableJSONLong::_update()
+void ls_std::SerializableJsonLong::_update()
 {
   this->jsonObject = {{"value", (ls_std::long_type) this->value->getValue()}};
 }

source/ls_std/serialization/json/boxing/SerializableJSONString.cpp → source/ls_std/serialization/json/boxing/SerializableJsonString.cpp

@@ -3,25 +3,25 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-30
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/serialization/json/boxing/SerializableJSONString.hpp>
+#include <ls_std/serialization/json/boxing/SerializableJsonString.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
-ls_std::SerializableJSONString::SerializableJSONString(const std::shared_ptr<ls_std::String> &_value) : ls_std::Class("SerializableJSONString")
+ls_std::SerializableJsonString::SerializableJsonString(const std::shared_ptr<ls_std::String> &_value) : ls_std::Class("SerializableJsonString")
 {
   this->_assignValue(_value);
 }
 
-ls_std::byte_field ls_std::SerializableJSONString::marshal()
+ls_std::byte_field ls_std::SerializableJsonString::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls_std::SerializableJSONString::unmarshal(const ls_std::byte_field &_data)
+void ls_std::SerializableJsonString::unmarshal(const ls_std::byte_field &_data)
 {
   this->jsonObject = nlohmann::json::parse(_data);
 
@@ -31,17 +31,17 @@ void ls_std::SerializableJSONString::unmarshal(const ls_std::byte_field &_data)
   }
 }
 
-std::shared_ptr<ls_std::String> ls_std::SerializableJSONString::getValue()
+std::shared_ptr<ls_std::String> ls_std::SerializableJsonString::getValue()
 {
   return this->value;
 }
 
-void ls_std::SerializableJSONString::setValue(const std::shared_ptr<ls_std::String> &_value)
+void ls_std::SerializableJsonString::setValue(const std::shared_ptr<ls_std::String> &_value)
 {
   this->_assignValue(_value);
 }
 
-void ls_std::SerializableJSONString::_assignValue(const std::shared_ptr<ls_std::String> &_value)
+void ls_std::SerializableJsonString::_assignValue(const std::shared_ptr<ls_std::String> &_value)
 {
   if (_value == nullptr)
   {
@@ -51,7 +51,7 @@ void ls_std::SerializableJSONString::_assignValue(const std::shared_ptr<ls_std::
   this->value = _value;
 }
 
-void ls_std::SerializableJSONString::_update()
+void ls_std::SerializableJsonString::_update()
 {
   this->jsonObject = {{"value", this->value->toString()}};
 }

source/ls_std/serialization/json/event/SerializableJSONEvent.cpp → source/ls_std/serialization/json/event/SerializableJsonEvent.cpp

@@ -3,25 +3,25 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-07
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/serialization/json/event/SerializableJSONEvent.hpp>
+#include <ls_std/serialization/json/event/SerializableJsonEvent.hpp>
 #include <ls_std/exception/NullPointerException.hpp>
 
-ls_std::SerializableJSONEvent::SerializableJSONEvent(const std::shared_ptr<ls_std::Event> &_value) : ls_std::Class("SerializableJSONEvent")
+ls_std::SerializableJsonEvent::SerializableJsonEvent(const std::shared_ptr<ls_std::Event> &_value) : ls_std::Class("SerializableJsonEvent")
 {
   this->_assignValue(_value);
 }
 
-ls_std::byte_field ls_std::SerializableJSONEvent::marshal()
+ls_std::byte_field ls_std::SerializableJsonEvent::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls_std::SerializableJSONEvent::unmarshal(const ls_std::byte_field &_data)
+void ls_std::SerializableJsonEvent::unmarshal(const ls_std::byte_field &_data)
 {
   this->jsonObject = nlohmann::json::parse(_data);
 
@@ -29,17 +29,17 @@ void ls_std::SerializableJSONEvent::unmarshal(const ls_std::byte_field &_data)
   this->_unmarshalParameterList();
 }
 
-std::shared_ptr<ls_std::Event> ls_std::SerializableJSONEvent::getValue()
+std::shared_ptr<ls_std::Event> ls_std::SerializableJsonEvent::getValue()
 {
   return this->value;
 }
 
-void ls_std::SerializableJSONEvent::setValue(const std::shared_ptr<ls_std::Event> &_value)
+void ls_std::SerializableJsonEvent::setValue(const std::shared_ptr<ls_std::Event> &_value)
 {
   this->_assignValue(_value);
 }
 
-void ls_std::SerializableJSONEvent::_assignValue(const std::shared_ptr<ls_std::Event> &_value)
+void ls_std::SerializableJsonEvent::_assignValue(const std::shared_ptr<ls_std::Event> &_value)
 {
   if (_value == nullptr)
   {
@@ -49,25 +49,25 @@ void ls_std::SerializableJSONEvent::_assignValue(const std::shared_ptr<ls_std::E
   this->value = _value;
 }
 
-void ls_std::SerializableJSONEvent::_unmarshalParameterList()
+void ls_std::SerializableJsonEvent::_unmarshalParameterList()
 {
   this->value->clearParameterList();
 
-  for (const auto &parameterJSON : this->jsonObject["parameterList"])
+  for (const auto &parameterJson : this->jsonObject["parameterList"])
   {
-    ls_std::event_parameter parameter = {parameterJSON.at(0), parameterJSON.at(1)};
+    ls_std::event_parameter parameter = {parameterJson.at(0), parameterJson.at(1)};
     this->value->addParameter(parameter);
   }
 }
 
-void ls_std::SerializableJSONEvent::_update()
+void ls_std::SerializableJsonEvent::_update()
 {
   this->jsonObject = {{"id", this->value->getId()}};
 
   this->_updateEventParameterList();
 }
 
-void ls_std::SerializableJSONEvent::_updateEventParameterList()
+void ls_std::SerializableJsonEvent::_updateEventParameterList()
 {
   std::string jsonString{};
 

source/ls_std/serialization/json/logic/SerializableJSONState.cpp → source/ls_std/serialization/json/logic/SerializableJsonState.cpp

@@ -3,26 +3,26 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-15
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/serialization/json/logic/SerializableJSONState.hpp>
-#include <ls_std/serialization/json/logic/SerializableJSONStateConnection.hpp>
+#include <ls_std/serialization/json/logic/SerializableJsonState.hpp>
+#include <ls_std/serialization/json/logic/SerializableJsonStateConnection.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
-ls_std::SerializableJSONState::SerializableJSONState(const std::shared_ptr<ls_std::State> &_value) : ls_std::Class("SerializableJSONState")
+ls_std::SerializableJsonState::SerializableJsonState(const std::shared_ptr<ls_std::State> &_value) : ls_std::Class("SerializableJsonState")
 {
   this->_assignValue(_value);
 }
 
-ls_std::byte_field ls_std::SerializableJSONState::marshal()
+ls_std::byte_field ls_std::SerializableJsonState::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls_std::SerializableJSONState::unmarshal(const ls_std::byte_field &_data)
+void ls_std::SerializableJsonState::unmarshal(const ls_std::byte_field &_data)
 {
   this->jsonObject = nlohmann::json::parse(_data);
 
@@ -30,18 +30,18 @@ void ls_std::SerializableJSONState::unmarshal(const ls_std::byte_field &_data)
   this->value->setId(this->jsonObject["id"]);
 }
 
-std::shared_ptr<ls_std::State> ls_std::SerializableJSONState::getValue()
+std::shared_ptr<ls_std::State> ls_std::SerializableJsonState::getValue()
 {
   return this->value;
 }
 
-void ls_std::SerializableJSONState::setValue(const std::shared_ptr<ls_std::State> &_value)
+void ls_std::SerializableJsonState::setValue(const std::shared_ptr<ls_std::State> &_value)
 {
   this->_assignValue(_value);
   this->_clear();
 }
 
-void ls_std::SerializableJSONState::_assignValue(const std::shared_ptr<ls_std::State> &_value)
+void ls_std::SerializableJsonState::_assignValue(const std::shared_ptr<ls_std::State> &_value)
 {
   if (_value == nullptr)
   {
@@ -51,40 +51,40 @@ void ls_std::SerializableJSONState::_assignValue(const std::shared_ptr<ls_std::S
   this->value = _value;
 }
 
-void ls_std::SerializableJSONState::_clear()
+void ls_std::SerializableJsonState::_clear()
 {
   this->jsonObject.clear();
 }
 
-void ls_std::SerializableJSONState::_unmarshalStateConnections()
+void ls_std::SerializableJsonState::_unmarshalStateConnections()
 {
   if (!this->jsonObject["connectedStates"].empty())
   {
     this->value->clearConnections();
 
-    for (const auto &connectionJSON : this->jsonObject["connectedStates"])
+    for (const auto &connectionJson : this->jsonObject["connectedStates"])
     {
       std::shared_ptr<ls_std::StateConnection> connection = std::make_shared<ls_std::StateConnection>("TMP_ID", "TMP_ID");
-      ls_std::SerializableJSONStateConnection{connection}.unmarshal(connectionJSON.dump());
+      ls_std::SerializableJsonStateConnection{connection}.unmarshal(connectionJson.dump());
       this->value->addStateConnection(connection);
     }
   }
 }
 
-void ls_std::SerializableJSONState::_update()
+void ls_std::SerializableJsonState::_update()
 {
   this->jsonObject = {{"id", this->value->getId()}};
 
   this->_updateStateConnections();
 }
 
-void ls_std::SerializableJSONState::_updateStateConnections()
+void ls_std::SerializableJsonState::_updateStateConnections()
 {
   std::string jsonString{};
 
   for (const auto &connection : this->value->getConnectedStates())
   {
-    jsonString = ls_std::SerializableJSONStateConnection{connection.second}.marshal();
+    jsonString = ls_std::SerializableJsonStateConnection{connection.second}.marshal();
     this->jsonObject["connectedStates"][connection.first] = nlohmann::json::parse(jsonString);
   }
 }

source/ls_std/serialization/json/logic/SerializableJSONStateConnection.cpp → source/ls_std/serialization/json/logic/SerializableJsonStateConnection.cpp

@@ -3,25 +3,25 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-14
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/serialization/json/logic/SerializableJSONStateConnection.hpp>
+#include <ls_std/serialization/json/logic/SerializableJsonStateConnection.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
-ls_std::SerializableJSONStateConnection::SerializableJSONStateConnection(const std::shared_ptr<ls_std::StateConnection> &_value) : ls_std::Class("SerializableJSONStateConnection")
+ls_std::SerializableJsonStateConnection::SerializableJsonStateConnection(const std::shared_ptr<ls_std::StateConnection> &_value) : ls_std::Class("SerializableJsonStateConnection")
 {
   this->_assignValue(_value);
 }
 
-ls_std::byte_field ls_std::SerializableJSONStateConnection::marshal()
+ls_std::byte_field ls_std::SerializableJsonStateConnection::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls_std::SerializableJSONStateConnection::unmarshal(const ls_std::byte_field &_data)
+void ls_std::SerializableJsonStateConnection::unmarshal(const ls_std::byte_field &_data)
 {
   std::string jsonString = std::string(_data);
   this->jsonObject = nlohmann::json::parse(jsonString);
@@ -31,18 +31,18 @@ void ls_std::SerializableJSONStateConnection::unmarshal(const ls_std::byte_field
   this->value->updatePassCondition(this->jsonObject["condition"]);
 }
 
-std::shared_ptr<ls_std::StateConnection> ls_std::SerializableJSONStateConnection::getValue()
+std::shared_ptr<ls_std::StateConnection> ls_std::SerializableJsonStateConnection::getValue()
 {
   return this->value;
 }
 
-void ls_std::SerializableJSONStateConnection::setValue(const std::shared_ptr<ls_std::StateConnection> &_value)
+void ls_std::SerializableJsonStateConnection::setValue(const std::shared_ptr<ls_std::StateConnection> &_value)
 {
   this->_assignValue(_value);
   this->_clear();
 }
 
-void ls_std::SerializableJSONStateConnection::_assignValue(const std::shared_ptr<ls_std::StateConnection> &_value)
+void ls_std::SerializableJsonStateConnection::_assignValue(const std::shared_ptr<ls_std::StateConnection> &_value)
 {
   if (_value == nullptr)
   {
@@ -52,12 +52,12 @@ void ls_std::SerializableJSONStateConnection::_assignValue(const std::shared_ptr
   this->value = _value;
 }
 
-void ls_std::SerializableJSONStateConnection::_clear()
+void ls_std::SerializableJsonStateConnection::_clear()
 {
   this->jsonObject.clear();
 }
 
-void ls_std::SerializableJSONStateConnection::_update()
+void ls_std::SerializableJsonStateConnection::_update()
 {
   this->jsonObject = {{"condition",    this->value->isPassable()},
                       {"connectionId", this->value->getConnectionId()},

source/ls_std/serialization/json/logic/SerializableJSONStateMachine.cpp → source/ls_std/serialization/json/logic/SerializableJsonStateMachine.cpp

@@ -3,26 +3,26 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-17
- * Changed:         2021-05-01
+ * Changed:         2021-05-02
  *
  * */
 
-#include <ls_std/serialization/json/logic/SerializableJSONStateMachine.hpp>
-#include <ls_std/serialization/json/logic/SerializableJSONState.hpp>
+#include <ls_std/serialization/json/logic/SerializableJsonStateMachine.hpp>
+#include <ls_std/serialization/json/logic/SerializableJsonState.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
-ls_std::SerializableJSONStateMachine::SerializableJSONStateMachine(const std::shared_ptr<ls_std::StateMachine> &_value) : ls_std::Class("SerializableJSONStateMachine")
+ls_std::SerializableJsonStateMachine::SerializableJsonStateMachine(const std::shared_ptr<ls_std::StateMachine> &_value) : ls_std::Class("SerializableJsonStateMachine")
 {
   this->_assignValue(_value);
 }
 
-ls_std::byte_field ls_std::SerializableJSONStateMachine::marshal()
+ls_std::byte_field ls_std::SerializableJsonStateMachine::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls_std::SerializableJSONStateMachine::unmarshal(const ls_std::byte_field &_data)
+void ls_std::SerializableJsonStateMachine::unmarshal(const ls_std::byte_field &_data)
 {
   this->jsonObject = nlohmann::json::parse(_data);
 
@@ -32,17 +32,17 @@ void ls_std::SerializableJSONStateMachine::unmarshal(const ls_std::byte_field &_
   this->value->setName(this->jsonObject["name"]);
 }
 
-std::shared_ptr<ls_std::StateMachine> ls_std::SerializableJSONStateMachine::getValue()
+std::shared_ptr<ls_std::StateMachine> ls_std::SerializableJsonStateMachine::getValue()
 {
   return this->value;
 }
 
-void ls_std::SerializableJSONStateMachine::setValue(const std::shared_ptr<ls_std::StateMachine> &_value)
+void ls_std::SerializableJsonStateMachine::setValue(const std::shared_ptr<ls_std::StateMachine> &_value)
 {
   this->_assignValue(_value);
 }
 
-void ls_std::SerializableJSONStateMachine::_assignValue(const std::shared_ptr<ls_std::StateMachine> &_value)
+void ls_std::SerializableJsonStateMachine::_assignValue(const std::shared_ptr<ls_std::StateMachine> &_value)
 {
   if (_value == nullptr)
   {
@@ -52,7 +52,7 @@ void ls_std::SerializableJSONStateMachine::_assignValue(const std::shared_ptr<ls
   this->value = _value;
 }
 
-void ls_std::SerializableJSONStateMachine::_unmarshalCurrentState()
+void ls_std::SerializableJsonStateMachine::_unmarshalCurrentState()
 {
   if (this->jsonObject.contains("currentState"))
   {
@@ -60,17 +60,17 @@ void ls_std::SerializableJSONStateMachine::_unmarshalCurrentState()
   }
 }
 
-void ls_std::SerializableJSONStateMachine::_unmarshalStates()
+void ls_std::SerializableJsonStateMachine::_unmarshalStates()
 {
   for (const auto &serializedState : this->jsonObject["states"])
   {
     std::shared_ptr<ls_std::State> state = std::make_shared<ls_std::State>("");
-    ls_std::SerializableJSONState{state}.unmarshal(serializedState.dump());
+    ls_std::SerializableJsonState{state}.unmarshal(serializedState.dump());
     this->value->addState(state);
   }
 }
 
-void ls_std::SerializableJSONStateMachine::_update()
+void ls_std::SerializableJsonStateMachine::_update()
 {
   this->jsonObject = {{"memory", this->value->getMemory()},
                       {"name",   this->value->getName()}};
@@ -79,7 +79,7 @@ void ls_std::SerializableJSONStateMachine::_update()
   this->_updateStates();
 }
 
-void ls_std::SerializableJSONStateMachine::_updateCurrentState()
+void ls_std::SerializableJsonStateMachine::_updateCurrentState()
 {
   if (this->value->getCurrentState() != nullptr)
   {
@@ -87,13 +87,13 @@ void ls_std::SerializableJSONStateMachine::_updateCurrentState()
   }
 }
 
-void ls_std::SerializableJSONStateMachine::_updateStates()
+void ls_std::SerializableJsonStateMachine::_updateStates()
 {
   std::string jsonString{};
 
   for (const auto &state : this->value->getStates())
   {
-    jsonString = ls_std::SerializableJSONState{state.second}.marshal();
+    jsonString = ls_std::SerializableJsonState{state.second}.marshal();
     this->jsonObject["states"][state.first] = nlohmann::json::parse(jsonString);
   }
 }

source/ls_std/time/Date.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2021-04-23
+ * Changed:         2021-05-22
  *
  * */
 
@@ -19,13 +19,25 @@ ls_std::Date::Date() : ls_std::Class("Date")
 
 ls_std::Date &ls_std::Date::operator+(int _value)
 {
-  this->timestamp += (_value * 86400);
+  this->_incrementByDays(_value);
   return *this;
 }
 
 ls_std::Date &ls_std::Date::operator-(int _value)
 {
-  this->timestamp -= (_value * 86400);
+  this->_decrementByDays(_value);
+  return *this;
+}
+
+ls_std::Date &ls_std::Date::operator+=(int _value)
+{
+  this->_incrementByDays(_value);
+  return *this;
+}
+
+ls_std::Date &ls_std::Date::operator-=(int _value)
+{
+  this->_decrementByDays(_value);
   return *this;
 }
 
@@ -88,6 +100,16 @@ std::string ls_std::Date::toString()
   return _stream.str();
 }
 
+void ls_std::Date::_decrementByDays(int _value)
+{
+  this->timestamp -= (_value * 86400);
+}
+
+void ls_std::Date::_incrementByDays(int _value)
+{
+  this->timestamp += (_value * 86400);
+}
+
 void ls_std::Date::_init()
 {
   this->localTime = std::localtime(&this->timestamp);

test/TestDataFactory.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-16
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -39,31 +39,31 @@ ls_std::StateMachine ls_std_test::TestDataFactory::createStateMachine()
   return stateMachine;
 }
 
-std::shared_ptr<ls_std::XMLNode> ls_std_test::TestDataFactory::createXMLContent()
+std::shared_ptr<ls_std::XmlNode> ls_std_test::TestDataFactory::createXmlContent()
 {
-  std::shared_ptr<ls_std::XMLNode> root = std::make_shared<ls_std::XMLNode>("dialog");
-  std::shared_ptr<ls_std::XMLAttribute> attribute{};
-  std::shared_ptr<ls_std::XMLNode> child{};
-  std::shared_ptr<ls_std::XMLNode> text{};
+  std::shared_ptr<ls_std::XmlNode> root = std::make_shared<ls_std::XmlNode>("dialog");
+  std::shared_ptr<ls_std::XmlAttribute> attribute{};
+  std::shared_ptr<ls_std::XmlNode> child{};
+  std::shared_ptr<ls_std::XmlNode> text{};
 
-  attribute = std::make_shared<ls_std::XMLAttribute>("name");
+  attribute = std::make_shared<ls_std::XmlAttribute>("name");
   attribute->setValue("dungeon_001");
   root->addAttributeToEnd(attribute);
 
-  child = std::make_shared<ls_std::XMLNode>("dialogUnit");
-  attribute = std::make_shared<ls_std::XMLAttribute>("id");
+  child = std::make_shared<ls_std::XmlNode>("dialogUnit");
+  attribute = std::make_shared<ls_std::XmlAttribute>("id");
   attribute->setValue("001");
   child->addAttributeToEnd(attribute);
-  text = std::make_shared<ls_std::XMLNode>("text");
+  text = std::make_shared<ls_std::XmlNode>("text");
   text->setValue("Hello!");
   child->addChildToEnd(text);
   root->addChildToEnd(child);
 
-  child = std::make_shared<ls_std::XMLNode>("dialogUnit");
-  attribute = std::make_shared<ls_std::XMLAttribute>("id");
+  child = std::make_shared<ls_std::XmlNode>("dialogUnit");
+  attribute = std::make_shared<ls_std::XmlAttribute>("id");
   attribute->setValue("002");
   child->addAttributeToEnd(attribute);
-  text = std::make_shared<ls_std::XMLNode>("text");
+  text = std::make_shared<ls_std::XmlNode>("text");
   text->setValue("Hello again!");
   child->addChildToEnd(text);
   root->addChildToEnd(child);

test/TestDataFactory.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-16
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -22,7 +22,7 @@ namespace ls_std_test
       ~TestDataFactory() = default;
 
       static ls_std::StateMachine createStateMachine();
-      static std::shared_ptr<ls_std::XMLNode> createXMLContent();
+      static std::shared_ptr<ls_std::XmlNode> createXmlContent();
   };
 }
 

test/cases/base/ClassTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-16
- * Changed:         2021-04-24
+ * Changed:         2021-05-24
  *
  * */
 
@@ -27,19 +27,7 @@ namespace
       {}
   };
 
-  TEST_F(ClassTest, Destructor)
-  {
-    std::shared_ptr<ls_std_test::ClassMock> object = std::make_shared<ls_std_test::ClassMock>();
-    EXPECT_CALL(*object, Die());
-  }
-
-  TEST_F(ClassTest, getClassName)
-  {
-    ls_std::Class object{"Class"};
-    ASSERT_STREQ("Class", object.getClassName().c_str());
-  }
-
-  TEST_F(ClassTest, getClassName_emptyName)
+  TEST_F(ClassTest, constructor_emoty_parameter)
   {
     EXPECT_THROW({
                    try
@@ -52,4 +40,17 @@ namespace
                    }
                  }, ls_std::IllegalArgumentException);
   }
+
+  TEST_F(ClassTest, destructor)
+  {
+    std::shared_ptr<ls_std_test::ClassWrapper> object = std::make_shared<ls_std_test::ClassWrapper>();
+    EXPECT_CALL(*object, Die());
+  }
+
+  TEST_F(ClassTest, getClassName)
+  {
+    ls_std::Class object{"Class"};
+    ASSERT_STREQ("Class", object.getClassName().c_str());
+  }
+
 }

test/cases/base/LibraryVersionTest.cpp

@@ -0,0 +1,33 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-05-02
+ * Changed:         2021-05-02
+ *
+ * */
+
+#include <gtest/gtest.h>
+#include <ls_std/ls_std.hpp>
+
+namespace
+{
+  class LibraryVersionTest : public ::testing::Test
+  {
+    protected:
+
+      LibraryVersionTest() = default;
+      ~LibraryVersionTest() override = default;
+
+      void SetUp() override
+      {}
+
+      void TearDown() override
+      {}
+  };
+
+  TEST_F(LibraryVersionTest, getVersion)
+  {
+    ASSERT_STREQ("1.0.0", ls_std::getVersion().c_str());
+  }
+}

test/cases/boxing/BooleanTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -126,7 +126,7 @@ namespace
     ls_std::FileWriter writer{file};
     writer.write(R"({"value":true})");
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONBoolean>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonBoolean>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
 
     auto storable = std::make_shared<ls_std::StorableFile>(path);
@@ -144,7 +144,7 @@ namespace
   {
     std::shared_ptr<ls_std::Boolean> x = std::make_shared<ls_std::Boolean>(true);
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONBoolean>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonBoolean>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
 
     ASSERT_STREQ(R"({"value":true})", x->marshal().c_str());
@@ -196,7 +196,7 @@ namespace
 
     ASSERT_FALSE(*x);
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONBoolean>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonBoolean>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
     x->unmarshal(R"({"value":true})");
 

test/cases/boxing/DoubleTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -285,7 +285,7 @@ namespace
     ls_std::FileWriter writer{file};
     writer.write(R"({"value":3.14159})");
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONDouble>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonDouble>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
 
     auto storable = std::make_shared<ls_std::StorableFile>(path);
@@ -303,7 +303,7 @@ namespace
   {
     std::shared_ptr<ls_std::Double> x = std::make_shared<ls_std::Double>(3.14159);
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONDouble>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonDouble>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
     ls_std::String jsonString{x->marshal()};
 
@@ -337,7 +337,7 @@ namespace
 
     ASSERT_DOUBLE_EQ(3.14159, *x);
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONDouble>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonDouble>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
     x->unmarshal(R"({"value":17.4132})");
 

test/cases/boxing/FloatTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -285,7 +285,7 @@ namespace
     ls_std::FileWriter writer{file};
     writer.write(R"({"value":3.14159})");
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONFloat>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonFloat>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
 
     auto storable = std::make_shared<ls_std::StorableFile>(path);
@@ -303,7 +303,7 @@ namespace
   {
     std::shared_ptr<ls_std::Float> x = std::make_shared<ls_std::Float>(3.14159f);
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONFloat>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonFloat>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
     ls_std::String jsonString{x->marshal()};
 
@@ -337,7 +337,7 @@ namespace
 
     ASSERT_FLOAT_EQ(3.14159f, *x);
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONFloat>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonFloat>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
     x->unmarshal(R"({"value":17.4132})");
 

test/cases/boxing/IntegerTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -351,7 +351,7 @@ namespace
     ls_std::FileWriter writer{file};
     writer.write(R"({"value":1990})");
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONInteger>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonInteger>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
 
     auto storable = std::make_shared<ls_std::StorableFile>(path);
@@ -369,7 +369,7 @@ namespace
   {
     std::shared_ptr<ls_std::Integer> x = std::make_shared<ls_std::Integer>(3);
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONInteger>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonInteger>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
 
     ASSERT_STREQ(R"({"value":3})", x->marshal().c_str());
@@ -400,7 +400,7 @@ namespace
     std::shared_ptr<ls_std::Integer> x = std::make_shared<ls_std::Integer>(13);
     ASSERT_EQ(13, *x);
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONInteger>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonInteger>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
 
     x->unmarshal(R"({"value":1989})");

test/cases/boxing/LongTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2021-04-23
+ * Changed:         2021-05-02
  *
  * */
 
@@ -351,7 +351,7 @@ namespace
     ls_std::FileWriter writer{file};
     writer.write(R"({"value":1990})");
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONLong>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonLong>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
 
     auto storable = std::make_shared<ls_std::StorableFile>(path);
@@ -369,7 +369,7 @@ namespace
   {
     std::shared_ptr<ls_std::Long> x = std::make_shared<ls_std::Long>(3);
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONLong>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonLong>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
 
     ASSERT_STREQ(R"({"value":3})", x->marshal().c_str());
@@ -400,7 +400,7 @@ namespace
     std::shared_ptr<ls_std::Long> x = std::make_shared<ls_std::Long>(13);
     ASSERT_EQ(13, *x);
 
-    auto serializable = std::make_shared<ls_std::SerializableJSONLong>(x);
+    auto serializable = std::make_shared<ls_std::SerializableJsonLong>(x);
     x->setSerializable(std::dynamic_pointer_cast<ls_std::ISerializable>(serializable));
 
     x->unmarshal(R"({"value":1989})");