Add missing namespaces

include/ls_std/base/Version.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2020-11-20
+ * Changed:         2020-11-26
  *
  * */
 
@@ -18,7 +18,7 @@ namespace ls_std {
   class Version : public ISerializable {
     public:
 
-      explicit Version(version_type _majorVersion, version_type _minorVersion, version_type _patchVersion);
+      explicit Version(ls_std::version_type _majorVersion, ls_std::version_type _minorVersion, ls_std::version_type _patchVersion);
       ~Version() = default;
 
       // implementation
@@ -28,19 +28,19 @@ namespace ls_std {
 
       // other functionality
 
-      version_type getMajorVersion() const;
-      version_type getMinorVersion() const;
-      version_type getPatchVersion() const;
+      ls_std::version_type getMajorVersion() const;
+      ls_std::version_type getMinorVersion() const;
+      ls_std::version_type getPatchVersion() const;
       static bool isValid(const std::string& _versionString);
-      void setMajorVersion(version_type _major);
-      void setMinorVersion(version_type _minor);
-      void setPatchVersion(version_type _patch);
+      void setMajorVersion(ls_std::version_type _major);
+      void setMinorVersion(ls_std::version_type _minor);
+      void setPatchVersion(ls_std::version_type _patch);
 
     private:
 
-      version_type majorVersion {};
-      version_type minorVersion {};
-      version_type patchVersion {};
+      ls_std::version_type majorVersion {};
+      ls_std::version_type minorVersion {};
+      ls_std::version_type patchVersion {};
 
       static bool _isValid(const std::string& _versionString);
   };

include/ls_std/boxing/Boolean.hpp

@@ -30,26 +30,26 @@ namespace ls_std {
 
       // assignment operators
 
-      Boolean& operator=(int _value);
-      Boolean& operator=(bool _value);
+      ls_std::Boolean& operator=(int _value);
+      ls_std::Boolean& operator=(bool _value);
 
       // stream operators
 
-      friend std::ostream& operator<<(std::ostream& _outputStream, const Boolean& _boolean) {
+      friend std::ostream& operator<<(std::ostream& _outputStream, const ls_std::Boolean& _boolean) {
         _outputStream << _boolean._toString();
         return _outputStream;
       }
 
       // logical operators
 
-      friend bool operator!(const Boolean& _boolean) {
+      friend bool operator!(const ls_std::Boolean& _boolean) {
         return !_boolean.value;
       }
 
-      bool operator&&(const Boolean& _boolean) const;
+      bool operator&&(const ls_std::Boolean& _boolean) const;
       bool operator&&(bool _value) const;
       bool operator&&(int _value) const;
-      bool operator||(const Boolean& _boolean) const;
+      bool operator||(const ls_std::Boolean& _boolean) const;
       bool operator||(bool _value) const;
       bool operator||(int _value) const;
       // INFO: operator ^ can not be taken for XOR, since it's not possible to implement it respecting commutative law
@@ -68,9 +68,9 @@ namespace ls_std {
       bool getValue() const;
       void setSerializable(std::shared_ptr<ISerializable> _serializable);
       void setStorable(std::shared_ptr<IStorable> _storable);
-      static bool XOR(const Boolean& _leftExpression, const Boolean& _rightExpression);
-      static bool XOR(const Boolean& _leftExpression, bool _rightExpression);
-      static bool XOR(bool _leftExpression, const Boolean& _rightExpression);
+      static bool XOR(const ls_std::Boolean& _leftExpression, const ls_std::Boolean& _rightExpression);
+      static bool XOR(const ls_std::Boolean& _leftExpression, bool _rightExpression);
+      static bool XOR(bool _leftExpression, const ls_std::Boolean& _rightExpression);
       static bool XOR(bool _leftExpression, bool _rightExpression);
 
     private:

include/ls_std/boxing/Double.hpp

@@ -30,44 +30,44 @@ namespace ls_std {
 
       // assignment operators
 
-      Double& operator=(double _value);
+      ls_std::Double& operator=(double _value);
 
       // arithmetic operators
 
       double operator-() const;
-      double operator+(const Double& _double) const;
+      double operator+(const ls_std::Double& _double) const;
       double operator+(double _value) const;
-      double operator*(const Double& _double) const;
+      double operator*(const ls_std::Double& _double) const;
       double operator*(double _value) const;
-      double operator-(const Double& _double) const;
+      double operator-(const ls_std::Double& _double) const;
       double operator-(double _value) const;
-      double operator/(const Double& _double) const;
+      double operator/(const ls_std::Double& _double) const;
       double operator/(double _value) const;
 
       // compound operators
 
-      Double& operator+=(const Double& _double);
-      Double& operator+=(double _value);
-      Double& operator-=(const Double& _double);
-      Double& operator-=(double _value);
-      Double& operator*=(const Double& _double);
-      Double& operator*=(double _value);
-      Double& operator/=(const Double& _double);
-      Double& operator/=(double _value);
+      ls_std::Double& operator+=(const ls_std::Double& _double);
+      ls_std::Double& operator+=(double _value);
+      ls_std::Double& operator-=(const ls_std::Double& _double);
+      ls_std::Double& operator-=(double _value);
+      ls_std::Double& operator*=(const ls_std::Double& _double);
+      ls_std::Double& operator*=(double _value);
+      ls_std::Double& operator/=(const ls_std::Double& _double);
+      ls_std::Double& operator/=(double _value);
 
       // comparison operators
 
-      bool operator==(const Double& _double) const;
+      bool operator==(const ls_std::Double& _double) const;
       bool operator==(double _value) const;
-      bool operator!=(const Double& _double) const;
+      bool operator!=(const ls_std::Double& _double) const;
       bool operator!=(double _value) const;
-      bool operator>(const Double& _double) const;
+      bool operator>(const ls_std::Double& _double) const;
       bool operator>(double _value) const;
-      bool operator>=(const Double& _double) const;
+      bool operator>=(const ls_std::Double& _double) const;
       bool operator>=(double _value) const;
-      bool operator<(const Double& _double) const;
+      bool operator<(const ls_std::Double& _double) const;
       bool operator<(double _value) const;
-      bool operator<=(const Double& _double) const;
+      bool operator<=(const ls_std::Double& _double) const;
       bool operator<=(double _value) const;
 
       // increment / decrement operator

include/ls_std/boxing/Float.hpp

@@ -30,44 +30,44 @@ namespace ls_std {
 
       // assignment operators
 
-      Float& operator=(float _value);
+      ls_std::Float& operator=(float _value);
 
       // arithmetic operators
 
       float operator-() const;
-      float operator+(const Float& _float) const;
+      float operator+(const ls_std::Float& _float) const;
       float operator+(float _value) const;
-      float operator*(const Float& _float) const;
+      float operator*(const ls_std::Float& _float) const;
       float operator*(float _value) const;
-      float operator-(const Float& _float) const;
+      float operator-(const ls_std::Float& _float) const;
       float operator-(float _value) const;
-      float operator/(const Float& _float) const;
+      float operator/(const ls_std::Float& _float) const;
       float operator/(float _value) const;
 
       // compound operators
 
-      Float& operator+=(const Float& _float);
-      Float& operator+=(float _value);
-      Float& operator-=(const Float& _float);
-      Float& operator-=(float _value);
-      Float& operator*=(const Float& _float);
-      Float& operator*=(float _value);
-      Float& operator/=(const Float& _float);
-      Float& operator/=(float _value);
+      ls_std::Float& operator+=(const ls_std::Float& _float);
+      ls_std::Float& operator+=(float _value);
+      ls_std::Float& operator-=(const ls_std::Float& _float);
+      ls_std::Float& operator-=(float _value);
+      ls_std::Float& operator*=(const ls_std::Float& _float);
+      ls_std::Float& operator*=(float _value);
+      ls_std::Float& operator/=(const ls_std::Float& _float);
+      ls_std::Float& operator/=(float _value);
 
       // comparison operators
 
-      bool operator==(const Float& _float) const;
+      bool operator==(const ls_std::Float& _float) const;
       bool operator==(float _value) const;
-      bool operator!=(const Float& _float) const;
+      bool operator!=(const ls_std::Float& _float) const;
       bool operator!=(float _value) const;
-      bool operator>(const Float& _float) const;
+      bool operator>(const ls_std::Float& _float) const;
       bool operator>(float _value) const;
-      bool operator>=(const Float& _float) const;
+      bool operator>=(const ls_std::Float& _float) const;
       bool operator>=(float _value) const;
-      bool operator<(const Float& _float) const;
+      bool operator<(const ls_std::Float& _float) const;
       bool operator<(float _value) const;
-      bool operator<=(const Float& _float) const;
+      bool operator<=(const ls_std::Float& _float) const;
       bool operator<=(float _value) const;
 
       // increment / decrement operator

include/ls_std/boxing/Integer.hpp

@@ -30,58 +30,58 @@ namespace ls_std {
 
       // assignment operators
 
-      Integer& operator=(int _value);
+      ls_std::Integer& operator=(int _value);
 
       // arithmetic operators
 
       int operator-() const;
-      int operator+(const Integer& _integer) const;
+      int operator+(const ls_std::Integer& _integer) const;
       int operator+(int _value) const;
-      int operator*(const Integer& _integer) const;
+      int operator*(const ls_std::Integer& _integer) const;
       int operator*(int _value) const;
-      int operator-(const Integer& _integer) const;
+      int operator-(const ls_std::Integer& _integer) const;
       int operator-(int _value) const;
-      int operator/(const Integer& _integer) const;
+      int operator/(const ls_std::Integer& _integer) const;
       int operator/(int _value) const;
-      int operator%(const Integer& _integer) const;
+      int operator%(const ls_std::Integer& _integer) const;
       int operator%(int _value) const;
 
       // compound operators
 
-      Integer& operator+=(const Integer& _integer);
-      Integer& operator+=(int _value);
-      Integer& operator-=(const Integer& _integer);
-      Integer& operator-=(int _value);
-      Integer& operator*=(const Integer& _integer);
-      Integer& operator*=(int _value);
-      Integer& operator/=(const Integer& _integer);
-      Integer& operator/=(int _value);
+      ls_std::Integer& operator+=(const ls_std::Integer& _integer);
+      ls_std::Integer& operator+=(int _value);
+      ls_std::Integer& operator-=(const ls_std::Integer& _integer);
+      ls_std::Integer& operator-=(int _value);
+      ls_std::Integer& operator*=(const ls_std::Integer& _integer);
+      ls_std::Integer& operator*=(int _value);
+      ls_std::Integer& operator/=(const ls_std::Integer& _integer);
+      ls_std::Integer& operator/=(int _value);
 
       // comparison operators
 
-      bool operator==(const Integer& _integer) const;
+      bool operator==(const ls_std::Integer& _integer) const;
       bool operator==(int _value) const;
-      bool operator!=(const Integer& _integer) const;
+      bool operator!=(const ls_std::Integer& _integer) const;
       bool operator!=(int _value) const;
-      bool operator>(const Integer& _integer) const;
+      bool operator>(const ls_std::Integer& _integer) const;
       bool operator>(int _value) const;
-      bool operator>=(const Integer& _integer) const;
+      bool operator>=(const ls_std::Integer& _integer) const;
       bool operator>=(int _value) const;
-      bool operator<(const Integer& _integer) const;
+      bool operator<(const ls_std::Integer& _integer) const;
       bool operator<(int _value) const;
-      bool operator<=(const Integer& _integer) const;
+      bool operator<=(const ls_std::Integer& _integer) const;
       bool operator<=(int _value) const;
 
       // logical operators
 
-      friend bool operator!(const Integer& _integer) {
+      friend bool operator!(const ls_std::Integer& _integer) {
         return !_integer.value;
       }
 
-      bool operator&&(const Integer& _integer) const;
+      bool operator&&(const ls_std::Integer& _integer) const;
       bool operator&&(int _value) const;
       bool operator&&(bool _expression) const;
-      bool operator||(const Integer& _integer) const;
+      bool operator||(const ls_std::Integer& _integer) const;
       bool operator||(int _value) const;
       bool operator||(bool _expression) const;
 

include/ls_std/boxing/Long.hpp

@@ -31,58 +31,58 @@ namespace ls_std {
 
       // assignment operators
 
-      Long& operator=(ls_std::long_type _value);
+      ls_std::Long& operator=(ls_std::long_type _value);
 
       // arithmetic operators
 
       ls_std::long_type operator-() const;
-      ls_std::long_type operator+(const Long& _long) const;
+      ls_std::long_type operator+(const ls_std::Long& _long) const;
       ls_std::long_type operator+(ls_std::long_type _value) const;
-      ls_std::long_type operator*(const Long& _long) const;
+      ls_std::long_type operator*(const ls_std::Long& _long) const;
       ls_std::long_type operator*(ls_std::long_type _value) const;
-      ls_std::long_type operator-(const Long& _long) const;
+      ls_std::long_type operator-(const ls_std::Long& _long) const;
       ls_std::long_type operator-(ls_std::long_type _value) const;
-      ls_std::long_type operator/(const Long& _long) const;
+      ls_std::long_type operator/(const ls_std::Long& _long) const;
       ls_std::long_type operator/(ls_std::long_type _value) const;
-      ls_std::long_type operator%(const Long& _long) const;
+      ls_std::long_type operator%(const ls_std::Long& _long) const;
       ls_std::long_type operator%(ls_std::long_type _value) const;
 
       // compound operators
 
-      Long& operator+=(const Long& _long);
-      Long& operator+=(ls_std::long_type _value);
-      Long& operator-=(const Long& _long);
-      Long& operator-=(ls_std::long_type _value);
-      Long& operator*=(const Long& _long);
-      Long& operator*=(ls_std::long_type _value);
-      Long& operator/=(const Long& _long);
-      Long& operator/=(ls_std::long_type _value);
+      ls_std::Long& operator+=(const ls_std::Long& _long);
+      ls_std::Long& operator+=(ls_std::long_type _value);
+      ls_std::Long& operator-=(const ls_std::Long& _long);
+      ls_std::Long& operator-=(ls_std::long_type _value);
+      ls_std::Long& operator*=(const ls_std::Long& _long);
+      ls_std::Long& operator*=(ls_std::long_type _value);
+      ls_std::Long& operator/=(const ls_std::Long& _long);
+      ls_std::Long& operator/=(ls_std::long_type _value);
 
       // comparison operators
 
-      bool operator==(const Long& _long) const;
+      bool operator==(const ls_std::Long& _long) const;
       bool operator==(ls_std::long_type _value) const;
-      bool operator!=(const Long& _long) const;
+      bool operator!=(const ls_std::Long& _long) const;
       bool operator!=(ls_std::long_type _value) const;
-      bool operator>(const Long& _long) const;
+      bool operator>(const ls_std::Long& _long) const;
       bool operator>(ls_std::long_type _value) const;
-      bool operator>=(const Long& _long) const;
+      bool operator>=(const ls_std::Long& _long) const;
       bool operator>=(ls_std::long_type _value) const;
-      bool operator<(const Long& _long) const;
+      bool operator<(const ls_std::Long& _long) const;
       bool operator<(ls_std::long_type _value) const;
-      bool operator<=(const Long& _long) const;
+      bool operator<=(const ls_std::Long& _long) const;
       bool operator<=(ls_std::long_type _value) const;
 
       // logical operators
 
-      friend bool operator!(const Long& _long) {
+      friend bool operator!(const ls_std::Long& _long) {
         return !_long.value;
       }
 
-      bool operator&&(const Long& _long) const;
+      bool operator&&(const ls_std::Long& _long) const;
       bool operator&&(ls_std::long_type _value) const;
       bool operator&&(bool _expression) const;
-      bool operator||(const Long& _long) const;
+      bool operator||(const ls_std::Long& _long) const;
       bool operator||(ls_std::long_type _value) const;
       bool operator||(bool _expression) const;
 

include/ls_std/boxing/String.hpp

@@ -33,26 +33,26 @@ namespace ls_std {
 
       // assignment operators
 
-      String& operator=(std::string _value);
+      ls_std::String& operator=(std::string _value);
 
       // arithmetic operators
 
-      std::string operator+(String _string) const;
+      std::string operator+(ls_std::String _string) const;
       std::string operator+(const std::string& _string) const;
       std::string operator+(const char* _string) const;
       std::string operator-(int _number);
 
       // compound operators
 
-      String& operator+=(String _string);
-      String& operator+=(const std::string& _text);
+      ls_std::String& operator+=(ls_std::String _string);
+      ls_std::String& operator+=(const std::string& _text);
 
       // comparison operators
 
-      bool operator==(String _string);
+      bool operator==(ls_std::String _string);
       bool operator==(const std::string& _value);
       bool operator==(const char* _value);
-      bool operator!=(String _string);
+      bool operator!=(ls_std::String _string);
       bool operator!=(const std::string& _value);
       bool operator!=(const char* _value);
 
@@ -69,7 +69,7 @@ namespace ls_std {
 
       bool contains(const std::string& _text);
       bool endsWith(const std::string& _text);
-      bool equalsIgnoreCase(String _string);
+      bool equalsIgnoreCase(ls_std::String _string);
       bool equalsIgnoreCase(std::string _text);
       std::vector<ls_std::byte> getByteData();
       std::string padLeft(size_t _width, char _fillCharacter);

include/ls_std/io/File.hpp

@@ -34,8 +34,8 @@ namespace ls_std {
 
       // comparison operators
 
-      bool operator==(File& _file);
-      bool operator!=(File& _file);
+      bool operator==(ls_std::File& _file);
+      bool operator!=(ls_std::File& _file);
 
       // additional functionality
 
@@ -69,7 +69,7 @@ namespace ls_std {
       #ifdef _WIN32
         static void _addToFileListWindows(const std::string& _path, bool _withDirectories, WIN32_FIND_DATA _data, std::list<std::string>& _list);
       #endif
-      static bool _equals(File& _file, File& _foreignFile);
+      static bool _equals(ls_std::File& _file, ls_std::File& _foreignFile);
       static bool _exists(const std::string& _path);
       static std::string _getParent(const std::string& _path);
       static bool _isDirectory(const std::string& _path);

include/ls_std/io/FileOutputStream.hpp

@@ -19,8 +19,8 @@ namespace ls_std {
   class FileOutputStream : public Class, public IWriter {
     public:
 
-      explicit FileOutputStream(File& _file);
-      explicit FileOutputStream(File& _file, bool _append);
+      explicit FileOutputStream(ls_std::File& _file);
+      explicit FileOutputStream(ls_std::File& _file, bool _append);
       ~FileOutputStream() override;
 
       void close();
@@ -29,7 +29,7 @@ namespace ls_std {
     private:
 
       bool append {};
-      File file;
+      ls_std::File file;
       std::ofstream outputStream {};
 
       void _close();

include/ls_std/io/FileReader.hpp

@@ -18,17 +18,17 @@ namespace ls_std {
   class FileReader : public Class, public IReader {
     public:
 
-      explicit FileReader(File& _file);
+      explicit FileReader(ls_std::File& _file);
       ~FileReader() override = default;
 
       ls_std::byte_field read() override;
-      void reset(File& _file);
+      void reset(ls_std::File& _file);
 
     private:
 
-      File file;
+      ls_std::File file;
 
-      static void _init(File &_file);
+      static void _init(ls_std::File &_file);
   };
 }
 

include/ls_std/io/FileWriter.hpp

@@ -18,17 +18,17 @@ namespace ls_std {
   class FileWriter : public Class, public IWriter {
     public:
 
-      explicit FileWriter(File& _file);
+      explicit FileWriter(ls_std::File& _file);
       ~FileWriter() override = default;
 
-      void reset(File& _file);
+      void reset(ls_std::File& _file);
       bool write(const ls_std::byte_field& _data) override;
 
     private:
 
-      File file;
+      ls_std::File file;
 
-      static void _init(File& _file);
+      static void _init(ls_std::File& _file);
   };
 }
 

include/ls_std/io/xml/XMLDeclaration.hpp

@@ -34,7 +34,7 @@ namespace ls_std {
       ls_std::XMLAttribute standalone {"standalone"};
       ls_std::XMLAttribute version {"version"};
 
-      static std::string _toXMLAttribute(XMLAttribute _attribute);
+      static std::string _toXMLAttribute(ls_std::XMLAttribute _attribute);
   };
 }
 

include/ls_std/io/xml/XMLNode.hpp

@@ -26,19 +26,19 @@ namespace ls_std {
       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<XMLNode>& _child, const std::shared_ptr<XMLNode>& _search);
-      bool addChildBefore(const std::shared_ptr<XMLNode>& _child, const std::shared_ptr<XMLNode>& _search);
-      bool addChildToBeginning(const std::shared_ptr<XMLNode>& _child);
-      bool addChildToEnd(const std::shared_ptr<XMLNode>& _child);
+      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<XMLAttribute>> getAttributes();
-      std::list<std::shared_ptr<XMLNode>> getChildren();
-      std::list<std::shared_ptr<XMLNode>> getChildren(const std::string& _name);
+      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<XMLNode>& _child);
+      bool hasChild(const std::shared_ptr<ls_std::XMLNode>& _child);
       void removeFirstAttribute();
       void removeLastAttribute();
       void removeFirstChild();
@@ -53,15 +53,15 @@ namespace ls_std {
 
     private:
 
-      std::list<std::shared_ptr<XMLAttribute>> attributes {};
-      std::list<std::shared_ptr<XMLNode>> children {};
+      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<XMLNode>& _child);
+      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);

include/ls_std/logic/IListener.hpp

@@ -3,12 +3,12 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2020-11-14
+ * Changed:         2020-11-26
  *
  * */
 
-#ifndef LS_STD_ILISTENER_HPP
-#define LS_STD_ILISTENER_HPP
+#ifndef LS_STD_I_LISTENER_HPP
+#define LS_STD_I_LISTENER_HPP
 
 #include "../base/Class.hpp"
 
@@ -19,7 +19,7 @@ namespace ls_std {
       IListener();
       ~IListener() override = default;
 
-      virtual void listen(const Class& _info) = 0;
+      virtual void listen(const ls_std::Class& _info) = 0;
   };
 }
 

include/ls_std/logic/State.hpp

@@ -17,27 +17,27 @@
 #include "StateConnection.hpp"
 
 namespace ls_std {
-  class State : public Class {
+  class State : public ls_std::Class {
     public:
 
-      explicit State(StateId _id);
+      explicit State(ls_std::StateId _id);
       ~State() override = default;
 
-      bool addStateConnection(const StateConnectionId& _connectionId, const std::shared_ptr<State>& _connectedState);
-      bool addStateConnection(const std::shared_ptr<StateConnection>& _connection);
+      bool addStateConnection(const ls_std::StateConnectionId& _connectionId, const std::shared_ptr<ls_std::State>& _connectedState);
+      bool addStateConnection(const std::shared_ptr<ls_std::StateConnection>& _connection);
       void clearConnections();
-      std::unordered_map<StateConnectionId, std::shared_ptr<StateConnection>> getConnectedStates();
-      StateId getId();
-      bool hasConnection(const StateConnectionId& _connectionId);
-      void setId(StateId _id);
+      std::unordered_map<ls_std::StateConnectionId, std::shared_ptr<ls_std::StateConnection>> getConnectedStates();
+      ls_std::StateId getId();
+      bool hasConnection(const ls_std::StateConnectionId& _connectionId);
+      void setId(ls_std::StateId _id);
 
     private:
 
-      std::unordered_map<StateConnectionId, std::shared_ptr<StateConnection>> connectedStates {};
-      StateId id {};
+      std::unordered_map<ls_std::StateConnectionId, std::shared_ptr<ls_std::StateConnection>> connectedStates {};
+      ls_std::StateId id {};
 
       void _clearConnections();
-      bool _hasConnection(const StateConnectionId& _connectionId);
+      bool _hasConnection(const ls_std::StateConnectionId& _connectionId);
   };
 }
 

include/ls_std/logic/StateConnection.hpp

@@ -18,21 +18,21 @@ namespace ls_std {
   class StateConnection : public Class {
     public:
 
-      explicit StateConnection(StateConnectionId _connectionId, StateId _stateId);
+      explicit StateConnection(ls_std::StateConnectionId _connectionId, ls_std::StateId _stateId);
       ~StateConnection() override = default;
 
       StateConnectionId getConnectionId();
-      StateId getStateId();
+      ls_std::StateId getStateId();
       bool isPassable() const;
-      void setConnectionId(StateConnectionId _connectionId);
-      void setStateId(StateId _stateId);
+      void setConnectionId(ls_std::StateConnectionId _connectionId);
+      void setStateId(ls_std::StateId _stateId);
       void updatePassCondition(bool _condition);
 
     private:
 
       bool condition {};
-      StateConnectionId connectionId {};
-      StateId stateId {};
+      ls_std::StateConnectionId connectionId {};
+      ls_std::StateId stateId {};
   };
 }
 

include/ls_std/logic/StateMachine.hpp

@@ -25,27 +25,27 @@ namespace ls_std {
       explicit StateMachine(std::string _name);
       ~StateMachine() override = default;
 
-      bool addState(const std::shared_ptr<State>& _state);
-      std::shared_ptr<State> getCurrentState();
+      bool addState(const std::shared_ptr<ls_std::State>& _state);
+      std::shared_ptr<ls_std::State> getCurrentState();
       std::vector<ls_std::StateId> getMemory();
       std::string getName();
-      std::unordered_map<StateId, std::shared_ptr<State>> getStates();
-      bool hasState(const StateId& _id);
+      std::unordered_map<StateId, std::shared_ptr<ls_std::State>> getStates();
+      bool hasState(const ls_std::StateId& _id);
       bool proceed();
       void setMemory(std::vector<ls_std::StateId> _memory);
       void setName(std::string _name);
-      bool setStartState(const StateId& _id);
+      bool setStartState(const ls_std::StateId& _id);
 
     private:
 
       std::shared_ptr<State> currentState {};
       std::vector<ls_std::StateId> memory {};
       std::string name {};
-      std::unordered_map<StateId, std::shared_ptr<State>> states {};
+      std::unordered_map<ls_std::StateId, std::shared_ptr<ls_std::State>> states {};
 
-      std::vector<StateId> _getNextValidStates();
-      void _remember(const StateId& _id);
-      bool _hasState(const StateId& _id);
+      std::vector<ls_std::StateId> _getNextValidStates();
+      void _remember(const ls_std::StateId& _id);
+      bool _hasState(const ls_std::StateId& _id);
   };
 }
 

include/ls_std/time/Date.hpp

@@ -22,13 +22,13 @@ namespace ls_std {
 
       // arithmetic operators
 
-      Date& operator+(int _value);
-      Date& operator-(int _value);
+      ls_std::Date& operator+(int _value);
+      ls_std::Date& operator-(int _value);
 
       // additional functionality
 
-      bool after(const Date& _foreignDate) const;
-      bool before(const Date& _foreignDate) const;
+      bool after(const ls_std::Date& _foreignDate) const;
+      bool before(const ls_std::Date& _foreignDate) const;
       int getDay();
       int getHour();
       int getMinute();

source/ls_std/base/Version.cpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-28
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <regex>
 #include <ls_std/base/Version.hpp>
 
-ls_std::Version::Version(version_type _majorVersion, version_type _minorVersion, version_type _patchVersion) :
+ls_std::Version::Version(ls_std::version_type _majorVersion, ls_std::version_type _minorVersion, ls_std::version_type _patchVersion) :
 majorVersion(_majorVersion),
 minorVersion(_minorVersion),
 patchVersion(_patchVersion)
@@ -68,17 +68,17 @@ bool ls_std::Version::isValid(const std::string &_versionString)
   return ls_std::Version::_isValid(_versionString);
 }
 
-void ls_std::Version::setMajorVersion(version_type _major)
+void ls_std::Version::setMajorVersion(ls_std::version_type _major)
 {
   this->majorVersion = _major;
 }
 
-void ls_std::Version::setMinorVersion(version_type _minor)
+void ls_std::Version::setMinorVersion(ls_std::version_type _minor)
 {
   this->minorVersion = _minor;
 }
 
-void ls_std::Version::setPatchVersion(version_type _patch)
+void ls_std::Version::setPatchVersion(ls_std::version_type _patch)
 {
   this->patchVersion = _patch;
 }

source/ls_std/boxing/Boolean.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
@@ -11,10 +11,10 @@
 #include <ls_std/boxing/Boolean.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
-ls_std::Boolean::Boolean() : Class("Boolean")
+ls_std::Boolean::Boolean() : ls_std::Class("Boolean")
 {}
 
-ls_std::Boolean::Boolean(bool _value) : Class("Boolean"),
+ls_std::Boolean::Boolean(bool _value) : ls_std::Class("Boolean"),
 value(_value)
 {}
 
@@ -35,7 +35,7 @@ ls_std::Boolean & ls_std::Boolean::operator=(bool _value)
   return *this;
 }
 
-bool ls_std::Boolean::operator&&(const Boolean &_boolean) const
+bool ls_std::Boolean::operator&&(const ls_std::Boolean &_boolean) const
 {
   return this->value && _boolean;
 }
@@ -50,7 +50,7 @@ bool ls_std::Boolean::operator&&(int _value) const
   return this->value && _value;
 }
 
-bool ls_std::Boolean::operator||(const Boolean &_boolean) const
+bool ls_std::Boolean::operator||(const ls_std::Boolean &_boolean) const
 {
   return this->value || _boolean;
 }
@@ -136,15 +136,15 @@ void ls_std::Boolean::setStorable(std::shared_ptr<IStorable> _storable) {
   this->storable = std::move(_storable);
 }
 
-bool ls_std::Boolean::XOR(const Boolean &_leftExpression, const Boolean &_rightExpression) {
+bool ls_std::Boolean::XOR(const ls_std::Boolean &_leftExpression, const ls_std::Boolean &_rightExpression) {
   return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression);
 }
 
-bool ls_std::Boolean::XOR(const Boolean &_leftExpression, bool _rightExpression) {
+bool ls_std::Boolean::XOR(const ls_std::Boolean &_leftExpression, bool _rightExpression) {
   return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression);
 }
 
-bool ls_std::Boolean::XOR(bool _leftExpression, const Boolean &_rightExpression) {
+bool ls_std::Boolean::XOR(bool _leftExpression, const ls_std::Boolean &_rightExpression) {
   return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression);
 }
 

source/ls_std/boxing/Double.cpp

@@ -3,18 +3,18 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <cmath>
 #include <ls_std/boxing/Double.hpp>
 
-ls_std::Double::Double() : Class("Double"),
+ls_std::Double::Double() : ls_std::Class("Double"),
 epsilon(0.00000001)
 {}
 
-ls_std::Double::Double(double _value) : Class("Double"),
+ls_std::Double::Double(double _value) : ls_std::Class("Double"),
 epsilon(0.00000001),
 value(_value)
 {}
@@ -32,7 +32,7 @@ double ls_std::Double::operator-() const {
   return -this->value;
 }
 
-double ls_std::Double::operator+(const Double &_double) const {
+double ls_std::Double::operator+(const ls_std::Double &_double) const {
   return this->value + _double;
 }
 
@@ -40,7 +40,7 @@ double ls_std::Double::operator+(double _value) const {
   return this->value + _value;
 }
 
-double ls_std::Double::operator*(const Double &_double) const {
+double ls_std::Double::operator*(const ls_std::Double &_double) const {
   return this->value * _double;
 }
 
@@ -48,7 +48,7 @@ double ls_std::Double::operator*(double _value) const {
   return this->value * _value;
 }
 
-double ls_std::Double::operator-(const Double &_double) const {
+double ls_std::Double::operator-(const ls_std::Double &_double) const {
   return this->value - _double;
 }
 
@@ -56,7 +56,7 @@ double ls_std::Double::operator-(double _value) const {
   return this->value - _value;
 }
 
-double ls_std::Double::operator/(const Double &_double) const {
+double ls_std::Double::operator/(const ls_std::Double &_double) const {
   return this->value / _double;
 }
 
@@ -64,7 +64,7 @@ double ls_std::Double::operator/(double _value) const {
   return this->value / _value;
 }
 
-ls_std::Double & ls_std::Double::operator+=(const Double &_double) {
+ls_std::Double & ls_std::Double::operator+=(const ls_std::Double &_double) {
   this->value += _double;
   return *this;
 }
@@ -74,7 +74,7 @@ ls_std::Double & ls_std::Double::operator+=(double _value) {
   return *this;
 }
 
-ls_std::Double & ls_std::Double::operator-=(const Double &_double) {
+ls_std::Double & ls_std::Double::operator-=(const ls_std::Double &_double) {
   this->value -= _double;
   return *this;
 }
@@ -84,7 +84,7 @@ ls_std::Double & ls_std::Double::operator-=(double _value) {
   return *this;
 }
 
-ls_std::Double & ls_std::Double::operator*=(const Double &_double) {
+ls_std::Double & ls_std::Double::operator*=(const ls_std::Double &_double) {
   this->value *= _double;
   return *this;
 }
@@ -94,7 +94,7 @@ ls_std::Double & ls_std::Double::operator*=(double _value) {
   return *this;
 }
 
-ls_std::Double & ls_std::Double::operator/=(const Double &_double) {
+ls_std::Double & ls_std::Double::operator/=(const ls_std::Double &_double) {
   this->value /= _double;
   return *this;
 }
@@ -104,7 +104,7 @@ ls_std::Double & ls_std::Double::operator/=(double _value) {
   return *this;
 }
 
-bool ls_std::Double::operator==(const Double &_double) const {
+bool ls_std::Double::operator==(const ls_std::Double &_double) const {
   return std::fabs(this->value - _double) < this->epsilon;
 }
 
@@ -112,7 +112,7 @@ bool ls_std::Double::operator==(double _value) const {
   return std::fabs(this->value - _value) < this->epsilon;
 }
 
-bool ls_std::Double::operator!=(const Double &_double) const {
+bool ls_std::Double::operator!=(const ls_std::Double &_double) const {
   return std::fabs(this->value - _double) >= this->epsilon;
 }
 
@@ -120,7 +120,7 @@ bool ls_std::Double::operator!=(double _value) const {
   return std::fabs(this->value - _value) >= this->epsilon;
 }
 
-bool ls_std::Double::operator>(const Double &_double) const {
+bool ls_std::Double::operator>(const ls_std::Double &_double) const {
   return this->value > _double;
 }
 
@@ -128,7 +128,7 @@ bool ls_std::Double::operator>(double _value) const {
   return this->value > _value;
 }
 
-bool ls_std::Double::operator>=(const Double &_double) const {
+bool ls_std::Double::operator>=(const ls_std::Double &_double) const {
   return this->value >= _double;
 }
 
@@ -136,7 +136,7 @@ bool ls_std::Double::operator>=(double _value) const {
   return this->value >= _value;
 }
 
-bool ls_std::Double::operator<(const Double &_double) const {
+bool ls_std::Double::operator<(const ls_std::Double &_double) const {
   return this->value < _double;
 }
 
@@ -144,7 +144,7 @@ bool ls_std::Double::operator<(double _value) const {
   return this->value < _value;
 }
 
-bool ls_std::Double::operator<=(const Double &_double) const {
+bool ls_std::Double::operator<=(const ls_std::Double &_double) const {
   return this->value <= _double;
 }
 

source/ls_std/boxing/Float.cpp

@@ -3,18 +3,18 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <cmath>
 #include <ls_std/boxing/Float.hpp>
 
-ls_std::Float::Float() : Class("Float"),
+ls_std::Float::Float() : ls_std::Class("Float"),
 epsilon(0.00001f)
 {}
 
-ls_std::Float::Float(float _value) : Class("Float"),
+ls_std::Float::Float(float _value) : ls_std::Class("Float"),
 epsilon(0.00001f),
 value(_value)
 {}
@@ -32,7 +32,7 @@ float ls_std::Float::operator-() const {
   return -this->value;
 }
 
-float ls_std::Float::operator+(const Float &_float) const {
+float ls_std::Float::operator+(const ls_std::Float &_float) const {
   return this->value + _float;
 }
 
@@ -40,7 +40,7 @@ float ls_std::Float::operator+(float _value) const {
   return this->value + _value;
 }
 
-float ls_std::Float::operator*(const Float &_float) const {
+float ls_std::Float::operator*(const ls_std::Float &_float) const {
   return this->value * _float;
 }
 
@@ -48,7 +48,7 @@ float ls_std::Float::operator*(float _value) const {
   return this->value * _value;
 }
 
-float ls_std::Float::operator-(const Float &_float) const {
+float ls_std::Float::operator-(const ls_std::Float &_float) const {
   return this->value - _float;
 }
 
@@ -56,7 +56,7 @@ float ls_std::Float::operator-(float _value) const {
   return this->value - _value;
 }
 
-float ls_std::Float::operator/(const Float &_float) const {
+float ls_std::Float::operator/(const ls_std::Float &_float) const {
   return this->value / _float;
 }
 
@@ -64,7 +64,7 @@ float ls_std::Float::operator/(float _value) const {
   return this->value / _value;
 }
 
-ls_std::Float & ls_std::Float::operator+=(const Float &_float) {
+ls_std::Float & ls_std::Float::operator+=(const ls_std::Float &_float) {
   this->value += _float;
   return *this;
 }
@@ -74,7 +74,7 @@ ls_std::Float & ls_std::Float::operator+=(float _value) {
   return *this;
 }
 
-ls_std::Float & ls_std::Float::operator-=(const Float &_float) {
+ls_std::Float & ls_std::Float::operator-=(const ls_std::Float &_float) {
   this->value -= _float;
   return *this;
 }
@@ -84,7 +84,7 @@ ls_std::Float & ls_std::Float::operator-=(float _value) {
   return *this;
 }
 
-ls_std::Float & ls_std::Float::operator*=(const Float &_float) {
+ls_std::Float & ls_std::Float::operator*=(const ls_std::Float &_float) {
   this->value *= _float;
   return *this;
 }
@@ -94,7 +94,7 @@ ls_std::Float & ls_std::Float::operator*=(float _value) {
   return *this;
 }
 
-ls_std::Float & ls_std::Float::operator/=(const Float &_float) {
+ls_std::Float & ls_std::Float::operator/=(const ls_std::Float &_float) {
   this->value /= _float;
   return *this;
 }
@@ -104,7 +104,7 @@ ls_std::Float & ls_std::Float::operator/=(float _value) {
   return *this;
 }
 
-bool ls_std::Float::operator==(const Float &_float) const {
+bool ls_std::Float::operator==(const ls_std::Float &_float) const {
   return std::fabs(this->value - _float) < this->epsilon;
 }
 
@@ -112,7 +112,7 @@ bool ls_std::Float::operator==(float _value) const {
   return std::fabs(this->value - _value) < this->epsilon;
 }
 
-bool ls_std::Float::operator!=(const Float &_float) const {
+bool ls_std::Float::operator!=(const ls_std::Float &_float) const {
   return std::fabs(this->value - _float) >= this->epsilon;
 }
 
@@ -120,7 +120,7 @@ bool ls_std::Float::operator!=(float _value) const {
   return std::fabs(this->value - _value) >= this->epsilon;
 }
 
-bool ls_std::Float::operator>(const Float &_float) const {
+bool ls_std::Float::operator>(const ls_std::Float &_float) const {
   return this->value > _float;
 }
 
@@ -128,7 +128,7 @@ bool ls_std::Float::operator>(float _value) const {
   return this->value > _value;
 }
 
-bool ls_std::Float::operator>=(const Float &_float) const {
+bool ls_std::Float::operator>=(const ls_std::Float &_float) const {
   return this->value >= _float;
 }
 
@@ -136,7 +136,7 @@ bool ls_std::Float::operator>=(float _value) const {
   return this->value >= _value;
 }
 
-bool ls_std::Float::operator<(const Float &_float) const {
+bool ls_std::Float::operator<(const ls_std::Float &_float) const {
   return this->value < _float;
 }
 
@@ -144,7 +144,7 @@ bool ls_std::Float::operator<(float _value) const {
   return this->value < _value;
 }
 
-bool ls_std::Float::operator<=(const Float &_float) const {
+bool ls_std::Float::operator<=(const ls_std::Float &_float) const {
   return this->value <= _float;
 }
 

source/ls_std/boxing/Integer.cpp

@@ -3,18 +3,18 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <ls_std/boxing/Integer.hpp>
 #include <ls_std/exception/IllegalArithmeticOperationException.hpp>
 
-ls_std::Integer::Integer(int _value) : Class("Integer"),
+ls_std::Integer::Integer(int _value) : ls_std::Class("Integer"),
 value(_value)
 {}
 
-ls_std::Integer::Integer() : Class("Integer")
+ls_std::Integer::Integer() : ls_std::Class("Integer")
 {}
 
 ls_std::Integer::operator int() const
@@ -33,7 +33,7 @@ int ls_std::Integer::operator-() const
   return -this->value;
 }
 
-int ls_std::Integer::operator+(const Integer &_integer) const
+int ls_std::Integer::operator+(const ls_std::Integer &_integer) const
 {
   return this->value + _integer;
 }
@@ -43,7 +43,7 @@ int ls_std::Integer::operator+(int _value) const
   return this->value + _value;
 }
 
-int ls_std::Integer::operator*(const Integer &_integer) const
+int ls_std::Integer::operator*(const ls_std::Integer &_integer) const
 {
   return this->value * _integer;
 }
@@ -53,7 +53,7 @@ int ls_std::Integer::operator*(int _value) const
   return this->value * _value;
 }
 
-int ls_std::Integer::operator-(const Integer &_integer) const
+int ls_std::Integer::operator-(const ls_std::Integer &_integer) const
 {
   return this->value - _integer;
 }
@@ -63,7 +63,7 @@ int ls_std::Integer::operator-(int _value) const
   return this->value - _value;
 }
 
-int ls_std::Integer::operator/(const Integer &_integer) const
+int ls_std::Integer::operator/(const ls_std::Integer &_integer) const
 {
   if(_integer == 0) {
     throw ls_std::IllegalArithmeticOperationException {};
@@ -81,7 +81,7 @@ int ls_std::Integer::operator/(int _value) const
   return this->value / _value;
 }
 
-int ls_std::Integer::operator%(const Integer &_integer) const
+int ls_std::Integer::operator%(const ls_std::Integer &_integer) const
 {
   return this->value % _integer;
 }
@@ -91,7 +91,7 @@ int ls_std::Integer::operator%(int _value) const
   return this->value % _value;
 }
 
-ls_std::Integer & ls_std::Integer::operator+=(const Integer &_integer)
+ls_std::Integer & ls_std::Integer::operator+=(const ls_std::Integer &_integer)
 {
   this->value += _integer;
   return *this;
@@ -103,7 +103,7 @@ ls_std::Integer & ls_std::Integer::operator+=(int _value)
   return *this;
 }
 
-ls_std::Integer & ls_std::Integer::operator-=(const Integer &_integer)
+ls_std::Integer & ls_std::Integer::operator-=(const ls_std::Integer &_integer)
 {
   this->value -= _integer;
   return *this;
@@ -115,7 +115,7 @@ ls_std::Integer & ls_std::Integer::operator-=(int _value)
   return *this;
 }
 
-ls_std::Integer & ls_std::Integer::operator*=(const Integer &_integer)
+ls_std::Integer & ls_std::Integer::operator*=(const ls_std::Integer &_integer)
 {
   this->value *= _integer;
   return *this;
@@ -127,7 +127,7 @@ ls_std::Integer & ls_std::Integer::operator*=(int _value)
   return *this;
 }
 
-ls_std::Integer & ls_std::Integer::operator/=(const Integer &_integer)
+ls_std::Integer & ls_std::Integer::operator/=(const ls_std::Integer &_integer)
 {
   if(_integer == 0) {
     throw ls_std::IllegalArithmeticOperationException {};
@@ -147,7 +147,7 @@ ls_std::Integer & ls_std::Integer::operator/=(int _value)
   return *this;
 }
 
-bool ls_std::Integer::operator==(const Integer &_integer) const
+bool ls_std::Integer::operator==(const ls_std::Integer &_integer) const
 {
   return this->value == _integer;
 }
@@ -157,7 +157,7 @@ bool ls_std::Integer::operator==(int _value) const
   return this->value == _value;
 }
 
-bool ls_std::Integer::operator!=(const Integer &_integer) const
+bool ls_std::Integer::operator!=(const ls_std::Integer &_integer) const
 {
   return this->value != _integer;
 }
@@ -167,7 +167,7 @@ bool ls_std::Integer::operator!=(int _value) const
   return this->value != _value;
 }
 
-bool ls_std::Integer::operator>(const Integer &_integer) const
+bool ls_std::Integer::operator>(const ls_std::Integer &_integer) const
 {
   return this->value > _integer;
 }
@@ -177,7 +177,7 @@ bool ls_std::Integer::operator>(int _value) const
   return this->value > _value;
 }
 
-bool ls_std::Integer::operator>=(const Integer &_integer) const
+bool ls_std::Integer::operator>=(const ls_std::Integer &_integer) const
 {
   return this->value >= _integer;
 }
@@ -187,7 +187,7 @@ bool ls_std::Integer::operator>=(int _value) const
   return this->value >= _value;
 }
 
-bool ls_std::Integer::operator<(const Integer &_integer) const
+bool ls_std::Integer::operator<(const ls_std::Integer &_integer) const
 {
   return this->value < _integer;
 }
@@ -197,7 +197,7 @@ bool ls_std::Integer::operator<(int _value) const
   return this->value < _value;
 }
 
-bool ls_std::Integer::operator<=(const Integer &_integer) const
+bool ls_std::Integer::operator<=(const ls_std::Integer &_integer) const
 {
   return this->value <= _integer;
 }
@@ -207,7 +207,7 @@ bool ls_std::Integer::operator<=(int _value) const
   return this->value <= _value;
 }
 
-bool ls_std::Integer::operator&&(const Integer &_integer) const
+bool ls_std::Integer::operator&&(const ls_std::Integer &_integer) const
 {
   return this->value && _integer;
 }
@@ -222,7 +222,7 @@ bool ls_std::Integer::operator&&(bool _expression) const
   return this->value && _expression;
 }
 
-bool ls_std::Integer::operator||(const Integer &_integer) const
+bool ls_std::Integer::operator||(const ls_std::Integer &_integer) const
 {
   return this->value || _integer;
 }

source/ls_std/boxing/Long.cpp

@@ -3,18 +3,18 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <ls_std/boxing/Long.hpp>
 #include <ls_std/exception/IllegalArithmeticOperationException.hpp>
 
-ls_std::Long::Long(ls_std::long_type _value) : Class("Long"),
+ls_std::Long::Long(ls_std::long_type _value) : ls_std::Class("Long"),
 value(_value)
 {}
 
-ls_std::Long::Long() : Class("Long")
+ls_std::Long::Long() : ls_std::Class("Long")
 {}
 
 ls_std::Long::operator ls_std::long_type() const
@@ -33,7 +33,7 @@ ls_std::long_type ls_std::Long::operator-() const
   return -this->value;
 }
 
-ls_std::long_type ls_std::Long::operator+(const Long &_long) const
+ls_std::long_type ls_std::Long::operator+(const ls_std::Long &_long) const
 {
   return this->value + _long;
 }
@@ -43,7 +43,7 @@ ls_std::long_type ls_std::Long::operator+(ls_std::long_type _value) const
   return this->value + _value;
 }
 
-ls_std::long_type ls_std::Long::operator*(const Long &_long) const
+ls_std::long_type ls_std::Long::operator*(const ls_std::Long &_long) const
 {
   return this->value * _long;
 }
@@ -53,7 +53,7 @@ ls_std::long_type ls_std::Long::operator*(ls_std::long_type _value) const
   return this->value * _value;
 }
 
-ls_std::long_type ls_std::Long::operator-(const Long &_long) const
+ls_std::long_type ls_std::Long::operator-(const ls_std::Long &_long) const
 {
   return this->value - _long;
 }
@@ -63,7 +63,7 @@ ls_std::long_type ls_std::Long::operator-(ls_std::long_type _value) const
   return this->value - _value;
 }
 
-ls_std::long_type ls_std::Long::operator/(const Long &_long) const
+ls_std::long_type ls_std::Long::operator/(const ls_std::Long &_long) const
 {
   if(_long == (ls_std::long_type) 0) {
     throw ls_std::IllegalArithmeticOperationException {};
@@ -81,7 +81,7 @@ ls_std::long_type ls_std::Long::operator/(ls_std::long_type _value) const
   return this->value / _value;
 }
 
-ls_std::long_type ls_std::Long::operator%(const Long &_long) const
+ls_std::long_type ls_std::Long::operator%(const ls_std::Long &_long) const
 {
   return this->value % _long;
 }
@@ -91,7 +91,7 @@ ls_std::long_type ls_std::Long::operator%(ls_std::long_type _value) const
   return this->value % _value;
 }
 
-ls_std::Long & ls_std::Long::operator+=(const Long &_long)
+ls_std::Long & ls_std::Long::operator+=(const ls_std::Long &_long)
 {
   this->value += _long;
   return *this;
@@ -103,7 +103,7 @@ ls_std::Long & ls_std::Long::operator+=(ls_std::long_type _value)
   return *this;
 }
 
-ls_std::Long & ls_std::Long::operator-=(const Long &_long)
+ls_std::Long & ls_std::Long::operator-=(const ls_std::Long &_long)
 {
   this->value -= _long;
   return *this;
@@ -115,7 +115,7 @@ ls_std::Long & ls_std::Long::operator-=(ls_std::long_type _value)
   return *this;
 }
 
-ls_std::Long & ls_std::Long::operator*=(const Long &_long)
+ls_std::Long & ls_std::Long::operator*=(const ls_std::Long &_long)
 {
   this->value *= _long;
   return *this;
@@ -127,7 +127,7 @@ ls_std::Long & ls_std::Long::operator*=(ls_std::long_type _value)
   return *this;
 }
 
-ls_std::Long & ls_std::Long::operator/=(const Long &_long)
+ls_std::Long & ls_std::Long::operator/=(const ls_std::Long &_long)
 {
   if(_long == (ls_std::long_type) 0) {
     throw ls_std::IllegalArithmeticOperationException {};
@@ -147,7 +147,7 @@ ls_std::Long & ls_std::Long::operator/=(ls_std::long_type _value)
   return *this;
 }
 
-bool ls_std::Long::operator==(const Long &_long) const
+bool ls_std::Long::operator==(const ls_std::Long &_long) const
 {
   return this->value == _long;
 }
@@ -157,7 +157,7 @@ bool ls_std::Long::operator==(ls_std::long_type _value) const
   return this->value == _value;
 }
 
-bool ls_std::Long::operator!=(const Long &_long) const
+bool ls_std::Long::operator!=(const ls_std::Long &_long) const
 {
   return this->value != _long;
 }
@@ -167,7 +167,7 @@ bool ls_std::Long::operator!=(ls_std::long_type _value) const
   return this->value != _value;
 }
 
-bool ls_std::Long::operator>(const Long &_long) const
+bool ls_std::Long::operator>(const ls_std::Long &_long) const
 {
   return this->value > _long;
 }
@@ -177,7 +177,7 @@ bool ls_std::Long::operator>(ls_std::long_type _value) const
   return this->value > _value;
 }
 
-bool ls_std::Long::operator>=(const Long &_long) const
+bool ls_std::Long::operator>=(const ls_std::Long &_long) const
 {
   return this->value >= _long;
 }
@@ -187,7 +187,7 @@ bool ls_std::Long::operator>=(ls_std::long_type _value) const
   return this->value >= _value;
 }
 
-bool ls_std::Long::operator<(const Long &_long) const
+bool ls_std::Long::operator<(const ls_std::Long &_long) const
 {
   return this->value < _long;
 }
@@ -197,7 +197,7 @@ bool ls_std::Long::operator<(ls_std::long_type _value) const
   return this->value < _value;
 }
 
-bool ls_std::Long::operator<=(const Long &_long) const
+bool ls_std::Long::operator<=(const ls_std::Long &_long) const
 {
   return this->value <= _long;
 }
@@ -207,7 +207,7 @@ bool ls_std::Long::operator<=(ls_std::long_type _value) const
   return this->value <= _value;
 }
 
-bool ls_std::Long::operator&&(const Long &_long) const
+bool ls_std::Long::operator&&(const ls_std::Long &_long) const
 {
   return this->value && _long;
 }
@@ -222,7 +222,7 @@ bool ls_std::Long::operator&&(bool _expression) const
   return this->value && _expression;
 }
 
-bool ls_std::Long::operator||(const Long &_long) const
+bool ls_std::Long::operator||(const ls_std::Long &_long) const
 {
   return this->value || _long;
 }

source/ls_std/boxing/String.cpp

@@ -3,17 +3,17 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <algorithm>
 #include <ls_std/boxing/String.hpp>
 
-ls_std::String::String() : Class("String")
+ls_std::String::String() : ls_std::Class("String")
 {}
 
-ls_std::String::String(std::string _value) : Class("String"),
+ls_std::String::String(std::string _value) : ls_std::Class("String"),
 value(std::move(_value))
 {}
 
@@ -30,7 +30,7 @@ ls_std::String & ls_std::String::operator=(std::string _value) {
   return *this;
 }
 
-std::string ls_std::String::operator+(String _string) const {
+std::string ls_std::String::operator+(ls_std::String _string) const {
   return this->value + _string.toString();
 }
 
@@ -47,7 +47,7 @@ std::string ls_std::String::operator-(int _number) {
   return copy.substr(0, copy.size() - _number);
 }
 
-ls_std::String & ls_std::String::operator+=(String _string) {
+ls_std::String & ls_std::String::operator+=(ls_std::String _string) {
   this->value = this->value + _string.toString();
   return *this;
 }
@@ -57,7 +57,7 @@ ls_std::String & ls_std::String::operator+=(const std::string &_text) {
   return *this;
 }
 
-bool ls_std::String::operator==(String _string) {
+bool ls_std::String::operator==(ls_std::String _string) {
   return this->value == _string.toString();
 }
 
@@ -69,7 +69,7 @@ bool ls_std::String::operator==(const char *_value) {
   return this->value == _value;
 }
 
-bool ls_std::String::operator!=(String _string) {
+bool ls_std::String::operator!=(ls_std::String _string) {
   return this->value != _string.toString();
 }
 
@@ -134,7 +134,7 @@ bool ls_std::String::endsWith(const std::string &_text) {
   return this->value.rfind(_text) == (this->value.size() - _text.size());
 }
 
-bool ls_std::String::equalsIgnoreCase(String _string) {
+bool ls_std::String::equalsIgnoreCase(ls_std::String _string) {
   return this->toLowerCase() == _string.toLowerCase();
 }
 

source/ls_std/io/File.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
@@ -25,16 +25,16 @@
 #include <direct.h>
 #endif
 
-ls_std::File::File(std::string _absoluteFilePath) : Class("File"),
+ls_std::File::File(std::string _absoluteFilePath) : ls_std::Class("File"),
 absoluteFilePath(ls_std::File::_normalizePath(std::move(_absoluteFilePath)))
 {}
 
-bool ls_std::File::operator==(File &_file)
+bool ls_std::File::operator==(ls_std::File &_file)
 {
   return ls_std::File::_equals(*this, _file);
 }
 
-bool ls_std::File::operator!=(File &_file)
+bool ls_std::File::operator!=(ls_std::File &_file)
 {
   return !ls_std::File::_equals(*this, _file);
 }
@@ -239,7 +239,7 @@ void ls_std::File::_addToFileListUnix(const std::string& _path, bool _withDirect
 }
 #endif
 
-bool ls_std::File::_equals(File &_file, File &_foreignFile)
+bool ls_std::File::_equals(ls_std::File &_file, ls_std::File &_foreignFile)
 {
   bool isEqual = _file.getAbsoluteFilePath() == _foreignFile.getAbsoluteFilePath();
 

source/ls_std/io/FileOutputStream.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
@@ -11,13 +11,13 @@
 #include <ls_std/exception/FileNotFoundException.hpp>
 #include <ls_std/exception/FileOperationException.hpp>
 
-ls_std::FileOutputStream::FileOutputStream(File &_file) : Class("FileOutputStream"),
+ls_std::FileOutputStream::FileOutputStream(ls_std::File &_file) : ls_std::Class("FileOutputStream"),
 file(_file)
 {
   this->_init();
 }
 
-ls_std::FileOutputStream::FileOutputStream(File &_file, bool _append) : Class("FileOutputStream"),
+ls_std::FileOutputStream::FileOutputStream(ls_std::File &_file, bool _append) : ls_std::Class("FileOutputStream"),
 append(_append),
 file(_file)
 {

source/ls_std/io/FileReader.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
@@ -12,7 +12,7 @@
 #include <ls_std/exception/FileNotFoundException.hpp>
 #include <ls_std/exception/FileOperationException.hpp>
 
-ls_std::FileReader::FileReader(File &_file) : Class("FileReader"),
+ls_std::FileReader::FileReader(ls_std::File &_file) : ls_std::Class("FileReader"),
 file(_file)
 {
   ls_std::FileReader::_init(_file);
@@ -37,13 +37,13 @@ ls_std::byte_field ls_std::FileReader::read()
   return readData;
 }
 
-void ls_std::FileReader::reset(File &_file)
+void ls_std::FileReader::reset(ls_std::File &_file)
 {
   ls_std::FileReader::_init(_file);
   this->file = _file;
 }
 
-void ls_std::FileReader::_init(File &_file)
+void ls_std::FileReader::_init(ls_std::File &_file)
 {
   if(!_file.exists()) {
     throw ls_std::FileNotFoundException {};

source/ls_std/io/FileWriter.cpp

@@ -12,13 +12,13 @@
 #include <ls_std/exception/FileNotFoundException.hpp>
 #include <ls_std/exception/FileOperationException.hpp>
 
-ls_std::FileWriter::FileWriter(ls_std::File &_file) : Class("FileWriter"),
+ls_std::FileWriter::FileWriter(ls_std::File &_file) : ls_std::Class("FileWriter"),
 file(_file)
 {
   ls_std::FileWriter::_init(_file);
 }
 
-void ls_std::FileWriter::reset(File &_file)
+void ls_std::FileWriter::reset(ls_std::File &_file)
 {
   ls_std::FileWriter::_init(_file);
   this->file = _file;
@@ -40,7 +40,7 @@ bool ls_std::FileWriter::write(const ls_std::byte_field& _data)
   return succeeded;
 }
 
-void ls_std::FileWriter::_init(File &_file)
+void ls_std::FileWriter::_init(ls_std::File &_file)
 {
   if(!_file.exists()) {
     throw ls_std::FileNotFoundException {};

source/ls_std/io/logging/LogLevel.cpp

@@ -3,13 +3,13 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <ls_std/io/logging/LogLevel.hpp>
 
-ls_std::LogLevel::LogLevel(const ls_std::LogLevelValue& _value) : Class("LogLevel"),
+ls_std::LogLevel::LogLevel(const ls_std::LogLevelValue& _value) : ls_std::Class("LogLevel"),
 value(_value)
 {
   this->_init();

source/ls_std/io/logging/Logger.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
@@ -13,7 +13,7 @@
 #include <ls_std/boxing/String.hpp>
 #include <ls_std/exception/NullPointerException.hpp>
 
-ls_std::Logger::Logger(const std::shared_ptr<ls_std::IWriter> &_writer) : Class("Logger"),
+ls_std::Logger::Logger(const std::shared_ptr<ls_std::IWriter> &_writer) : ls_std::Class("Logger"),
 logLevel(ls_std::LogLevelValue::INFO)
 {
   if(_writer == nullptr) {

source/ls_std/io/xml/XMLAttribute.cpp

@@ -3,13 +3,13 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-23
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <ls_std/io/xml/XMLAttribute.hpp>
 
-ls_std::XMLAttribute::XMLAttribute(std::string _name) : Class("XMLAttribute"),
+ls_std::XMLAttribute::XMLAttribute(std::string _name) : ls_std::Class("XMLAttribute"),
 name(std::move(_name))
 {}
 

source/ls_std/io/xml/XMLDeclaration.cpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-29
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <ls_std/io/xml/XMLDeclaration.hpp>
 
 ls_std::XMLDeclaration::XMLDeclaration(std::string _version) :
-Class("XMLDeclaration")
+ls_std::Class("XMLDeclaration")
 {
   this->version.setValue(std::move(_version));
 }

source/ls_std/io/xml/XMLDocument.cpp

@@ -3,13 +3,13 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-30
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <ls_std/io/xml/XMLDocument.hpp>
 
-ls_std::XMLDocument::XMLDocument() : Class("XMLDocument")
+ls_std::XMLDocument::XMLDocument() : ls_std::Class("XMLDocument")
 {}
 
 std::shared_ptr<ls_std::XMLDeclaration> ls_std::XMLDocument::getDeclaration()

source/ls_std/io/xml/XMLNode.cpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-24
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <ls_std/io/xml/XMLNode.hpp>
 #include <ls_std/utils/STLUtils.hpp>
 
-ls_std::XMLNode::XMLNode(std::string _name) : Class("XMLNode"),
+ls_std::XMLNode::XMLNode(std::string _name) : ls_std::Class("XMLNode"),
 name(std::move(_name))
 {}
 
@@ -118,7 +118,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<XMLNode> &_child)
+bool ls_std::XMLNode::addChildToBeginning(const std::shared_ptr<ls_std::XMLNode> &_child)
 {
   bool added {};
 
@@ -130,7 +130,7 @@ bool ls_std::XMLNode::addChildToBeginning(const std::shared_ptr<XMLNode> &_child
   return added;
 }
 
-bool ls_std::XMLNode::addChildToEnd(const std::shared_ptr<XMLNode>& _child)
+bool ls_std::XMLNode::addChildToEnd(const std::shared_ptr<ls_std::XMLNode>& _child)
 {
   bool added {};
 
@@ -190,7 +190,7 @@ bool ls_std::XMLNode::hasChild(const std::string &_name)
   return this->_hasChild(_name);
 }
 
-bool ls_std::XMLNode::hasChild(const std::shared_ptr<XMLNode> &_child)
+bool ls_std::XMLNode::hasChild(const std::shared_ptr<ls_std::XMLNode> &_child)
 {
   return this->_hasChild(_child);
 }

source/ls_std/logic/IListener.cpp

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

source/ls_std/logic/Narrator.cpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2020-11-14
+ * Changed:         2020-11-26
  *
  * */
 
 #include <ls_std/utils/STLUtils.hpp>
 #include "../../../include/ls_std/logic/Narrator.hpp"
 
-ls_std::Narrator::Narrator() : Class("Narrator")
+ls_std::Narrator::Narrator() : ls_std::Class("Narrator")
 {}
 
 void ls_std::Narrator::addListener(const std::shared_ptr<ls_std::IListener>& _listener)

source/ls_std/logic/State.cpp

@@ -3,17 +3,17 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-05
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <ls_std/logic/State.hpp>
 
-ls_std::State::State(ls_std::StateId _id) : Class("State"),
+ls_std::State::State(ls_std::StateId _id) : ls_std::Class("State"),
 id(std::move(_id))
 {}
 
-bool ls_std::State::addStateConnection(const StateConnectionId& _connectionId, const std::shared_ptr<State>& _connectedState)
+bool ls_std::State::addStateConnection(const ls_std::StateConnectionId& _connectionId, const std::shared_ptr<ls_std::State>& _connectedState)
 {
   bool added {};
   std::shared_ptr<ls_std::StateConnection> connection {};
@@ -27,7 +27,7 @@ bool ls_std::State::addStateConnection(const StateConnectionId& _connectionId, c
   return added;
 }
 
-bool ls_std::State::addStateConnection(const std::shared_ptr<StateConnection>& _connection)
+bool ls_std::State::addStateConnection(const std::shared_ptr<ls_std::StateConnection>& _connection)
 {
   bool added {};
 
@@ -54,12 +54,12 @@ ls_std::StateId ls_std::State::getId()
   return this->id;
 }
 
-bool ls_std::State::hasConnection(const StateConnectionId &_connectionId)
+bool ls_std::State::hasConnection(const ls_std::StateConnectionId &_connectionId)
 {
   return this->_hasConnection(_connectionId);
 }
 
-void ls_std::State::setId(StateId _id)
+void ls_std::State::setId(ls_std::StateId _id)
 {
   this->id = std::move(_id);
 }
@@ -69,7 +69,7 @@ void ls_std::State::_clearConnections()
   this->connectedStates.clear();
 }
 
-bool ls_std::State::_hasConnection(const StateConnectionId &_connectionId)
+bool ls_std::State::_hasConnection(const ls_std::StateConnectionId &_connectionId)
 {
   return this->connectedStates.find(_connectionId) != this->connectedStates.end();
 }

source/ls_std/logic/StateConnection.cpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-10
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <ls_std/logic/StateConnection.hpp>
 
 ls_std::StateConnection::StateConnection(ls_std::StateConnectionId _connectionId, ls_std::StateId _stateId) :
-Class("StateConnection"),
+ls_std::Class("StateConnection"),
 connectionId(std::move(_connectionId)),
 stateId(std::move(_stateId))
 {}
@@ -27,12 +27,12 @@ bool ls_std::StateConnection::isPassable() const {
   return this->condition;
 }
 
-void ls_std::StateConnection::setConnectionId(StateConnectionId _connectionId)
+void ls_std::StateConnection::setConnectionId(ls_std::StateConnectionId _connectionId)
 {
   this->connectionId = std::move(_connectionId);
 }
 
-void ls_std::StateConnection::setStateId(StateId _stateId)
+void ls_std::StateConnection::setStateId(ls_std::StateId _stateId)
 {
   this->stateId = std::move(_stateId);
 }

source/ls_std/logic/StateMachine.cpp

@@ -3,18 +3,18 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-05
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
 #include <ls_std/logic/StateMachine.hpp>
 
 ls_std::StateMachine::StateMachine(std::string _name) :
-Class("StateMachine"),
+ls_std::Class("StateMachine"),
 name(std::move(_name))
 {}
 
-bool ls_std::StateMachine::addState(const std::shared_ptr<State>& _state) {
+bool ls_std::StateMachine::addState(const std::shared_ptr<ls_std::State>& _state) {
   bool condition = !this->_hasState(_state->getId());
 
   if(condition) {
@@ -42,7 +42,7 @@ std::unordered_map<ls_std::StateId, std::shared_ptr<ls_std::State>> ls_std::Stat
   return this->states;
 }
 
-bool ls_std::StateMachine::hasState(const StateId &_id)
+bool ls_std::StateMachine::hasState(const ls_std::StateId &_id)
 {
   return this->_hasState(_id);
 }

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

@@ -11,7 +11,7 @@
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
 ls_std::SerializableJSONBoolean::SerializableJSONBoolean(const std::shared_ptr<ls_std::Boolean>& _value) :
-Class("SerializableJSONBoolean")
+ls_std::Class("SerializableJSONBoolean")
 {
   this->_assignValue(_value);
 }

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

@@ -11,7 +11,7 @@
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
 ls_std::SerializableJSONDouble::SerializableJSONDouble(const std::shared_ptr<ls_std::Double>& _value) :
-Class("SerializableJSONDouble")
+ls_std::Class("SerializableJSONDouble")
 {
   this->_assignValue(_value);
 }

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

@@ -11,7 +11,7 @@
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
 ls_std::SerializableJSONFloat::SerializableJSONFloat(const std::shared_ptr<ls_std::Float>& _value) :
-Class("SerializableJSONFloat")
+ls_std::Class("SerializableJSONFloat")
 {
   this->_assignValue(_value);
 }

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

@@ -11,7 +11,7 @@
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
 ls_std::SerializableJSONInteger::SerializableJSONInteger(const std::shared_ptr<ls_std::Integer>& _value) :
-Class("SerializableJSONInteger")
+ls_std::Class("SerializableJSONInteger")
 {
   this->_assignValue(_value);
 }

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

@@ -11,7 +11,7 @@
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
 ls_std::SerializableJSONLong::SerializableJSONLong(const std::shared_ptr<ls_std::Long>& _value) :
-Class("SerializableJSONLong")
+ls_std::Class("SerializableJSONLong")
 {
   this->_assignValue(_value);
 }

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

@@ -11,7 +11,7 @@
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
 ls_std::SerializableJSONString::SerializableJSONString(const std::shared_ptr<ls_std::String>& _value) :
-Class("SerializableJSONString")
+ls_std::Class("SerializableJSONString")
 {
   this->_assignValue(_value);
 }

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

@@ -11,8 +11,8 @@
 #include <ls_std/serialization/logic/SerializableJSONStateConnection.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
-ls_std::SerializableJSONState::SerializableJSONState(const std::shared_ptr<State>& _value) :
-Class("SerializableJSONState")
+ls_std::SerializableJSONState::SerializableJSONState(const std::shared_ptr<ls_std::State>& _value) :
+ls_std::Class("SerializableJSONState")
 {
   this->_assignValue(_value);
 }

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

@@ -11,7 +11,7 @@
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
 ls_std::SerializableJSONStateConnection::SerializableJSONStateConnection(const std::shared_ptr<ls_std::StateConnection>& _value) :
-Class("SerializableJSONStateConnection")
+ls_std::Class("SerializableJSONStateConnection")
 {
   this->_assignValue(_value);
 }

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

@@ -12,7 +12,7 @@
 #include <ls_std/exception/IllegalArgumentException.hpp>
 
 ls_std::SerializableJSONStateMachine::SerializableJSONStateMachine(const std::shared_ptr<ls_std::StateMachine>& _value) :
-Class("SerializableJSONStateMachine")
+ls_std::Class("SerializableJSONStateMachine")
 {
   this->_assignValue(_value);
 }

source/ls_std/time/Date.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2020-11-25
+ * Changed:         2020-11-26
  *
  * */
 
@@ -11,7 +11,7 @@
 #include <sstream>
 #include <ls_std/time/Date.hpp>
 
-ls_std::Date::Date() : Class("Date")
+ls_std::Date::Date() : ls_std::Class("Date")
 {
   this->timestamp = std::time(nullptr);
   this->_init();
@@ -27,11 +27,11 @@ ls_std::Date & ls_std::Date::operator-(int _value) {
   return *this;
 }
 
-bool ls_std::Date::after(const Date& _foreignDate) const {
+bool ls_std::Date::after(const ls_std::Date& _foreignDate) const {
   return this->timestamp > _foreignDate.getTime();
 }
 
-bool ls_std::Date::before(const Date& _foreignDate) const {
+bool ls_std::Date::before(const ls_std::Date& _foreignDate) const {
   return this->timestamp < _foreignDate.getTime();
 }