Rename "ls_std" namespace to "ls" namespace

include/ls_std/boxing/Boolean.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -14,9 +14,9 @@
 #include <ls_std/core/Class.hpp>
 #include "IBoxing.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class Boolean : public ls_std::Class, public ls_std::IBoxing
+  class Boolean : public ls::Class, public ls::IBoxing
   {
     public:
 
@@ -30,12 +30,12 @@ namespace ls_std
 
       // assignment operators
 
-      ls_std::Boolean &operator=(int _value);
-      ls_std::Boolean &operator=(bool _value);
+      ls::Boolean &operator=(int _value);
+      ls::Boolean &operator=(bool _value);
 
       // stream operators
 
-      friend std::ostream &operator<<(std::ostream &_outputStream, const ls_std::Boolean &_boolean)
+      friend std::ostream &operator<<(std::ostream &_outputStream, const ls::Boolean &_boolean)
       {
         _outputStream << _boolean._toString();
         return _outputStream;
@@ -43,15 +43,15 @@ namespace ls_std
 
       // logical operators
 
-      friend bool operator!(const ls_std::Boolean &_boolean)
+      friend bool operator!(const ls::Boolean &_boolean)
       {
         return !_boolean.value;
       }
 
-      bool operator&&(const ls_std::Boolean &_boolean) const;
+      bool operator&&(const ls::Boolean &_boolean) const;
       bool operator&&(bool _value) const;
       bool operator&&(int _value) const;
-      bool operator||(const ls_std::Boolean &_boolean) const;
+      bool operator||(const ls::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
@@ -64,9 +64,9 @@ namespace ls_std
       // additional functionality
 
       bool getValue() const;
-      static bool XOR(const ls_std::Boolean &_leftExpression, const ls_std::Boolean &_rightExpression);
-      static bool XOR(const ls_std::Boolean &_leftExpression, bool _rightExpression);
-      static bool XOR(bool _leftExpression, const ls_std::Boolean &_rightExpression);
+      static bool XOR(const ls::Boolean &_leftExpression, const ls::Boolean &_rightExpression);
+      static bool XOR(const ls::Boolean &_leftExpression, bool _rightExpression);
+      static bool XOR(bool _leftExpression, const ls::Boolean &_rightExpression);
       static bool XOR(bool _leftExpression, bool _rightExpression);
 
     private:

include/ls_std/boxing/Double.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -14,9 +14,9 @@
 #include <ls_std/core/Class.hpp>
 #include "IBoxing.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class Double : public ls_std::Class, public ls_std::IBoxing
+  class Double : public ls::Class, public ls::IBoxing
   {
     public:
 
@@ -30,44 +30,44 @@ namespace ls_std
 
       // assignment operators
 
-      ls_std::Double &operator=(double _value);
+      ls::Double &operator=(double _value);
 
       // arithmetic operators
 
       double operator-() const;
-      double operator+(const ls_std::Double &_double) const;
+      double operator+(const ls::Double &_double) const;
       double operator+(double _value) const;
-      double operator*(const ls_std::Double &_double) const;
+      double operator*(const ls::Double &_double) const;
       double operator*(double _value) const;
-      double operator-(const ls_std::Double &_double) const;
+      double operator-(const ls::Double &_double) const;
       double operator-(double _value) const;
-      double operator/(const ls_std::Double &_double) const;
+      double operator/(const ls::Double &_double) const;
       double operator/(double _value) const;
 
       // compound operators
 
-      ls_std::Double &operator+=(const ls_std::Double &_double);
-      ls_std::Double &operator+=(double _value);
-      ls_std::Double &operator-=(const ls_std::Double &_double);
-      ls_std::Double &operator-=(double _value);
-      ls_std::Double &operator*=(const ls_std::Double &_double);
-      ls_std::Double &operator*=(double _value);
-      ls_std::Double &operator/=(const ls_std::Double &_double);
-      ls_std::Double &operator/=(double _value);
+      ls::Double &operator+=(const ls::Double &_double);
+      ls::Double &operator+=(double _value);
+      ls::Double &operator-=(const ls::Double &_double);
+      ls::Double &operator-=(double _value);
+      ls::Double &operator*=(const ls::Double &_double);
+      ls::Double &operator*=(double _value);
+      ls::Double &operator/=(const ls::Double &_double);
+      ls::Double &operator/=(double _value);
 
       // comparison operators
 
-      bool operator==(const ls_std::Double &_double) const;
+      bool operator==(const ls::Double &_double) const;
       bool operator==(double _value) const;
-      bool operator!=(const ls_std::Double &_double) const;
+      bool operator!=(const ls::Double &_double) const;
       bool operator!=(double _value) const;
-      bool operator>(const ls_std::Double &_double) const;
+      bool operator>(const ls::Double &_double) const;
       bool operator>(double _value) const;
-      bool operator>=(const ls_std::Double &_double) const;
+      bool operator>=(const ls::Double &_double) const;
       bool operator>=(double _value) const;
-      bool operator<(const ls_std::Double &_double) const;
+      bool operator<(const ls::Double &_double) const;
       bool operator<(double _value) const;
-      bool operator<=(const ls_std::Double &_double) const;
+      bool operator<=(const ls::Double &_double) const;
       bool operator<=(double _value) const;
 
       // increment / decrement operator

include/ls_std/boxing/Float.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -14,9 +14,9 @@
 #include <ls_std/core/Class.hpp>
 #include "IBoxing.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class Float : public ls_std::Class, public ls_std::IBoxing
+  class Float : public ls::Class, public ls::IBoxing
   {
     public:
 
@@ -30,44 +30,44 @@ namespace ls_std
 
       // assignment operators
 
-      ls_std::Float &operator=(float _value);
+      ls::Float &operator=(float _value);
 
       // arithmetic operators
 
       float operator-() const;
-      float operator+(const ls_std::Float &_float) const;
+      float operator+(const ls::Float &_float) const;
       float operator+(float _value) const;
-      float operator*(const ls_std::Float &_float) const;
+      float operator*(const ls::Float &_float) const;
       float operator*(float _value) const;
-      float operator-(const ls_std::Float &_float) const;
+      float operator-(const ls::Float &_float) const;
       float operator-(float _value) const;
-      float operator/(const ls_std::Float &_float) const;
+      float operator/(const ls::Float &_float) const;
       float operator/(float _value) const;
 
       // compound operators
 
-      ls_std::Float &operator+=(const ls_std::Float &_float);
-      ls_std::Float &operator+=(float _value);
-      ls_std::Float &operator-=(const ls_std::Float &_float);
-      ls_std::Float &operator-=(float _value);
-      ls_std::Float &operator*=(const ls_std::Float &_float);
-      ls_std::Float &operator*=(float _value);
-      ls_std::Float &operator/=(const ls_std::Float &_float);
-      ls_std::Float &operator/=(float _value);
+      ls::Float &operator+=(const ls::Float &_float);
+      ls::Float &operator+=(float _value);
+      ls::Float &operator-=(const ls::Float &_float);
+      ls::Float &operator-=(float _value);
+      ls::Float &operator*=(const ls::Float &_float);
+      ls::Float &operator*=(float _value);
+      ls::Float &operator/=(const ls::Float &_float);
+      ls::Float &operator/=(float _value);
 
       // comparison operators
 
-      bool operator==(const ls_std::Float &_float) const;
+      bool operator==(const ls::Float &_float) const;
       bool operator==(float _value) const;
-      bool operator!=(const ls_std::Float &_float) const;
+      bool operator!=(const ls::Float &_float) const;
       bool operator!=(float _value) const;
-      bool operator>(const ls_std::Float &_float) const;
+      bool operator>(const ls::Float &_float) const;
       bool operator>(float _value) const;
-      bool operator>=(const ls_std::Float &_float) const;
+      bool operator>=(const ls::Float &_float) const;
       bool operator>=(float _value) const;
-      bool operator<(const ls_std::Float &_float) const;
+      bool operator<(const ls::Float &_float) const;
       bool operator<(float _value) const;
-      bool operator<=(const ls_std::Float &_float) const;
+      bool operator<=(const ls::Float &_float) const;
       bool operator<=(float _value) const;
 
       // increment / decrement operator

include/ls_std/boxing/IBoxing.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2021-04-23
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
   class IBoxing
   {

include/ls_std/boxing/Integer.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -16,9 +16,9 @@
 #include <ls_std/serialization/ISerializable.hpp>
 #include <ls_std/io/IStorable.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class Integer : public ls_std::Class, public ls_std::IBoxing
+  class Integer : public ls::Class, public ls::IBoxing
   {
     public:
 
@@ -32,59 +32,59 @@ namespace ls_std
 
       // assignment operators
 
-      ls_std::Integer &operator=(int _value);
+      ls::Integer &operator=(int _value);
 
       // arithmetic operators
 
       int operator-() const;
-      int operator+(const ls_std::Integer &_integer) const;
+      int operator+(const ls::Integer &_integer) const;
       int operator+(int _value) const;
-      int operator*(const ls_std::Integer &_integer) const;
+      int operator*(const ls::Integer &_integer) const;
       int operator*(int _value) const;
-      int operator-(const ls_std::Integer &_integer) const;
+      int operator-(const ls::Integer &_integer) const;
       int operator-(int _value) const;
-      int operator/(const ls_std::Integer &_integer) const;
+      int operator/(const ls::Integer &_integer) const;
       int operator/(int _value) const;
-      int operator%(const ls_std::Integer &_integer) const;
+      int operator%(const ls::Integer &_integer) const;
       int operator%(int _value) const;
 
       // compound operators
 
-      ls_std::Integer &operator+=(const ls_std::Integer &_integer);
-      ls_std::Integer &operator+=(int _value);
-      ls_std::Integer &operator-=(const ls_std::Integer &_integer);
-      ls_std::Integer &operator-=(int _value);
-      ls_std::Integer &operator*=(const ls_std::Integer &_integer);
-      ls_std::Integer &operator*=(int _value);
-      ls_std::Integer &operator/=(const ls_std::Integer &_integer);
-      ls_std::Integer &operator/=(int _value);
+      ls::Integer &operator+=(const ls::Integer &_integer);
+      ls::Integer &operator+=(int _value);
+      ls::Integer &operator-=(const ls::Integer &_integer);
+      ls::Integer &operator-=(int _value);
+      ls::Integer &operator*=(const ls::Integer &_integer);
+      ls::Integer &operator*=(int _value);
+      ls::Integer &operator/=(const ls::Integer &_integer);
+      ls::Integer &operator/=(int _value);
 
       // comparison operators
 
-      bool operator==(const ls_std::Integer &_integer) const;
+      bool operator==(const ls::Integer &_integer) const;
       bool operator==(int _value) const;
-      bool operator!=(const ls_std::Integer &_integer) const;
+      bool operator!=(const ls::Integer &_integer) const;
       bool operator!=(int _value) const;
-      bool operator>(const ls_std::Integer &_integer) const;
+      bool operator>(const ls::Integer &_integer) const;
       bool operator>(int _value) const;
-      bool operator>=(const ls_std::Integer &_integer) const;
+      bool operator>=(const ls::Integer &_integer) const;
       bool operator>=(int _value) const;
-      bool operator<(const ls_std::Integer &_integer) const;
+      bool operator<(const ls::Integer &_integer) const;
       bool operator<(int _value) const;
-      bool operator<=(const ls_std::Integer &_integer) const;
+      bool operator<=(const ls::Integer &_integer) const;
       bool operator<=(int _value) const;
 
       // logical operators
 
-      friend bool operator!(const ls_std::Integer &_integer)
+      friend bool operator!(const ls::Integer &_integer)
       {
         return !_integer.value;
       }
 
-      bool operator&&(const ls_std::Integer &_integer) const;
+      bool operator&&(const ls::Integer &_integer) const;
       bool operator&&(int _value) const;
       bool operator&&(bool _expression) const;
-      bool operator||(const ls_std::Integer &_integer) const;
+      bool operator||(const ls::Integer &_integer) const;
       bool operator||(int _value) const;
       bool operator||(bool _expression) const;
 

include/ls_std/boxing/Long.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -17,76 +17,76 @@
 #include <ls_std/serialization/ISerializable.hpp>
 #include <ls_std/io/IStorable.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class Long : public ls_std::Class, public ls_std::IBoxing
+  class Long : public ls::Class, public ls::IBoxing
   {
     public:
 
-      explicit Long(ls_std::long_type _value);
+      explicit Long(ls::long_type _value);
       Long();
       ~Long() override = default;
 
       // conversion operator
 
-      operator ls_std::long_type() const;
+      operator ls::long_type() const;
 
       // assignment operators
 
-      ls_std::Long &operator=(ls_std::long_type _value);
+      ls::Long &operator=(ls::long_type _value);
 
       // arithmetic operators
 
-      ls_std::long_type operator-() const;
-      ls_std::long_type operator+(const ls_std::Long &_long) const;
-      ls_std::long_type operator+(ls_std::long_type _value) const;
-      ls_std::long_type operator*(const ls_std::Long &_long) const;
-      ls_std::long_type operator*(ls_std::long_type _value) const;
-      ls_std::long_type operator-(const ls_std::Long &_long) const;
-      ls_std::long_type operator-(ls_std::long_type _value) const;
-      ls_std::long_type operator/(const ls_std::Long &_long) const;
-      ls_std::long_type operator/(ls_std::long_type _value) const;
-      ls_std::long_type operator%(const ls_std::Long &_long) const;
-      ls_std::long_type operator%(ls_std::long_type _value) const;
+      ls::long_type operator-() const;
+      ls::long_type operator+(const ls::Long &_long) const;
+      ls::long_type operator+(ls::long_type _value) const;
+      ls::long_type operator*(const ls::Long &_long) const;
+      ls::long_type operator*(ls::long_type _value) const;
+      ls::long_type operator-(const ls::Long &_long) const;
+      ls::long_type operator-(ls::long_type _value) const;
+      ls::long_type operator/(const ls::Long &_long) const;
+      ls::long_type operator/(ls::long_type _value) const;
+      ls::long_type operator%(const ls::Long &_long) const;
+      ls::long_type operator%(ls::long_type _value) const;
 
       // compound operators
 
-      ls_std::Long &operator+=(const ls_std::Long &_long);
-      ls_std::Long &operator+=(ls_std::long_type _value);
-      ls_std::Long &operator-=(const ls_std::Long &_long);
-      ls_std::Long &operator-=(ls_std::long_type _value);
-      ls_std::Long &operator*=(const ls_std::Long &_long);
-      ls_std::Long &operator*=(ls_std::long_type _value);
-      ls_std::Long &operator/=(const ls_std::Long &_long);
-      ls_std::Long &operator/=(ls_std::long_type _value);
+      ls::Long &operator+=(const ls::Long &_long);
+      ls::Long &operator+=(ls::long_type _value);
+      ls::Long &operator-=(const ls::Long &_long);
+      ls::Long &operator-=(ls::long_type _value);
+      ls::Long &operator*=(const ls::Long &_long);
+      ls::Long &operator*=(ls::long_type _value);
+      ls::Long &operator/=(const ls::Long &_long);
+      ls::Long &operator/=(ls::long_type _value);
 
       // comparison operators
 
-      bool operator==(const ls_std::Long &_long) const;
-      bool operator==(ls_std::long_type _value) const;
-      bool operator!=(const ls_std::Long &_long) const;
-      bool operator!=(ls_std::long_type _value) const;
-      bool operator>(const ls_std::Long &_long) const;
-      bool operator>(ls_std::long_type _value) const;
-      bool operator>=(const ls_std::Long &_long) const;
-      bool operator>=(ls_std::long_type _value) const;
-      bool operator<(const ls_std::Long &_long) const;
-      bool operator<(ls_std::long_type _value) const;
-      bool operator<=(const ls_std::Long &_long) const;
-      bool operator<=(ls_std::long_type _value) const;
+      bool operator==(const ls::Long &_long) const;
+      bool operator==(ls::long_type _value) const;
+      bool operator!=(const ls::Long &_long) const;
+      bool operator!=(ls::long_type _value) const;
+      bool operator>(const ls::Long &_long) const;
+      bool operator>(ls::long_type _value) const;
+      bool operator>=(const ls::Long &_long) const;
+      bool operator>=(ls::long_type _value) const;
+      bool operator<(const ls::Long &_long) const;
+      bool operator<(ls::long_type _value) const;
+      bool operator<=(const ls::Long &_long) const;
+      bool operator<=(ls::long_type _value) const;
 
       // logical operators
 
-      friend bool operator!(const ls_std::Long &_long)
+      friend bool operator!(const ls::Long &_long)
       {
         return !_long.value;
       }
 
-      bool operator&&(const ls_std::Long &_long) const;
-      bool operator&&(ls_std::long_type _value) const;
+      bool operator&&(const ls::Long &_long) const;
+      bool operator&&(ls::long_type _value) const;
       bool operator&&(bool _expression) const;
-      bool operator||(const ls_std::Long &_long) const;
-      bool operator||(ls_std::long_type _value) const;
+      bool operator||(const ls::Long &_long) const;
+      bool operator||(ls::long_type _value) const;
       bool operator||(bool _expression) const;
 
       // increment / decrement operator
@@ -101,11 +101,11 @@ namespace ls_std
 
       // additional functionality
 
-      ls_std::long_type getValue() const;
+      ls::long_type getValue() const;
 
     private:
 
-      ls_std::long_type value{};
+      ls::long_type value{};
   };
 }
 

include/ls_std/boxing/String.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -17,9 +17,9 @@
 #include <memory>
 #include <vector>
 
-namespace ls_std
+namespace ls
 {
-  class String : public ls_std::Class, public ls_std::IBoxing
+  class String : public ls::Class, public ls::IBoxing
   {
     public:
 
@@ -34,26 +34,26 @@ namespace ls_std
 
       // assignment operators
 
-      ls_std::String &operator=(std::string _value);
+      ls::String &operator=(std::string _value);
 
       // arithmetic operators
 
-      std::string operator+(ls_std::String _string) const;
+      std::string operator+(ls::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
 
-      ls_std::String &operator+=(ls_std::String _string);
-      ls_std::String &operator+=(const std::string &_text);
+      ls::String &operator+=(ls::String _string);
+      ls::String &operator+=(const std::string &_text);
 
       // comparison operators
 
-      bool operator==(ls_std::String _string);
+      bool operator==(ls::String _string);
       bool operator==(const std::string &_value);
       bool operator==(const char *_value);
-      bool operator!=(ls_std::String _string);
+      bool operator!=(ls::String _string);
       bool operator!=(const std::string &_value);
       bool operator!=(const char *_value);
 
@@ -66,9 +66,9 @@ namespace ls_std
 
       bool contains(const std::string &_text);
       bool endsWith(const std::string &_text);
-      bool equalsIgnoreCase(ls_std::String _string);
+      bool equalsIgnoreCase(ls::String _string);
       bool equalsIgnoreCase(std::string _text);
-      std::vector<ls_std::byte> getByteData();
+      std::vector<ls::byte> getByteData();
       std::string padLeft(size_t _width, char _fillCharacter);
       std::string padRight(size_t _width, char _fillCharacter);
       std::string reverse();

include/ls_std/core/Class.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
   class Class
   {

include/ls_std/core/LibraryVersion.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-02
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
   static std::string getVersion()
   {

include/ls_std/core/Types.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
   using byte = char;
   using byte_field = std::string;

include/ls_std/core/Version.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -14,35 +14,35 @@
 #include <ls_std/serialization/ISerializable.hpp>
 #include "Types.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class Version : public ls_std::ISerializable
+  class Version : public ls::ISerializable
   {
     public:
 
-      explicit Version(ls_std::version_type _majorVersion, ls_std::version_type _minorVersion, ls_std::version_type _patchVersion);
+      explicit Version(ls::version_type _majorVersion, ls::version_type _minorVersion, ls::version_type _patchVersion);
       ~Version() = default;
 
       // implementation
 
-      ls_std::byte_field marshal() override;
-      void unmarshal(const ls_std::byte_field &_data) override;
+      ls::byte_field marshal() override;
+      void unmarshal(const ls::byte_field &_data) override;
 
       // other functionality
 
-      ls_std::version_type getMajorVersion() const;
-      ls_std::version_type getMinorVersion() const;
-      ls_std::version_type getPatchVersion() const;
+      ls::version_type getMajorVersion() const;
+      ls::version_type getMinorVersion() const;
+      ls::version_type getPatchVersion() const;
       static bool isValid(const std::string &_versionString);
-      void setMajorVersion(ls_std::version_type _major);
-      void setMinorVersion(ls_std::version_type _minor);
-      void setPatchVersion(ls_std::version_type _patch);
+      void setMajorVersion(ls::version_type _major);
+      void setMinorVersion(ls::version_type _minor);
+      void setPatchVersion(ls::version_type _patch);
 
     private:
 
-      ls_std::version_type majorVersion{};
-      ls_std::version_type minorVersion{};
-      ls_std::version_type patchVersion{};
+      ls::version_type majorVersion{};
+      ls::version_type minorVersion{};
+      ls::version_type patchVersion{};
 
       static bool _isValid(const std::string &_versionString);
   };

include/ls_std/core/exception/EventNotHandledException.hpp

@@ -12,7 +12,7 @@
 
 #include <exception>
 
-namespace ls_std
+namespace ls
 {
   class EventNotHandledException : public std::exception
   {

include/ls_std/core/exception/EventNotSubscribedException.hpp

@@ -12,7 +12,7 @@
 
 #include <exception>
 
-namespace ls_std
+namespace ls
 {
   class EventNotSubscribedException : public std::exception
   {

include/ls_std/core/exception/FileNotFoundException.hpp

@@ -15,7 +15,7 @@
 #include <cstring>
 
 // TODO: pass parameters, use class, show class name
-namespace ls_std
+namespace ls
 {
   class FileNotFoundException : public std::exception
   {

include/ls_std/core/exception/FileOperationException.hpp

@@ -13,7 +13,7 @@
 #include <exception>
 #include <string>
 
-namespace ls_std
+namespace ls
 {
   class FileOperationException : public std::exception
   {

include/ls_std/core/exception/IllegalArgumentException.hpp

@@ -12,7 +12,7 @@
 
 #include <exception>
 
-namespace ls_std
+namespace ls
 {
   class IllegalArgumentException : public std::exception
   {

include/ls_std/core/exception/IllegalArithmeticOperationException.hpp

@@ -12,7 +12,7 @@
 
 #include <exception>
 
-namespace ls_std
+namespace ls
 {
   class IllegalArithmeticOperationException : public std::exception
   {

include/ls_std/core/exception/IncompleteJsonException.hpp

@@ -12,7 +12,7 @@
 
 #include <exception>
 
-namespace ls_std
+namespace ls
 {
   class IncompleteJsonException : public std::exception
   {

include/ls_std/core/exception/NullPointerException.hpp

@@ -12,7 +12,7 @@
 
 #include <exception>
 
-namespace ls_std
+namespace ls
 {
   class NullPointerException : public std::exception
   {

include/ls_std/core/factory/IFactory.hpp

@@ -13,7 +13,7 @@
 #include <memory>
 #include "ls_std/core/Class.hpp"
 
-namespace ls_std
+namespace ls
 {
   class IFactory
   {
@@ -22,7 +22,7 @@ namespace ls_std
       IFactory() = default;
       ~IFactory() = default;
 
-      virtual std::shared_ptr<ls_std::Class> build() = 0;
+      virtual std::shared_ptr<ls::Class> build() = 0;
   };
 }
 

include/ls_std/core/utils/RegexUtils.hpp

@@ -13,7 +13,7 @@
 #include <string>
 #include <regex>
 
-namespace ls_std
+namespace ls
 {
   class RegexUtils
   {

include/ls_std/core/utils/STLUtils.hpp

@@ -13,7 +13,7 @@
 #include <algorithm>
 #include <list>
 
-namespace ls_std
+namespace ls
 {
   class STLUtils
   {

include/ls_std/core/utils/WindowsUtils.hpp

@@ -14,7 +14,7 @@
 #include <string>
 #include <windows.h>
 
-namespace ls_std
+namespace ls
 {
   class WindowsUtils
   {
@@ -25,7 +25,7 @@ namespace ls_std
 
       static std::string getMessageFromErrorCode(const int &_errorCode)
       {
-        ls_std::byte messageBuffer[256 + 1];
+        ls::byte messageBuffer[256 + 1];
         FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, _errorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), messageBuffer, sizeof(messageBuffer), nullptr);
 
         return std::string{messageBuffer};

include/ls_std/event/Event.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -15,31 +15,31 @@
 #include <memory>
 #include "EventTypes.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class Event : public ls_std::Class
+  class Event : public ls::Class
   {
     public:
 
-      explicit Event(const ls_std::event_id &_id);
+      explicit Event(const ls::event_id &_id);
       ~Event() override = default;
 
       // additional functionality
 
-      bool addParameter(const ls_std::event_parameter &_eventParameter);
+      bool addParameter(const ls::event_parameter &_eventParameter);
       void clearParameterList();
-      ls_std::event_id getId();
-      ls_std::event_parameter_list getParameterList();
-      bool removeParameter(const ls_std::event_parameter_id &_id);
-      void setId(const ls_std::event_id &_id);
+      ls::event_id getId();
+      ls::event_parameter_list getParameterList();
+      bool removeParameter(const ls::event_parameter_id &_id);
+      void setId(const ls::event_id &_id);
 
     private:
 
-      ls_std::event_id id{};
-      ls_std::event_parameter_list parameterList{};
+      ls::event_id id{};
+      ls::event_parameter_list parameterList{};
 
-      void _assignId(const ls_std::event_id &_id);
-      bool _hasParameter(const ls_std::event_id &_id);
+      void _assignId(const ls::event_id &_id);
+      bool _hasParameter(const ls::event_id &_id);
   };
 }
 

include/ls_std/event/EventHandler.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -17,22 +17,22 @@
 #include "Event.hpp"
 #include <ls_std/logic/Narrator.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class EventHandler : public ls_std::Narrator
+  class EventHandler : public ls::Narrator
   {
     public:
 
-      explicit EventHandler(const ls_std::event_id& _id);
+      explicit EventHandler(const ls::event_id& _id);
       ~EventHandler() override = default;
 
-      ls_std::event_id getId();
+      ls::event_id getId();
 
     private:
 
-      ls_std::event_id id{};
+      ls::event_id id{};
 
-      void _assignId(const ls_std::event_id& _id);
+      void _assignId(const ls::event_id& _id);
   };
 }
 

include/ls_std/event/EventManager.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -17,9 +17,9 @@
 #include "EventHandler.hpp"
 #include "IEventSubscriber.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class EventManager : public ls_std::Class, public ls_std::IEventSubscriber
+  class EventManager : public ls::Class, public ls::IEventSubscriber
   {
     public:
 
@@ -28,22 +28,22 @@ namespace ls_std
 
       // implementation
 
-      void subscribe(const ls_std::event_id &_id, const std::shared_ptr<ls_std::IListener> &_listener) override;
-      void unsubscribe(const ls_std::event_id &_id, const std::shared_ptr<ls_std::IListener> &_listener) override;
+      void subscribe(const ls::event_id &_id, const std::shared_ptr<ls::IListener> &_listener) override;
+      void unsubscribe(const ls::event_id &_id, const std::shared_ptr<ls::IListener> &_listener) override;
 
       // additional functionality
 
-      bool addEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
-      void fire(ls_std::Event _event);
-      bool hasEventHandler(const ls_std::event_id &_id);
-      bool removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
+      bool addEventHandler(const std::shared_ptr<ls::EventHandler> &_eventHandler);
+      void fire(ls::Event _event);
+      bool hasEventHandler(const ls::event_id &_id);
+      bool removeEventHandler(const std::shared_ptr<ls::EventHandler> &_eventHandler);
 
     private:
 
-      std::map<ls_std::event_id, std::shared_ptr<ls_std::EventHandler>> eventHandlers{};
+      std::map<ls::event_id, std::shared_ptr<ls::EventHandler>> eventHandlers{};
 
-      bool _hasEventHandler(const ls_std::event_id &_id);
-      bool _removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
+      bool _hasEventHandler(const ls::event_id &_id);
+      bool _removeEventHandler(const std::shared_ptr<ls::EventHandler> &_eventHandler);
   };
 }
 

include/ls_std/event/EventTypes.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2021-05-01
+ * Changed:         2022-05-05
  *
  * */
 
@@ -14,13 +14,13 @@
 #include <vector>
 #include <map>
 
-namespace ls_std
+namespace ls
 {
   using event_id = std::string;
   using event_parameter_id = std::string;
   using event_parameter_value = std::string;
   using event_parameter = std::pair<std::string, std::string>;
-  using event_parameter_list = std::map<ls_std::event_parameter_id, ls_std::event_parameter_value>;
+  using event_parameter_list = std::map<ls::event_parameter_id, ls::event_parameter_value>;
 }
 
 #endif

include/ls_std/event/IEventSubscriber.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2021-05-01
+ * Changed:         2022-05-05
  *
  * */
 
@@ -14,7 +14,7 @@
 #include <memory>
 #include <ls_std/logic/IListener.hpp>
 
-namespace ls_std
+namespace ls
 {
   class IEventSubscriber
   {
@@ -23,8 +23,8 @@ namespace ls_std
       IEventSubscriber() = default;
       ~IEventSubscriber() = default;
 
-      virtual void subscribe(const ls_std::event_id &_id, const std::shared_ptr<ls_std::IListener> &_listener) = 0;
-      virtual void unsubscribe(const ls_std::event_id &_id, const std::shared_ptr<ls_std::IListener> &_listener) = 0;
+      virtual void subscribe(const ls::event_id &_id, const std::shared_ptr<ls::IListener> &_listener) = 0;
+      virtual void unsubscribe(const ls::event_id &_id, const std::shared_ptr<ls::IListener> &_listener) = 0;
   };
 }
 

include/ls_std/event/serialization/SerializableJsonEvent.hpp

@@ -16,31 +16,31 @@
 #include <memory>
 #include "ls_std/lib/nlohmann_json/include/nlohmann/json.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class SerializableJsonEvent : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonEvent : public ls::Class, public ls::ISerializable
   {
     public:
 
-      explicit SerializableJsonEvent(const std::shared_ptr<ls_std::Event> &_value);
+      explicit SerializableJsonEvent(const std::shared_ptr<ls::Event> &_value);
       ~SerializableJsonEvent() override = default;
 
       // implementation
 
-      ls_std::byte_field marshal() override;
-      void unmarshal(const ls_std::byte_field &_data) override;
+      ls::byte_field marshal() override;
+      void unmarshal(const ls::byte_field &_data) override;
 
       // additional functionality
 
-      std::shared_ptr<ls_std::Event> getValue();
-      void setValue(const std::shared_ptr<ls_std::Event> &_value);
+      std::shared_ptr<ls::Event> getValue();
+      void setValue(const std::shared_ptr<ls::Event> &_value);
 
     private:
 
       nlohmann::json jsonObject{};
-      std::shared_ptr<ls_std::Event> value{};
+      std::shared_ptr<ls::Event> value{};
 
-      void _assignValue(const std::shared_ptr<ls_std::Event> &_value);
+      void _assignValue(const std::shared_ptr<ls::Event> &_value);
       void _unmarshalParameterList();
       void _update();
       void _updateEventParameterList();

include/ls_std/io/File.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -29,9 +29,9 @@
 
 #endif
 
-namespace ls_std
+namespace ls
 {
-  class File : public ls_std::Class
+  class File : public ls::Class
   {
     public:
 
@@ -40,8 +40,8 @@ namespace ls_std
 
       // comparison operators
 
-      bool operator==(ls_std::File &_file);
-      bool operator!=(ls_std::File &_file);
+      bool operator==(ls::File &_file);
+      bool operator!=(ls::File &_file);
 
       // additional functionality
 
@@ -76,7 +76,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(ls_std::File &_file, ls_std::File &_foreignFile);
+      static bool _equals(ls::File &_file, ls::File &_foreignFile);
       static bool _exists(const std::string &_path);
       static std::string _getParent(const std::string &_path);
       #if defined(unix) || defined(__APPLE__)

include/ls_std/io/FileOutputStream.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -15,23 +15,23 @@
 #include "IWriter.hpp"
 #include <fstream>
 
-namespace ls_std
+namespace ls
 {
-  class FileOutputStream : public ls_std::Class, public ls_std::IWriter
+  class FileOutputStream : public ls::Class, public ls::IWriter
   {
     public:
 
-      explicit FileOutputStream(ls_std::File &_file);
-      explicit FileOutputStream(ls_std::File &_file, bool _append);
+      explicit FileOutputStream(ls::File &_file);
+      explicit FileOutputStream(ls::File &_file, bool _append);
       ~FileOutputStream() override;
 
       void close();
-      bool write(const ls_std::byte_field &_data) override;
+      bool write(const ls::byte_field &_data) override;
 
     private:
 
       bool append{};
-      ls_std::File file;
+      ls::File file;
       std::ofstream outputStream{};
 
       void _close();

include/ls_std/io/FilePathSeparator.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2021-04-23
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
   class FilePathSeparator
   {
@@ -26,10 +26,10 @@ namespace ls_std
         char separator;
 
         #ifdef _WIN32
-        separator = ls_std::FilePathSeparator::getWindowsFilePathSeparator();
+        separator = ls::FilePathSeparator::getWindowsFilePathSeparator();
         #endif
         #if defined(unix) || defined(__APPLE__)
-        separator = ls_std::FilePathSeparator::getUnixFilePathSeparator();
+        separator = ls::FilePathSeparator::getUnixFilePathSeparator();
         #endif
 
         return separator;

include/ls_std/io/FilePathSeparatorMatch.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2021-04-23
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,13 +12,13 @@
 
 #include "FilePathSeparator.hpp"
 
-namespace ls_std
+namespace ls
 {
   struct FilePathSeparatorMatch
   {
     bool operator()(char _char) const
     {
-      return _char == ls_std::FilePathSeparator::getWindowsFilePathSeparator() || _char == ls_std::FilePathSeparator::getUnixFilePathSeparator();
+      return _char == ls::FilePathSeparator::getWindowsFilePathSeparator() || _char == ls::FilePathSeparator::getUnixFilePathSeparator();
     }
   };
 }

include/ls_std/io/FileReader.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -14,23 +14,23 @@
 #include "File.hpp"
 #include "IReader.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class FileReader : public ls_std::Class, public ls_std::IReader
+  class FileReader : public ls::Class, public ls::IReader
   {
     public:
 
-      explicit FileReader(ls_std::File &_file);
+      explicit FileReader(ls::File &_file);
       ~FileReader() override = default;
 
-      ls_std::byte_field read() override;
-      void reset(ls_std::File &_file);
+      ls::byte_field read() override;
+      void reset(ls::File &_file);
 
     private:
 
-      ls_std::File file;
+      ls::File file;
 
-      static void _init(ls_std::File &_file);
+      static void _init(ls::File &_file);
   };
 }
 

include/ls_std/io/FileWriter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -14,23 +14,23 @@
 #include "IWriter.hpp"
 #include "File.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class FileWriter : public ls_std::Class, public ls_std::IWriter
+  class FileWriter : public ls::Class, public ls::IWriter
   {
     public:
 
-      explicit FileWriter(ls_std::File &_file);
+      explicit FileWriter(ls::File &_file);
       ~FileWriter() override = default;
 
-      void reset(ls_std::File &_file);
-      bool write(const ls_std::byte_field &_data) override;
+      void reset(ls::File &_file);
+      bool write(const ls::byte_field &_data) override;
 
     private:
 
-      ls_std::File file;
+      ls::File file;
 
-      static void _init(ls_std::File &_file);
+      static void _init(ls::File &_file);
   };
 }
 

include/ls_std/io/IReader.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <ls_std/core/Types.hpp>
 
-namespace ls_std
+namespace ls
 {
   class IReader
   {
@@ -21,7 +21,7 @@ namespace ls_std
       IReader() = default;
       ~IReader() = default;
 
-      virtual ls_std::byte_field read() = 0;
+      virtual ls::byte_field read() = 0;
   };
 }
 

include/ls_std/io/IStorable.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <ls_std/core/Types.hpp>
 
-namespace ls_std
+namespace ls
 {
   class IStorable
   {
@@ -20,8 +20,8 @@ namespace ls_std
       IStorable() = default;
       ~IStorable() = default;
 
-      virtual ls_std::byte_field load() = 0;
-      virtual void save(const ls_std::byte_field &_data) = 0;
+      virtual ls::byte_field load() = 0;
+      virtual void save(const ls::byte_field &_data) = 0;
   };
 }
 

include/ls_std/io/IWriter.hpp

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

include/ls_std/io/NewLine.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-18
- * Changed:         2021-04-23
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
   class NewLine
   {
@@ -26,10 +26,10 @@ namespace ls_std
         std::string newLine{};
 
         #if defined(unix) || defined(__APPLE__)
-        newLine = ls_std::NewLine::getUnixNewLine();
+        newLine = ls::NewLine::getUnixNewLine();
         #endif
         #ifdef _WIN32
-        newLine = ls_std::NewLine::getWindowsNewLine();
+        newLine = ls::NewLine::getWindowsNewLine();
         #endif
 
         return newLine;

include/ls_std/io/StandardOutputWriter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-06
- * Changed:         2021-05-01
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,16 +12,16 @@
 
 #include "IWriter.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class StandardOutputWriter : public ls_std::IWriter
+  class StandardOutputWriter : public ls::IWriter
   {
     public:
 
       StandardOutputWriter() = default;
       ~StandardOutputWriter() = default;
 
-      bool write(const ls_std::byte_field &_data) override;
+      bool write(const ls::byte_field &_data) override;
   };
 }
 

include/ls_std/io/StorableFile.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2021-05-01
+ * Changed:         2022-05-05
  *
  * */
 
@@ -15,23 +15,23 @@
 #include "IStorable.hpp"
 #include "File.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class StorableFile : public ls_std::IStorable
+  class StorableFile : public ls::IStorable
   {
     public:
 
       explicit StorableFile(const std::string &_path);
       ~StorableFile() = default;
 
-      std::shared_ptr<ls_std::File> getFile();
-      ls_std::byte_field load() override;
+      std::shared_ptr<ls::File> getFile();
+      ls::byte_field load() override;
       void reset(const std::string &_path);
-      void save(const ls_std::byte_field &_data) override;
+      void save(const ls::byte_field &_data) override;
 
     private:
 
-      std::shared_ptr<ls_std::File> file{};
+      std::shared_ptr<ls::File> file{};
 
       void _init(const std::string &_path);
   };

include/ls_std/io/kv/KvDocument.hpp

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

include/ls_std/io/kv/KvFileReader.hpp

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

include/ls_std/io/kv/KvPair.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -13,25 +13,25 @@
 #include <ls_std/core/Class.hpp>
 #include "KvTypes.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class KvPair : public ls_std::Class
+  class KvPair : public ls::Class
   {
     public:
 
-      explicit KvPair(const ls_std::kv_key &_key, ls_std::kv_value _value);
+      explicit KvPair(const ls::kv_key &_key, ls::kv_value _value);
       ~KvPair() override = default;
 
-      ls_std::kv_key getKey();
-      ls_std::kv_value getValue();
-      void setValue(const ls_std::kv_value &_value);
+      ls::kv_key getKey();
+      ls::kv_value getValue();
+      void setValue(const ls::kv_value &_value);
 
     private:
 
-      ls_std::kv_key key{};
-      ls_std::kv_value value{};
+      ls::kv_key key{};
+      ls::kv_value value{};
 
-      void _assignKey(const ls_std::kv_key &_key);
+      void _assignKey(const ls::kv_key &_key);
   };
 }
 

include/ls_std/io/kv/KvParseParameter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-05-02
+ * Changed:         2022-05-05
  *
  * */
 
@@ -13,12 +13,12 @@
 #include <string>
 #include <ls_std/boxing/String.hpp>
 
-namespace ls_std
+namespace ls
 {
   struct KvParseParameter
   {
     std::string::size_type index{};
-    ls_std::String line{};
+    ls::String line{};
   };
 }
 

include/ls_std/io/kv/KvParser.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -16,30 +16,30 @@
 #include "KvParseParameter.hpp"
 #include <memory>
 
-namespace ls_std
+namespace ls
 {
-  class KvParser : public ls_std::Class
+  class KvParser : public ls::Class
   {
     public:
 
-      explicit KvParser(const std::shared_ptr<ls_std::KvDocument> &_document);
+      explicit KvParser(const std::shared_ptr<ls::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);
+      std::shared_ptr<ls::KvDocument> getDocument();
+      void parse(const ls::byte_field &_data);
+      void setDocument(const std::shared_ptr<ls::KvDocument> &_document);
 
     private:
 
-      std::shared_ptr<ls_std::KvDocument> document{};
+      std::shared_ptr<ls::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);
+      void _assignDocument(const std::shared_ptr<ls::KvDocument> &_document);
+      static bool _lineHasPair(ls::KvParseParameter _parseParameter);
+      void _parse(const ls::byte_field &_data);
+      void _parsePair(ls::KvParseParameter _parseParameter);
+      static ls::KvParseParameter _readLine(const ls::byte_field &_data, std::string::size_type _index);
+      static void _readLineWithUnixLineBreak(ls::KvParseParameter &_parseParameter);
+      static void _readLineWithWindowsLineBreak(ls::KvParseParameter &_parseParameter);
   };
 }
 

include/ls_std/io/kv/KvTypes.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-04-23
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
   using kv_key = std::string;
   using kv_value = std::string;

include/ls_std/io/logging/LogLevel.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -14,34 +14,34 @@
 #include <ls_std/core/Class.hpp>
 #include "LogLevelValue.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class LogLevel : public ls_std::Class
+  class LogLevel : public ls::Class
   {
     public:
 
-      explicit LogLevel(const ls_std::LogLevelValue &_value);
+      explicit LogLevel(const ls::LogLevelValue &_value);
       LogLevel();
       ~LogLevel() override = default;
 
       operator unsigned char() const;
-      ls_std::LogLevel &operator=(const ls_std::LogLevelValue &_value);
-      bool operator<(const ls_std::LogLevelValue &_value);
-      bool operator<=(const ls_std::LogLevelValue &_value);
-      bool operator>(const ls_std::LogLevelValue &_value);
-      bool operator>=(const ls_std::LogLevelValue &_value);
-      bool operator==(const ls_std::LogLevelValue &_value);
-
-      void setLogLevel(const ls_std::LogLevelValue &_value);
+      ls::LogLevel &operator=(const ls::LogLevelValue &_value);
+      bool operator<(const ls::LogLevelValue &_value);
+      bool operator<=(const ls::LogLevelValue &_value);
+      bool operator>(const ls::LogLevelValue &_value);
+      bool operator>=(const ls::LogLevelValue &_value);
+      bool operator==(const ls::LogLevelValue &_value);
+
+      void setLogLevel(const ls::LogLevelValue &_value);
       void setLogLevel(const std::string &_value);
       std::string toString() const;
 
     private:
 
       std::unordered_map<uint8_t, std::string> level{};
-      ls_std::LogLevelValue value{};
+      ls::LogLevelValue value{};
 
-      ls_std::LogLevelValue _getValueFromString(const std::string &_value);
+      ls::LogLevelValue _getValueFromString(const std::string &_value);
       void _init();
       bool _isValidLogLevelString(const std::string &_value);
   };

include/ls_std/io/logging/LogLevelValue.hpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2021-05-02
+ * Changed:         2022-05-05
  *
  * */
 
 #ifndef LS_STD_LOG_LEVEL_VALUE_HPP
 #define LS_STD_LOG_LEVEL_VALUE_HPP
 
-namespace ls_std
+namespace ls
 {
   enum LogLevelValue
   {

include/ls_std/io/logging/Logger.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -17,31 +17,31 @@
 #include <ls_std/io/FileOutputStream.hpp>
 #include <string>
 
-namespace ls_std
+namespace ls
 {
-  class Logger : public ls_std::Class
+  class Logger : public ls::Class
   {
     public:
 
-      explicit Logger(const std::shared_ptr<ls_std::IWriter> &_writer);
+      explicit Logger(const std::shared_ptr<ls::IWriter> &_writer);
       ~Logger() override = default;
 
-      void debug(const ls_std::byte *_data);
-      void error(const ls_std::byte *_data);
-      void fatal(const ls_std::byte *_data);
-      ls_std::LogLevel getLogLevel();
-      void info(const ls_std::byte *_data);
-      void setLogLevel(const ls_std::LogLevelValue &_logLevelValue);
-      void trace(const ls_std::byte *_data);
-      void warn(const ls_std::byte *_data);
+      void debug(const ls::byte *_data);
+      void error(const ls::byte *_data);
+      void fatal(const ls::byte *_data);
+      ls::LogLevel getLogLevel();
+      void info(const ls::byte *_data);
+      void setLogLevel(const ls::LogLevelValue &_logLevelValue);
+      void trace(const ls::byte *_data);
+      void warn(const ls::byte *_data);
 
     private:
 
-      ls_std::LogLevel logLevel{};
-      std::shared_ptr<ls_std::IWriter> writer{};
+      ls::LogLevel logLevel{};
+      std::shared_ptr<ls::IWriter> writer{};
 
-      void _assignWriter(const std::shared_ptr<ls_std::IWriter> &_writer);
-      void _log(const ls_std::byte *_data, const ls_std::LogLevel &_logLevel);
+      void _assignWriter(const std::shared_ptr<ls::IWriter> &_writer);
+      void _log(const ls::byte *_data, const ls::LogLevel &_logLevel);
   };
 }
 

include/ls_std/io/xml/XmlAttribute.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-23
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -13,9 +13,9 @@
 #include <ls_std/core/Class.hpp>
 #include <string>
 
-namespace ls_std
+namespace ls
 {
-  class XmlAttribute : public ls_std::Class
+  class XmlAttribute : public ls::Class
   {
     public:
 

include/ls_std/io/xml/XmlDeclaration.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -13,9 +13,9 @@
 #include <ls_std/core/Class.hpp>
 #include "XmlAttribute.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class XmlDeclaration : public ls_std::Class
+  class XmlDeclaration : public ls::Class
   {
     public:
 
@@ -32,11 +32,11 @@ namespace ls_std
 
     private:
 
-      ls_std::XmlAttribute encoding{"encoding"};
-      ls_std::XmlAttribute standalone{"standalone"};
-      ls_std::XmlAttribute version{"version"};
+      ls::XmlAttribute encoding{"encoding"};
+      ls::XmlAttribute standalone{"standalone"};
+      ls::XmlAttribute version{"version"};
 
-      static std::string _toXmlAttribute(ls_std::XmlAttribute _attribute);
+      static std::string _toXmlAttribute(ls::XmlAttribute _attribute);
   };
 }
 

include/ls_std/io/xml/XmlDocument.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -15,28 +15,28 @@
 #include "XmlNode.hpp"
 #include "XmlDeclaration.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class XmlDocument : public ls_std::Class
+  class XmlDocument : public ls::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> &_rootElement);
+      std::shared_ptr<ls::XmlDeclaration> getDeclaration();
+      std::shared_ptr<ls::XmlNode> getRootElement();
+      void setDeclaration(const std::shared_ptr<ls::XmlDeclaration> &_declaration);
+      void setRootElement(const std::shared_ptr<ls::XmlNode> &_rootElement);
       std::string toXml();
 
     private:
 
-      std::shared_ptr<ls_std::XmlDeclaration> declaration{};
-      std::shared_ptr<ls_std::XmlNode> rootElement{};
+      std::shared_ptr<ls::XmlDeclaration> declaration{};
+      std::shared_ptr<ls::XmlNode> rootElement{};
 
-      void _assignDeclaration(const std::shared_ptr<ls_std::XmlDeclaration> &_declaration);
-      void _assignRootElement(const std::shared_ptr<ls_std::XmlNode> &_rootElement);
+      void _assignDeclaration(const std::shared_ptr<ls::XmlDeclaration> &_declaration);
+      void _assignRootElement(const std::shared_ptr<ls::XmlNode> &_rootElement);
   };
 }
 

include/ls_std/io/xml/XmlNode.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-24
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -15,32 +15,32 @@
 #include <ls_std/core/Class.hpp>
 #include "XmlAttribute.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class XmlNode : public ls_std::Class
+  class XmlNode : public ls::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);
+      bool addAttributeAfter(const std::shared_ptr<ls::XmlAttribute> &_attribute, const std::string &_name);
+      bool addAttributeBefore(const std::shared_ptr<ls::XmlAttribute> &_attribute, const std::string &_name);
+      bool addAttributeToBeginning(const std::shared_ptr<ls::XmlAttribute> &_attribute);
+      bool addAttributeToEnd(const std::shared_ptr<ls::XmlAttribute> &_attribute);
+      bool addChildAfter(const std::shared_ptr<ls::XmlNode> &_child, const std::shared_ptr<ls::XmlNode> &_search);
+      bool addChildBefore(const std::shared_ptr<ls::XmlNode> &_child, const std::shared_ptr<ls::XmlNode> &_search);
+      bool addChildToBeginning(const std::shared_ptr<ls::XmlNode> &_child);
+      bool addChildToEnd(const std::shared_ptr<ls::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::list<std::shared_ptr<ls::XmlAttribute>> getAttributes();
+      std::list<std::shared_ptr<ls::XmlNode>> getChildren();
+      std::list<std::shared_ptr<ls::XmlNode>> getChildren(const std::string &_name);
       std::string getName();
       std::string getValue();
       bool hasAttribute(const std::string &_name);
       bool hasChild(const std::string &_name);
-      bool hasChild(const std::shared_ptr<ls_std::XmlNode> &_child);
+      bool hasChild(const std::shared_ptr<ls::XmlNode> &_child);
       bool removeFirstAttribute();
       bool removeLastAttribute();
       bool removeFirstChild();
@@ -55,20 +55,20 @@ namespace ls_std
 
     private:
 
-      std::list<std::shared_ptr<ls_std::XmlAttribute>> attributes{};
-      std::list<std::shared_ptr<ls_std::XmlNode>> children{};
+      std::list<std::shared_ptr<ls::XmlAttribute>> attributes{};
+      std::list<std::shared_ptr<ls::XmlNode>> children{};
       std::string name{};
       const static uint8_t TAB_SIZE{4};
       std::string value{};
 
       void _assignName(const std::string &_name);
       void _assignValue(const std::string &_value);
-      static void _checkIfAttributeReferenceIsValid(const std::shared_ptr<ls_std::XmlAttribute> &_attribute);
+      static void _checkIfAttributeReferenceIsValid(const std::shared_ptr<ls::XmlAttribute> &_attribute);
       static void _checkIfNameIsNotEmpty(const std::string &_name);
-      static void _checkIfNodeReferenceIsValid(const std::shared_ptr<ls_std::XmlNode> &_child);
+      static void _checkIfNodeReferenceIsValid(const std::shared_ptr<ls::XmlNode> &_child);
       static std::string _getTab(uint8_t _tabSize);
       bool _hasAttribute(const std::string &_name);
-      bool _hasChild(const std::shared_ptr<ls_std::XmlNode> &_child);
+      bool _hasChild(const std::shared_ptr<ls::XmlNode> &_child);
       bool _hasChild(const std::string &_name);
       std::string _toXmlAttributes();
       std::string _toXmlChildren(uint8_t _tabSize);

include/ls_std/io/xml/XmlParseMode.hpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-13
- * Changed:         2021-05-02
+ * Changed:         2022-05-05
  *
  * */
 
 #ifndef LS_STD_XML_PARSE_MODE_HPP
 #define LS_STD_XML_PARSE_MODE_HPP
 
-namespace ls_std
+namespace ls
 {
   enum XmlParseMode
   {

include/ls_std/io/xml/XmlParseParameter.hpp

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

include/ls_std/io/xml/XmlParser.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-25
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -17,54 +17,54 @@
 #include "XmlParseParameter.hpp"
 #include <list>
 
-namespace ls_std
+namespace ls
 {
-  class XmlParser : public ls_std::Class
+  class XmlParser : public ls::Class
   {
     public:
 
-      explicit XmlParser(const std::shared_ptr<ls_std::XmlDocument> &_document);
+      explicit XmlParser(const std::shared_ptr<ls::XmlDocument> &_document);
       ~XmlParser() override = default;
 
-      std::shared_ptr<ls_std::XmlDocument> getDocument();
-      void parse(const ls_std::byte_field &_data);
-      void setDocument(const std::shared_ptr<ls_std::XmlDocument> &_document);
+      std::shared_ptr<ls::XmlDocument> getDocument();
+      void parse(const ls::byte_field &_data);
+      void setDocument(const std::shared_ptr<ls::XmlDocument> &_document);
 
     protected:
 
-      static std::pair<std::string, std::string> _readAttribute_(const ls_std::byte_field &_data);
-      static std::list<std::pair<std::string, std::string>> _readAttributes_(ls_std::byte_field _data);
+      static std::pair<std::string, std::string> _readAttribute_(const ls::byte_field &_data);
+      static std::list<std::pair<std::string, std::string>> _readAttributes_(ls::byte_field _data);
 
     private:
 
       uint8_t currentLevel{};
-      std::shared_ptr<ls_std::XmlDocument> document{};
+      std::shared_ptr<ls::XmlDocument> document{};
       uint8_t maxLevel{};
-      ls_std::XmlParseMode mode{};
-      std::list<ls_std::XmlParseParameter> parseParameters{};
+      ls::XmlParseMode mode{};
+      std::list<ls::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 _analyze(const ls::byte_field &_data, std::string::size_type _index);
+      void _assignDocument(const std::shared_ptr<ls::XmlDocument> &_document);
+      static std::shared_ptr<ls::XmlDeclaration> _createDeclaration(const std::list<std::pair<std::string, std::string>> &_attributes);
+      static std::shared_ptr<ls::XmlNode> _createNode(const std::list<std::pair<std::string, std::string>> &_attributes, const std::string &_name);
       static std::pair<std::string, std::string> _findAttribute(const std::list<std::pair<std::string, std::string>> &_attributes, const std::string &_name);
-      static size_t _findAttributeEndPosition(const ls_std::byte_field &_data);
-      static ls_std::byte_field _getNextTagString(const ls_std::byte_field &_data, std::string::size_type _index);
-      void _isClosingTag(const ls_std::byte_field &_data, std::string::size_type _index);
-      void _isDeclaration(const ls_std::byte_field &_data, std::string::size_type _index);
-      void _isOpeningTag(const ls_std::byte_field &_data, std::string::size_type _index);
-      void _isValue(const ls_std::byte_field &_data, std::string::size_type _index);
+      static size_t _findAttributeEndPosition(const ls::byte_field &_data);
+      static ls::byte_field _getNextTagString(const ls::byte_field &_data, std::string::size_type _index);
+      void _isClosingTag(const ls::byte_field &_data, std::string::size_type _index);
+      void _isDeclaration(const ls::byte_field &_data, std::string::size_type _index);
+      void _isOpeningTag(const ls::byte_field &_data, std::string::size_type _index);
+      void _isValue(const ls::byte_field &_data, std::string::size_type _index);
       void _mergeNodes();
-      void _mergeChildrenToParentNode(const std::shared_ptr<ls_std::XmlNode> &_parent, std::list<ls_std::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel);
+      void _mergeChildrenToParentNode(const std::shared_ptr<ls::XmlNode> &_parent, std::list<ls::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel);
       void _mergeNodesOnCurrentLevel();
-      void _parse(const ls_std::byte_field &_data);
-      static std::pair<std::string, std::string> _parseAttribute(const ls_std::byte_field &_data);
-      static std::list<std::pair<std::string, std::string>> _parseAttributes(ls_std::byte_field _data);
-      size_t _parseClosingTag(const ls_std::byte_field &_data, std::string::size_type _index);
-      size_t _parseDeclaration(const ls_std::byte_field &_data, std::string::size_type _index);
-      size_t _parseOpeningTag(const ls_std::byte_field &_data, std::string::size_type _index);
-      static ls_std::byte_field _parseTagName(const ls_std::byte_field &_data);
-      size_t _parseValue(const ls_std::byte_field &_data, std::string::size_type _index);
+      void _parse(const ls::byte_field &_data);
+      static std::pair<std::string, std::string> _parseAttribute(const ls::byte_field &_data);
+      static std::list<std::pair<std::string, std::string>> _parseAttributes(ls::byte_field _data);
+      size_t _parseClosingTag(const ls::byte_field &_data, std::string::size_type _index);
+      size_t _parseDeclaration(const ls::byte_field &_data, std::string::size_type _index);
+      size_t _parseOpeningTag(const ls::byte_field &_data, std::string::size_type _index);
+      static ls::byte_field _parseTagName(const ls::byte_field &_data);
+      size_t _parseValue(const ls::byte_field &_data, std::string::size_type _index);
       void _reset();
       void _setMaxLevel();
   };

include/ls_std/io/xml/XmlReader.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-08
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -18,32 +18,32 @@
 #include "XmlParseParameter.hpp"
 #include <list>
 
-namespace ls_std
+namespace ls
 {
-  class XmlReader : public ls_std::Class, public ls_std::IReader
+  class XmlReader : public ls::Class, public ls::IReader
   {
     public:
 
-      explicit XmlReader(const std::shared_ptr<ls_std::XmlDocument> &_document, const std::string &_absolutePath);
+      explicit XmlReader(const std::shared_ptr<ls::XmlDocument> &_document, const std::string &_absolutePath);
       ~XmlReader() override = default;
 
       // implementation
 
-      ls_std::byte_field read() override;
+      ls::byte_field read() override;
 
       // additional functionality
 
-      std::shared_ptr<ls_std::XmlDocument> getDocument();
-      void setDocument(const std::shared_ptr<ls_std::XmlDocument> &_document);
-      void setFile(const ls_std::File &_xmlFile);
+      std::shared_ptr<ls::XmlDocument> getDocument();
+      void setDocument(const std::shared_ptr<ls::XmlDocument> &_document);
+      void setFile(const ls::File &_xmlFile);
 
     private:
 
-      std::shared_ptr<ls_std::XmlDocument> document{};
-      ls_std::File xmlFile;
+      std::shared_ptr<ls::XmlDocument> document{};
+      ls::File xmlFile;
 
-      void _assignDocument(const std::shared_ptr<ls_std::XmlDocument> &_document);
-      void _assignFile(ls_std::File _xmlFile);
+      void _assignDocument(const std::shared_ptr<ls::XmlDocument> &_document);
+      void _assignFile(ls::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:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <ls_std/core/Class.hpp>
 
-namespace ls_std
+namespace ls
 {
   class IListener
   {
@@ -21,7 +21,7 @@ namespace ls_std
       IListener() = default;
       ~IListener() = default;
 
-      virtual void listen(const ls_std::Class &_info) = 0;
+      virtual void listen(const ls::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:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -15,24 +15,24 @@
 #include <list>
 #include <memory>
 
-namespace ls_std
+namespace ls
 {
-  class Narrator : public ls_std::Class
+  class Narrator : public ls::Class
   {
     public:
 
       Narrator();
       ~Narrator() override = default;
 
-      bool addListener(const std::shared_ptr<ls_std::IListener> &_listener);
+      bool addListener(const std::shared_ptr<ls::IListener> &_listener);
       void clear();
-      std::list<std::shared_ptr<ls_std::IListener>> getListeners();
-      bool removeListener(const std::shared_ptr<ls_std::IListener> &_listener);
-      void tell(const ls_std::Class &_info);
+      std::list<std::shared_ptr<ls::IListener>> getListeners();
+      bool removeListener(const std::shared_ptr<ls::IListener> &_listener);
+      void tell(const ls::Class &_info);
 
     private:
 
-      std::list<std::shared_ptr<ls_std::IListener>> listeners{};
+      std::list<std::shared_ptr<ls::IListener>> listeners{};
   };
 }
 

include/ls_std/logic/State.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-05
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -17,33 +17,33 @@
 #include "StateConnection.hpp"
 #include <ls_std/serialization/ISerializable.hpp>
 
-namespace ls_std
+namespace ls
 {
-  class State : public ls_std::Class
+  class State : public ls::Class
   {
     public:
 
-      explicit State(const ls_std::StateId& _id);
+      explicit State(const ls::StateId& _id);
       ~State() override = default;
 
       // additional functionality
 
-      bool addStateConnection(const ls_std::StateConnectionId &_connectionId, const std::shared_ptr<ls_std::State> &_connectedState);
-      bool addStateConnection(const std::shared_ptr<ls_std::StateConnection> &_connection);
+      bool addStateConnection(const ls::StateConnectionId &_connectionId, const std::shared_ptr<ls::State> &_connectedState);
+      bool addStateConnection(const std::shared_ptr<ls::StateConnection> &_connection);
       void clearConnections();
-      std::unordered_map<ls_std::StateConnectionId, std::shared_ptr<ls_std::StateConnection>> getConnectedStates();
-      ls_std::StateId getId();
-      bool hasConnection(const ls_std::StateConnectionId &_connectionId);
-      void setId(const ls_std::StateId& _id);
+      std::unordered_map<ls::StateConnectionId, std::shared_ptr<ls::StateConnection>> getConnectedStates();
+      ls::StateId getId();
+      bool hasConnection(const ls::StateConnectionId &_connectionId);
+      void setId(const ls::StateId& _id);
 
     private:
 
-      std::unordered_map<ls_std::StateConnectionId, std::shared_ptr<ls_std::StateConnection>> connectedStates{};
-      ls_std::StateId id{};
+      std::unordered_map<ls::StateConnectionId, std::shared_ptr<ls::StateConnection>> connectedStates{};
+      ls::StateId id{};
 
-      void _assignStateId(const ls_std::StateId& _id);
+      void _assignStateId(const ls::StateId& _id);
       void _clearConnections();
-      bool _hasConnection(const ls_std::StateConnectionId &_connectionId);
+      bool _hasConnection(const ls::StateConnectionId &_connectionId);
   };
 }
 

include/ls_std/logic/StateConnection.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-10
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -14,30 +14,30 @@
 #include <ls_std/core/Class.hpp>
 #include "StateMachineTypes.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class StateConnection : public ls_std::Class
+  class StateConnection : public ls::Class
   {
     public:
 
-      explicit StateConnection(const ls_std::StateConnectionId& _connectionId, const ls_std::StateId& _stateId);
+      explicit StateConnection(const ls::StateConnectionId& _connectionId, const ls::StateId& _stateId);
       ~StateConnection() override = default;
 
       StateConnectionId getConnectionId();
-      ls_std::StateId getStateId();
+      ls::StateId getStateId();
       bool isPassable() const;
-      void setConnectionId(const ls_std::StateConnectionId& _connectionId);
-      void setStateId(const ls_std::StateId& _stateId);
+      void setConnectionId(const ls::StateConnectionId& _connectionId);
+      void setStateId(const ls::StateId& _stateId);
       void updatePassCondition(bool _condition);
 
     private:
 
       bool condition{};
-      ls_std::StateConnectionId connectionId{};
-      ls_std::StateId stateId{};
+      ls::StateConnectionId connectionId{};
+      ls::StateId stateId{};
 
-      void _assignConnectionId(const ls_std::StateConnectionId& _connectionId);
-      void _assignStateId(const ls_std::StateId& _stateId);
+      void _assignConnectionId(const ls::StateConnectionId& _connectionId);
+      void _assignStateId(const ls::StateId& _stateId);
   };
 }
 

include/ls_std/logic/StateMachine.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-05
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -18,38 +18,38 @@
 #include "State.hpp"
 #include "StateMachineTypes.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class StateMachine : public ls_std::Class
+  class StateMachine : public ls::Class
   {
     public:
 
       explicit StateMachine(const std::string& _name);
       ~StateMachine() override = default;
 
-      bool addState(const std::shared_ptr<ls_std::State> &_state);
-      std::shared_ptr<ls_std::State> getCurrentState();
-      std::vector<ls_std::StateId> getMemory();
+      bool addState(const std::shared_ptr<ls::State> &_state);
+      std::shared_ptr<ls::State> getCurrentState();
+      std::vector<ls::StateId> getMemory();
       std::string getName();
-      std::unordered_map<StateId, std::shared_ptr<ls_std::State>> getStates();
-      bool hasState(const ls_std::StateId &_id);
+      std::unordered_map<StateId, std::shared_ptr<ls::State>> getStates();
+      bool hasState(const ls::StateId &_id);
       bool proceed();
-      void setMemory(const std::vector<ls_std::StateId>& _memory);
+      void setMemory(const std::vector<ls::StateId>& _memory);
       void setName(const std::string& _name);
-      bool setStartState(const ls_std::StateId &_id);
+      bool setStartState(const ls::StateId &_id);
 
     private:
 
       std::shared_ptr<State> currentState{};
-      std::vector<ls_std::StateId> memory{};
+      std::vector<ls::StateId> memory{};
       std::string name{};
-      std::unordered_map<ls_std::StateId, std::shared_ptr<ls_std::State>> states{};
+      std::unordered_map<ls::StateId, std::shared_ptr<ls::State>> states{};
 
-      void _assignMemory(const std::vector<ls_std::StateId>& _memory);
+      void _assignMemory(const std::vector<ls::StateId>& _memory);
       void _assignName(const std::string& _name);
-      std::vector<ls_std::StateId> _getNextValidStates();
-      void _remember(const ls_std::StateId &_id);
-      bool _hasState(const ls_std::StateId &_id);
+      std::vector<ls::StateId> _getNextValidStates();
+      void _remember(const ls::StateId &_id);
+      bool _hasState(const ls::StateId &_id);
   };
 }
 

include/ls_std/logic/StateMachineTypes.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-10
- * Changed:         2021-04-23
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <string>
 
-namespace ls_std
+namespace ls
 {
   using StateConnectionId = std::string;
   using StateId = std::string;

include/ls_std/logic/serialization/SerializableJsonState.hpp

@@ -16,31 +16,31 @@
 #include "ls_std/serialization/ISerializable.hpp"
 #include "ls_std/core/Class.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class SerializableJsonState : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonState : public ls::Class, public ls::ISerializable
   {
     public:
 
-      explicit SerializableJsonState(const std::shared_ptr<ls_std::State> &_value);
+      explicit SerializableJsonState(const std::shared_ptr<ls::State> &_value);
       ~SerializableJsonState() override = default;
 
       // implementation
 
-      ls_std::byte_field marshal() override;
-      void unmarshal(const ls_std::byte_field &_data) override;
+      ls::byte_field marshal() override;
+      void unmarshal(const ls::byte_field &_data) override;
 
       // additional functionality
 
-      std::shared_ptr<ls_std::State> getValue();
-      void setValue(const std::shared_ptr<ls_std::State> &_value);
+      std::shared_ptr<ls::State> getValue();
+      void setValue(const std::shared_ptr<ls::State> &_value);
 
     private:
 
       nlohmann::json jsonObject{};
-      std::shared_ptr<ls_std::State> value{};
+      std::shared_ptr<ls::State> value{};
 
-      void _assignValue(const std::shared_ptr<ls_std::State> &_value);
+      void _assignValue(const std::shared_ptr<ls::State> &_value);
       void _clear();
       void _unmarshalStateConnections();
       void _update();

include/ls_std/logic/serialization/SerializableJsonStateConnection.hpp

@@ -16,31 +16,31 @@
 #include "ls_std/serialization/ISerializable.hpp"
 #include "ls_std/logic/StateConnection.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class SerializableJsonStateConnection : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonStateConnection : public ls::Class, public ls::ISerializable
   {
     public:
 
-      explicit SerializableJsonStateConnection(const std::shared_ptr<ls_std::StateConnection> &_value);
+      explicit SerializableJsonStateConnection(const std::shared_ptr<ls::StateConnection> &_value);
       ~SerializableJsonStateConnection() override = default;
 
       // implementation
 
-      ls_std::byte_field marshal() override;
-      void unmarshal(const ls_std::byte_field &_data) override;
+      ls::byte_field marshal() override;
+      void unmarshal(const ls::byte_field &_data) override;
 
       // additional functionality
 
-      std::shared_ptr<ls_std::StateConnection> getValue();
-      void setValue(const std::shared_ptr<ls_std::StateConnection> &_value);
+      std::shared_ptr<ls::StateConnection> getValue();
+      void setValue(const std::shared_ptr<ls::StateConnection> &_value);
 
     private:
 
       nlohmann::json jsonObject{};
-      std::shared_ptr<ls_std::StateConnection> value{};
+      std::shared_ptr<ls::StateConnection> value{};
 
-      void _assignValue(const std::shared_ptr<ls_std::StateConnection> &_value);
+      void _assignValue(const std::shared_ptr<ls::StateConnection> &_value);
       void _clear();
       void _update();
   };

include/ls_std/logic/serialization/SerializableJsonStateMachine.hpp

@@ -16,31 +16,31 @@
 #include <memory>
 #include "ls_std/lib/nlohmann_json/include/nlohmann/json.hpp"
 
-namespace ls_std
+namespace ls
 {
-  class SerializableJsonStateMachine : public ls_std::Class, public ls_std::ISerializable
+  class SerializableJsonStateMachine : public ls::Class, public ls::ISerializable
   {
     public:
 
-      explicit SerializableJsonStateMachine(const std::shared_ptr<ls_std::StateMachine> &_value);
+      explicit SerializableJsonStateMachine(const std::shared_ptr<ls::StateMachine> &_value);
       ~SerializableJsonStateMachine() override = default;
 
       // implementation
 
-      ls_std::byte_field marshal() override;
-      void unmarshal(const ls_std::byte_field &_data) override;
+      ls::byte_field marshal() override;
+      void unmarshal(const ls::byte_field &_data) override;
 
       // additional functionality
 
-      std::shared_ptr<ls_std::StateMachine> getValue();
-      void setValue(const std::shared_ptr<ls_std::StateMachine> &_value);
+      std::shared_ptr<ls::StateMachine> getValue();
+      void setValue(const std::shared_ptr<ls::StateMachine> &_value);
 
     private:
 
       nlohmann::json jsonObject{};
-      std::shared_ptr<ls_std::StateMachine> value{};
+      std::shared_ptr<ls::StateMachine> value{};
 
-      void _assignValue(const std::shared_ptr<ls_std::StateMachine> &_value);
+      void _assignValue(const std::shared_ptr<ls::StateMachine> &_value);
       void _unmarshalCurrentState();
       void _unmarshalStates();
       void _update();

include/ls_std/serialization/ISerializable.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-21
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -12,7 +12,7 @@
 
 #include <ls_std/core/Types.hpp>
 
-namespace ls_std
+namespace ls
 {
   class ISerializable
   {
@@ -21,8 +21,8 @@ namespace ls_std
       ISerializable() = default;
       ~ISerializable() = default;
 
-      virtual ls_std::byte_field marshal() = 0;
-      virtual void unmarshal(const ls_std::byte_field &_data) = 0;
+      virtual ls::byte_field marshal() = 0;
+      virtual void unmarshal(const ls::byte_field &_data) = 0;
   };
 }
 

include/ls_std/time/Date.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
@@ -13,9 +13,9 @@
 #include <ls_std/core/Class.hpp>
 #include <ctime>
 
-namespace ls_std
+namespace ls
 {
-  class Date : public ls_std::Class
+  class Date : public ls::Class
   {
     public:
 
@@ -24,15 +24,15 @@ namespace ls_std
 
       // arithmetic operators
 
-      ls_std::Date &operator+(int _value);
-      ls_std::Date &operator-(int _value);
-      ls_std::Date &operator+=(int _value);
-      ls_std::Date &operator-=(int _value);
+      ls::Date &operator+(int _value);
+      ls::Date &operator-(int _value);
+      ls::Date &operator+=(int _value);
+      ls::Date &operator-=(int _value);
 
       // additional functionality
 
-      bool after(const ls_std::Date &_foreignDate) const;
-      bool before(const ls_std::Date &_foreignDate) const;
+      bool after(const ls::Date &_foreignDate) const;
+      bool before(const ls::Date &_foreignDate) const;
       int getDay();
       int getHour();
       int getMinute();

source/ls_std/boxing/Boolean.cpp

@@ -11,68 +11,68 @@
 #include <ls_std/boxing/Boolean.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::Boolean::Boolean() : ls_std::Class("Boolean")
+ls::Boolean::Boolean() : ls::Class("Boolean")
 {}
 
-ls_std::Boolean::Boolean(bool _value)
-    : ls_std::Class("Boolean"),
+ls::Boolean::Boolean(bool _value)
+    : ls::Class("Boolean"),
       value(_value)
 {}
 
-ls_std::Boolean::operator bool() const
+ls::Boolean::operator bool() const
 {
   return this->value;
 }
 
-ls_std::Boolean &ls_std::Boolean::operator=(int _value)
+ls::Boolean &ls::Boolean::operator=(int _value)
 {
   this->value = _value;
   return *this;
 }
 
-ls_std::Boolean &ls_std::Boolean::operator=(bool _value)
+ls::Boolean &ls::Boolean::operator=(bool _value)
 {
   this->value = _value;
   return *this;
 }
 
-bool ls_std::Boolean::operator&&(const ls_std::Boolean &_boolean) const
+bool ls::Boolean::operator&&(const ls::Boolean &_boolean) const
 {
   return this->value && _boolean;
 }
 
-bool ls_std::Boolean::operator&&(bool _value) const
+bool ls::Boolean::operator&&(bool _value) const
 {
   return this->value && _value;
 }
 
-bool ls_std::Boolean::operator&&(int _value) const
+bool ls::Boolean::operator&&(int _value) const
 {
   return this->value && _value;
 }
 
-bool ls_std::Boolean::operator||(const ls_std::Boolean &_boolean) const
+bool ls::Boolean::operator||(const ls::Boolean &_boolean) const
 {
   return this->value || _boolean;
 }
 
-bool ls_std::Boolean::operator||(bool _value) const
+bool ls::Boolean::operator||(bool _value) const
 {
   return this->value || _value;
 }
 
-bool ls_std::Boolean::operator||(int _value) const
+bool ls::Boolean::operator||(int _value) const
 {
   return this->value || _value;
 }
 
-void ls_std::Boolean::parse(std::string _parseText)
+void ls::Boolean::parse(std::string _parseText)
 {
   std::transform(_parseText.begin(), _parseText.end(), _parseText.begin(), ::tolower);
 
   if (_parseText != this->TRUE_STRING && _parseText != this->FALSE_STRING)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
   else
   {
@@ -88,37 +88,37 @@ void ls_std::Boolean::parse(std::string _parseText)
   }
 }
 
-std::string ls_std::Boolean::toString()
+std::string ls::Boolean::toString()
 {
   return this->_toString();
 }
 
-bool ls_std::Boolean::getValue() const
+bool ls::Boolean::getValue() const
 {
   return this->value;
 }
 
-bool ls_std::Boolean::XOR(const ls_std::Boolean &_leftExpression, const ls_std::Boolean &_rightExpression)
+bool ls::Boolean::XOR(const ls::Boolean &_leftExpression, const ls::Boolean &_rightExpression)
 {
   return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression);
 }
 
-bool ls_std::Boolean::XOR(const ls_std::Boolean &_leftExpression, bool _rightExpression)
+bool ls::Boolean::XOR(const ls::Boolean &_leftExpression, bool _rightExpression)
 {
   return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression);
 }
 
-bool ls_std::Boolean::XOR(bool _leftExpression, const ls_std::Boolean &_rightExpression)
+bool ls::Boolean::XOR(bool _leftExpression, const ls::Boolean &_rightExpression)
 {
   return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression);
 }
 
-bool ls_std::Boolean::XOR(bool _leftExpression, bool _rightExpression)
+bool ls::Boolean::XOR(bool _leftExpression, bool _rightExpression)
 {
   return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression);
 }
 
-std::string ls_std::Boolean::_toString() const
+std::string ls::Boolean::_toString() const
 {
   std::string booleanString{};
 

source/ls_std/boxing/Double.cpp

@@ -11,222 +11,222 @@
 #include <ls_std/boxing/Double.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::Double::Double() : ls_std::Class("Double")
+ls::Double::Double() : ls::Class("Double")
 {
   this->_assignEpsilon(0.00000001);
 }
 
-ls_std::Double::Double(double _value)
-    : ls_std::Class("Double"),
+ls::Double::Double(double _value)
+    : ls::Class("Double"),
       value(_value)
 {
   this->_assignEpsilon(0.00000001);
 }
 
-ls_std::Double::operator double() const
+ls::Double::operator double() const
 {
   return this->value;
 }
 
-ls_std::Double &ls_std::Double::operator=(double _value)
+ls::Double &ls::Double::operator=(double _value)
 {
   this->value = _value;
   return *this;
 }
 
-double ls_std::Double::operator-() const
+double ls::Double::operator-() const
 {
   return -this->value;
 }
 
-double ls_std::Double::operator+(const ls_std::Double &_double) const
+double ls::Double::operator+(const ls::Double &_double) const
 {
   return this->value + _double;
 }
 
-double ls_std::Double::operator+(double _value) const
+double ls::Double::operator+(double _value) const
 {
   return this->value + _value;
 }
 
-double ls_std::Double::operator*(const ls_std::Double &_double) const
+double ls::Double::operator*(const ls::Double &_double) const
 {
   return this->value * _double;
 }
 
-double ls_std::Double::operator*(double _value) const
+double ls::Double::operator*(double _value) const
 {
   return this->value * _value;
 }
 
-double ls_std::Double::operator-(const ls_std::Double &_double) const
+double ls::Double::operator-(const ls::Double &_double) const
 {
   return this->value - _double;
 }
 
-double ls_std::Double::operator-(double _value) const
+double ls::Double::operator-(double _value) const
 {
   return this->value - _value;
 }
 
-double ls_std::Double::operator/(const ls_std::Double &_double) const
+double ls::Double::operator/(const ls::Double &_double) const
 {
   return this->value / _double;
 }
 
-double ls_std::Double::operator/(double _value) const
+double ls::Double::operator/(double _value) const
 {
   return this->value / _value;
 }
 
-ls_std::Double &ls_std::Double::operator+=(const ls_std::Double &_double)
+ls::Double &ls::Double::operator+=(const ls::Double &_double)
 {
   this->value += _double;
   return *this;
 }
 
-ls_std::Double &ls_std::Double::operator+=(double _value)
+ls::Double &ls::Double::operator+=(double _value)
 {
   this->value += _value;
   return *this;
 }
 
-ls_std::Double &ls_std::Double::operator-=(const ls_std::Double &_double)
+ls::Double &ls::Double::operator-=(const ls::Double &_double)
 {
   this->value -= _double;
   return *this;
 }
 
-ls_std::Double &ls_std::Double::operator-=(double _value)
+ls::Double &ls::Double::operator-=(double _value)
 {
   this->value -= _value;
   return *this;
 }
 
-ls_std::Double &ls_std::Double::operator*=(const ls_std::Double &_double)
+ls::Double &ls::Double::operator*=(const ls::Double &_double)
 {
   this->value *= _double;
   return *this;
 }
 
-ls_std::Double &ls_std::Double::operator*=(double _value)
+ls::Double &ls::Double::operator*=(double _value)
 {
   this->value *= _value;
   return *this;
 }
 
-ls_std::Double &ls_std::Double::operator/=(const ls_std::Double &_double)
+ls::Double &ls::Double::operator/=(const ls::Double &_double)
 {
   this->value /= _double;
   return *this;
 }
 
-ls_std::Double &ls_std::Double::operator/=(double _value)
+ls::Double &ls::Double::operator/=(double _value)
 {
   this->value /= _value;
   return *this;
 }
 
-bool ls_std::Double::operator==(const ls_std::Double &_double) const
+bool ls::Double::operator==(const ls::Double &_double) const
 {
   return std::fabs(this->value - _double) < this->epsilon;
 }
 
-bool ls_std::Double::operator==(double _value) const
+bool ls::Double::operator==(double _value) const
 {
   return std::fabs(this->value - _value) < this->epsilon;
 }
 
-bool ls_std::Double::operator!=(const ls_std::Double &_double) const
+bool ls::Double::operator!=(const ls::Double &_double) const
 {
   return std::fabs(this->value - _double) >= this->epsilon;
 }
 
-bool ls_std::Double::operator!=(double _value) const
+bool ls::Double::operator!=(double _value) const
 {
   return std::fabs(this->value - _value) >= this->epsilon;
 }
 
-bool ls_std::Double::operator>(const ls_std::Double &_double) const
+bool ls::Double::operator>(const ls::Double &_double) const
 {
   return this->value > _double;
 }
 
-bool ls_std::Double::operator>(double _value) const
+bool ls::Double::operator>(double _value) const
 {
   return this->value > _value;
 }
 
-bool ls_std::Double::operator>=(const ls_std::Double &_double) const
+bool ls::Double::operator>=(const ls::Double &_double) const
 {
   return this->value >= _double;
 }
 
-bool ls_std::Double::operator>=(double _value) const
+bool ls::Double::operator>=(double _value) const
 {
   return this->value >= _value;
 }
 
-bool ls_std::Double::operator<(const ls_std::Double &_double) const
+bool ls::Double::operator<(const ls::Double &_double) const
 {
   return this->value < _double;
 }
 
-bool ls_std::Double::operator<(double _value) const
+bool ls::Double::operator<(double _value) const
 {
   return this->value < _value;
 }
 
-bool ls_std::Double::operator<=(const ls_std::Double &_double) const
+bool ls::Double::operator<=(const ls::Double &_double) const
 {
   return this->value <= _double;
 }
 
-bool ls_std::Double::operator<=(double _value) const
+bool ls::Double::operator<=(double _value) const
 {
   return this->value <= _value;
 }
 
-void ls_std::Double::operator++()
+void ls::Double::operator++()
 {
   this->value += 1.0f;
 }
 
-void ls_std::Double::operator--()
+void ls::Double::operator--()
 {
   this->value -= 1.0f;
 }
 
-void ls_std::Double::parse(std::string _parseText)
+void ls::Double::parse(std::string _parseText)
 {
   this->value = std::stod(_parseText);
 }
 
-std::string ls_std::Double::toString()
+std::string ls::Double::toString()
 {
   return std::to_string(this->value);
 }
 
-double ls_std::Double::getEpsilon()
+double ls::Double::getEpsilon()
 {
   return this->epsilon;
 }
 
-double ls_std::Double::getValue()
+double ls::Double::getValue()
 {
   return this->value;
 }
 
-void ls_std::Double::setEpsilon(double _epsilon)
+void ls::Double::setEpsilon(double _epsilon)
 {
   this->_assignEpsilon(_epsilon);
 }
 
-void ls_std::Double::_assignEpsilon(double _epsilon)
+void ls::Double::_assignEpsilon(double _epsilon)
 {
   if (_epsilon <= 0.0)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->epsilon = _epsilon;

source/ls_std/boxing/Float.cpp

@@ -11,221 +11,221 @@
 #include <ls_std/boxing/Float.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::Float::Float()
-    : ls_std::Class("Float"),
+ls::Float::Float()
+    : ls::Class("Float"),
       epsilon(0.00001f)
 {}
 
-ls_std::Float::Float(float _value)
-    : ls_std::Class("Float"),
+ls::Float::Float(float _value)
+    : ls::Class("Float"),
       epsilon(0.00001f),
       value(_value)
 {}
 
-ls_std::Float::operator float() const
+ls::Float::operator float() const
 {
   return this->value;
 }
 
-ls_std::Float &ls_std::Float::operator=(float _value)
+ls::Float &ls::Float::operator=(float _value)
 {
   this->value = _value;
   return *this;
 }
 
-float ls_std::Float::operator-() const
+float ls::Float::operator-() const
 {
   return -this->value;
 }
 
-float ls_std::Float::operator+(const ls_std::Float &_float) const
+float ls::Float::operator+(const ls::Float &_float) const
 {
   return this->value + _float;
 }
 
-float ls_std::Float::operator+(float _value) const
+float ls::Float::operator+(float _value) const
 {
   return this->value + _value;
 }
 
-float ls_std::Float::operator*(const ls_std::Float &_float) const
+float ls::Float::operator*(const ls::Float &_float) const
 {
   return this->value * _float;
 }
 
-float ls_std::Float::operator*(float _value) const
+float ls::Float::operator*(float _value) const
 {
   return this->value * _value;
 }
 
-float ls_std::Float::operator-(const ls_std::Float &_float) const
+float ls::Float::operator-(const ls::Float &_float) const
 {
   return this->value - _float;
 }
 
-float ls_std::Float::operator-(float _value) const
+float ls::Float::operator-(float _value) const
 {
   return this->value - _value;
 }
 
-float ls_std::Float::operator/(const ls_std::Float &_float) const
+float ls::Float::operator/(const ls::Float &_float) const
 {
   return this->value / _float;
 }
 
-float ls_std::Float::operator/(float _value) const
+float ls::Float::operator/(float _value) const
 {
   return this->value / _value;
 }
 
-ls_std::Float &ls_std::Float::operator+=(const ls_std::Float &_float)
+ls::Float &ls::Float::operator+=(const ls::Float &_float)
 {
   this->value += _float;
   return *this;
 }
 
-ls_std::Float &ls_std::Float::operator+=(float _value)
+ls::Float &ls::Float::operator+=(float _value)
 {
   this->value += _value;
   return *this;
 }
 
-ls_std::Float &ls_std::Float::operator-=(const ls_std::Float &_float)
+ls::Float &ls::Float::operator-=(const ls::Float &_float)
 {
   this->value -= _float;
   return *this;
 }
 
-ls_std::Float &ls_std::Float::operator-=(float _value)
+ls::Float &ls::Float::operator-=(float _value)
 {
   this->value -= _value;
   return *this;
 }
 
-ls_std::Float &ls_std::Float::operator*=(const ls_std::Float &_float)
+ls::Float &ls::Float::operator*=(const ls::Float &_float)
 {
   this->value *= _float;
   return *this;
 }
 
-ls_std::Float &ls_std::Float::operator*=(float _value)
+ls::Float &ls::Float::operator*=(float _value)
 {
   this->value *= _value;
   return *this;
 }
 
-ls_std::Float &ls_std::Float::operator/=(const ls_std::Float &_float)
+ls::Float &ls::Float::operator/=(const ls::Float &_float)
 {
   this->value /= _float;
   return *this;
 }
 
-ls_std::Float &ls_std::Float::operator/=(float _value)
+ls::Float &ls::Float::operator/=(float _value)
 {
   this->value /= _value;
   return *this;
 }
 
-bool ls_std::Float::operator==(const ls_std::Float &_float) const
+bool ls::Float::operator==(const ls::Float &_float) const
 {
   return std::fabs(this->value - _float) < this->epsilon;
 }
 
-bool ls_std::Float::operator==(float _value) const
+bool ls::Float::operator==(float _value) const
 {
   return std::fabs(this->value - _value) < this->epsilon;
 }
 
-bool ls_std::Float::operator!=(const ls_std::Float &_float) const
+bool ls::Float::operator!=(const ls::Float &_float) const
 {
   return std::fabs(this->value - _float) >= this->epsilon;
 }
 
-bool ls_std::Float::operator!=(float _value) const
+bool ls::Float::operator!=(float _value) const
 {
   return std::fabs(this->value - _value) >= this->epsilon;
 }
 
-bool ls_std::Float::operator>(const ls_std::Float &_float) const
+bool ls::Float::operator>(const ls::Float &_float) const
 {
   return this->value > _float;
 }
 
-bool ls_std::Float::operator>(float _value) const
+bool ls::Float::operator>(float _value) const
 {
   return this->value > _value;
 }
 
-bool ls_std::Float::operator>=(const ls_std::Float &_float) const
+bool ls::Float::operator>=(const ls::Float &_float) const
 {
   return this->value >= _float;
 }
 
-bool ls_std::Float::operator>=(float _value) const
+bool ls::Float::operator>=(float _value) const
 {
   return this->value >= _value;
 }
 
-bool ls_std::Float::operator<(const ls_std::Float &_float) const
+bool ls::Float::operator<(const ls::Float &_float) const
 {
   return this->value < _float;
 }
 
-bool ls_std::Float::operator<(float _value) const
+bool ls::Float::operator<(float _value) const
 {
   return this->value < _value;
 }
 
-bool ls_std::Float::operator<=(const ls_std::Float &_float) const
+bool ls::Float::operator<=(const ls::Float &_float) const
 {
   return this->value <= _float;
 }
 
-bool ls_std::Float::operator<=(float _value) const
+bool ls::Float::operator<=(float _value) const
 {
   return this->value <= _value;
 }
 
-void ls_std::Float::operator++()
+void ls::Float::operator++()
 {
   this->value += 1.0f;
 }
 
-void ls_std::Float::operator--()
+void ls::Float::operator--()
 {
   this->value -= 1.0f;
 }
 
-void ls_std::Float::parse(std::string _parseText)
+void ls::Float::parse(std::string _parseText)
 {
   this->value = std::stof(_parseText);
 }
 
-std::string ls_std::Float::toString()
+std::string ls::Float::toString()
 {
   return std::to_string(this->value);
 }
 
-float ls_std::Float::getEpsilon()
+float ls::Float::getEpsilon()
 {
   return this->epsilon;
 }
 
-float ls_std::Float::getValue()
+float ls::Float::getValue()
 {
   return this->value;
 }
 
-void ls_std::Float::setEpsilon(float _epsilon)
+void ls::Float::setEpsilon(float _epsilon)
 {
   this->_assignEpsilon(_epsilon);
 }
 
-void ls_std::Float::_assignEpsilon(float _epsilon)
+void ls::Float::_assignEpsilon(float _epsilon)
 {
   if (_epsilon <= 0.0)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->epsilon = _epsilon;

source/ls_std/boxing/Integer.cpp

@@ -10,259 +10,259 @@
 #include <ls_std/boxing/Integer.hpp>
 #include <ls_std/core/exception/IllegalArithmeticOperationException.hpp>
 
-ls_std::Integer::Integer(int _value)
-    : ls_std::Class("Integer"),
+ls::Integer::Integer(int _value)
+    : ls::Class("Integer"),
       value(_value)
 {}
 
-ls_std::Integer::Integer() : ls_std::Class("Integer")
+ls::Integer::Integer() : ls::Class("Integer")
 {}
 
-ls_std::Integer::operator int() const
+ls::Integer::operator int() const
 {
   return this->value;
 }
 
-ls_std::Integer &ls_std::Integer::operator=(int _value)
+ls::Integer &ls::Integer::operator=(int _value)
 {
   this->value = _value;
   return *this;
 }
 
-int ls_std::Integer::operator-() const
+int ls::Integer::operator-() const
 {
   return -this->value;
 }
 
-int ls_std::Integer::operator+(const ls_std::Integer &_integer) const
+int ls::Integer::operator+(const ls::Integer &_integer) const
 {
   return this->value + _integer;
 }
 
-int ls_std::Integer::operator+(int _value) const
+int ls::Integer::operator+(int _value) const
 {
   return this->value + _value;
 }
 
-int ls_std::Integer::operator*(const ls_std::Integer &_integer) const
+int ls::Integer::operator*(const ls::Integer &_integer) const
 {
   return this->value * _integer;
 }
 
-int ls_std::Integer::operator*(int _value) const
+int ls::Integer::operator*(int _value) const
 {
   return this->value * _value;
 }
 
-int ls_std::Integer::operator-(const ls_std::Integer &_integer) const
+int ls::Integer::operator-(const ls::Integer &_integer) const
 {
   return this->value - _integer;
 }
 
-int ls_std::Integer::operator-(int _value) const
+int ls::Integer::operator-(int _value) const
 {
   return this->value - _value;
 }
 
-int ls_std::Integer::operator/(const ls_std::Integer &_integer) const
+int ls::Integer::operator/(const ls::Integer &_integer) const
 {
   if (_integer == 0)
   {
-    throw ls_std::IllegalArithmeticOperationException{};
+    throw ls::IllegalArithmeticOperationException{};
   }
 
   return this->value / _integer;
 }
 
-int ls_std::Integer::operator/(int _value) const
+int ls::Integer::operator/(int _value) const
 {
   if (_value == 0)
   {
-    throw ls_std::IllegalArithmeticOperationException{};
+    throw ls::IllegalArithmeticOperationException{};
   }
 
   return this->value / _value;
 }
 
-int ls_std::Integer::operator%(const ls_std::Integer &_integer) const
+int ls::Integer::operator%(const ls::Integer &_integer) const
 {
   return this->value % _integer;
 }
 
-int ls_std::Integer::operator%(int _value) const
+int ls::Integer::operator%(int _value) const
 {
   return this->value % _value;
 }
 
-ls_std::Integer &ls_std::Integer::operator+=(const ls_std::Integer &_integer)
+ls::Integer &ls::Integer::operator+=(const ls::Integer &_integer)
 {
   this->value += _integer;
   return *this;
 }
 
-ls_std::Integer &ls_std::Integer::operator+=(int _value)
+ls::Integer &ls::Integer::operator+=(int _value)
 {
   this->value += _value;
   return *this;
 }
 
-ls_std::Integer &ls_std::Integer::operator-=(const ls_std::Integer &_integer)
+ls::Integer &ls::Integer::operator-=(const ls::Integer &_integer)
 {
   this->value -= _integer;
   return *this;
 }
 
-ls_std::Integer &ls_std::Integer::operator-=(int _value)
+ls::Integer &ls::Integer::operator-=(int _value)
 {
   this->value -= _value;
   return *this;
 }
 
-ls_std::Integer &ls_std::Integer::operator*=(const ls_std::Integer &_integer)
+ls::Integer &ls::Integer::operator*=(const ls::Integer &_integer)
 {
   this->value *= _integer;
   return *this;
 }
 
-ls_std::Integer &ls_std::Integer::operator*=(int _value)
+ls::Integer &ls::Integer::operator*=(int _value)
 {
   this->value *= _value;
   return *this;
 }
 
-ls_std::Integer &ls_std::Integer::operator/=(const ls_std::Integer &_integer)
+ls::Integer &ls::Integer::operator/=(const ls::Integer &_integer)
 {
   if (_integer == 0)
   {
-    throw ls_std::IllegalArithmeticOperationException{};
+    throw ls::IllegalArithmeticOperationException{};
   }
 
   this->value /= _integer;
   return *this;
 }
 
-ls_std::Integer &ls_std::Integer::operator/=(int _value)
+ls::Integer &ls::Integer::operator/=(int _value)
 {
   if (_value == 0)
   {
-    throw ls_std::IllegalArithmeticOperationException{};
+    throw ls::IllegalArithmeticOperationException{};
   }
 
   this->value /= _value;
   return *this;
 }
 
-bool ls_std::Integer::operator==(const ls_std::Integer &_integer) const
+bool ls::Integer::operator==(const ls::Integer &_integer) const
 {
   return this->value == _integer;
 }
 
-bool ls_std::Integer::operator==(int _value) const
+bool ls::Integer::operator==(int _value) const
 {
   return this->value == _value;
 }
 
-bool ls_std::Integer::operator!=(const ls_std::Integer &_integer) const
+bool ls::Integer::operator!=(const ls::Integer &_integer) const
 {
   return this->value != _integer;
 }
 
-bool ls_std::Integer::operator!=(int _value) const
+bool ls::Integer::operator!=(int _value) const
 {
   return this->value != _value;
 }
 
-bool ls_std::Integer::operator>(const ls_std::Integer &_integer) const
+bool ls::Integer::operator>(const ls::Integer &_integer) const
 {
   return this->value > _integer;
 }
 
-bool ls_std::Integer::operator>(int _value) const
+bool ls::Integer::operator>(int _value) const
 {
   return this->value > _value;
 }
 
-bool ls_std::Integer::operator>=(const ls_std::Integer &_integer) const
+bool ls::Integer::operator>=(const ls::Integer &_integer) const
 {
   return this->value >= _integer;
 }
 
-bool ls_std::Integer::operator>=(int _value) const
+bool ls::Integer::operator>=(int _value) const
 {
   return this->value >= _value;
 }
 
-bool ls_std::Integer::operator<(const ls_std::Integer &_integer) const
+bool ls::Integer::operator<(const ls::Integer &_integer) const
 {
   return this->value < _integer;
 }
 
-bool ls_std::Integer::operator<(int _value) const
+bool ls::Integer::operator<(int _value) const
 {
   return this->value < _value;
 }
 
-bool ls_std::Integer::operator<=(const ls_std::Integer &_integer) const
+bool ls::Integer::operator<=(const ls::Integer &_integer) const
 {
   return this->value <= _integer;
 }
 
-bool ls_std::Integer::operator<=(int _value) const
+bool ls::Integer::operator<=(int _value) const
 {
   return this->value <= _value;
 }
 
-bool ls_std::Integer::operator&&(const ls_std::Integer &_integer) const
+bool ls::Integer::operator&&(const ls::Integer &_integer) const
 {
   return this->value && _integer;
 }
 
-bool ls_std::Integer::operator&&(int _value) const
+bool ls::Integer::operator&&(int _value) const
 {
   return this->value && _value;
 }
 
-bool ls_std::Integer::operator&&(bool _expression) const
+bool ls::Integer::operator&&(bool _expression) const
 {
   return this->value && _expression;
 }
 
-bool ls_std::Integer::operator||(const ls_std::Integer &_integer) const
+bool ls::Integer::operator||(const ls::Integer &_integer) const
 {
   return this->value || _integer;
 }
 
-bool ls_std::Integer::operator||(int _value) const
+bool ls::Integer::operator||(int _value) const
 {
   return this->value || _value;
 }
 
-bool ls_std::Integer::operator||(bool _expression) const
+bool ls::Integer::operator||(bool _expression) const
 {
   return this->value || _expression;
 }
 
-void ls_std::Integer::operator++()
+void ls::Integer::operator++()
 {
   this->value += 1;
 }
 
-void ls_std::Integer::operator--()
+void ls::Integer::operator--()
 {
   this->value -= 1;
 }
 
-void ls_std::Integer::parse(std::string _parseText)
+void ls::Integer::parse(std::string _parseText)
 {
   this->value = std::stoi(_parseText);
 }
 
-std::string ls_std::Integer::toString()
+std::string ls::Integer::toString()
 {
   return std::to_string(this->value);
 }
 
-int ls_std::Integer::getValue() const
+int ls::Integer::getValue() const
 {
   return this->value;
 }

source/ls_std/boxing/Long.cpp

@@ -10,259 +10,259 @@
 #include <ls_std/boxing/Long.hpp>
 #include <ls_std/core/exception/IllegalArithmeticOperationException.hpp>
 
-ls_std::Long::Long(ls_std::long_type _value)
-    : ls_std::Class("Long"),
+ls::Long::Long(ls::long_type _value)
+    : ls::Class("Long"),
       value(_value)
 {}
 
-ls_std::Long::Long() : ls_std::Class("Long")
+ls::Long::Long() : ls::Class("Long")
 {}
 
-ls_std::Long::operator ls_std::long_type() const
+ls::Long::operator ls::long_type() const
 {
   return this->value;
 }
 
-ls_std::Long &ls_std::Long::operator=(ls_std::long_type _value)
+ls::Long &ls::Long::operator=(ls::long_type _value)
 {
   this->value = _value;
   return *this;
 }
 
-ls_std::long_type ls_std::Long::operator-() const
+ls::long_type ls::Long::operator-() const
 {
   return -this->value;
 }
 
-ls_std::long_type ls_std::Long::operator+(const ls_std::Long &_long) const
+ls::long_type ls::Long::operator+(const ls::Long &_long) const
 {
   return this->value + _long;
 }
 
-ls_std::long_type ls_std::Long::operator+(ls_std::long_type _value) const
+ls::long_type ls::Long::operator+(ls::long_type _value) const
 {
   return this->value + _value;
 }
 
-ls_std::long_type ls_std::Long::operator*(const ls_std::Long &_long) const
+ls::long_type ls::Long::operator*(const ls::Long &_long) const
 {
   return this->value * _long;
 }
 
-ls_std::long_type ls_std::Long::operator*(ls_std::long_type _value) const
+ls::long_type ls::Long::operator*(ls::long_type _value) const
 {
   return this->value * _value;
 }
 
-ls_std::long_type ls_std::Long::operator-(const ls_std::Long &_long) const
+ls::long_type ls::Long::operator-(const ls::Long &_long) const
 {
   return this->value - _long;
 }
 
-ls_std::long_type ls_std::Long::operator-(ls_std::long_type _value) const
+ls::long_type ls::Long::operator-(ls::long_type _value) const
 {
   return this->value - _value;
 }
 
-ls_std::long_type ls_std::Long::operator/(const ls_std::Long &_long) const
+ls::long_type ls::Long::operator/(const ls::Long &_long) const
 {
-  if (_long == (ls_std::long_type) 0)
+  if (_long == (ls::long_type) 0)
   {
-    throw ls_std::IllegalArithmeticOperationException{};
+    throw ls::IllegalArithmeticOperationException{};
   }
 
   return this->value / _long;
 }
 
-ls_std::long_type ls_std::Long::operator/(ls_std::long_type _value) const
+ls::long_type ls::Long::operator/(ls::long_type _value) const
 {
   if (_value == 0)
   {
-    throw ls_std::IllegalArithmeticOperationException{};
+    throw ls::IllegalArithmeticOperationException{};
   }
 
   return this->value / _value;
 }
 
-ls_std::long_type ls_std::Long::operator%(const ls_std::Long &_long) const
+ls::long_type ls::Long::operator%(const ls::Long &_long) const
 {
   return this->value % _long;
 }
 
-ls_std::long_type ls_std::Long::operator%(ls_std::long_type _value) const
+ls::long_type ls::Long::operator%(ls::long_type _value) const
 {
   return this->value % _value;
 }
 
-ls_std::Long &ls_std::Long::operator+=(const ls_std::Long &_long)
+ls::Long &ls::Long::operator+=(const ls::Long &_long)
 {
   this->value += _long;
   return *this;
 }
 
-ls_std::Long &ls_std::Long::operator+=(ls_std::long_type _value)
+ls::Long &ls::Long::operator+=(ls::long_type _value)
 {
   this->value += _value;
   return *this;
 }
 
-ls_std::Long &ls_std::Long::operator-=(const ls_std::Long &_long)
+ls::Long &ls::Long::operator-=(const ls::Long &_long)
 {
   this->value -= _long;
   return *this;
 }
 
-ls_std::Long &ls_std::Long::operator-=(ls_std::long_type _value)
+ls::Long &ls::Long::operator-=(ls::long_type _value)
 {
   this->value -= _value;
   return *this;
 }
 
-ls_std::Long &ls_std::Long::operator*=(const ls_std::Long &_long)
+ls::Long &ls::Long::operator*=(const ls::Long &_long)
 {
   this->value *= _long;
   return *this;
 }
 
-ls_std::Long &ls_std::Long::operator*=(ls_std::long_type _value)
+ls::Long &ls::Long::operator*=(ls::long_type _value)
 {
   this->value *= _value;
   return *this;
 }
 
-ls_std::Long &ls_std::Long::operator/=(const ls_std::Long &_long)
+ls::Long &ls::Long::operator/=(const ls::Long &_long)
 {
-  if (_long == (ls_std::long_type) 0)
+  if (_long == (ls::long_type) 0)
   {
-    throw ls_std::IllegalArithmeticOperationException{};
+    throw ls::IllegalArithmeticOperationException{};
   }
 
   this->value /= _long;
   return *this;
 }
 
-ls_std::Long &ls_std::Long::operator/=(ls_std::long_type _value)
+ls::Long &ls::Long::operator/=(ls::long_type _value)
 {
   if (_value == 0)
   {
-    throw ls_std::IllegalArithmeticOperationException{};
+    throw ls::IllegalArithmeticOperationException{};
   }
 
   this->value /= _value;
   return *this;
 }
 
-bool ls_std::Long::operator==(const ls_std::Long &_long) const
+bool ls::Long::operator==(const ls::Long &_long) const
 {
   return this->value == _long;
 }
 
-bool ls_std::Long::operator==(ls_std::long_type _value) const
+bool ls::Long::operator==(ls::long_type _value) const
 {
   return this->value == _value;
 }
 
-bool ls_std::Long::operator!=(const ls_std::Long &_long) const
+bool ls::Long::operator!=(const ls::Long &_long) const
 {
   return this->value != _long;
 }
 
-bool ls_std::Long::operator!=(ls_std::long_type _value) const
+bool ls::Long::operator!=(ls::long_type _value) const
 {
   return this->value != _value;
 }
 
-bool ls_std::Long::operator>(const ls_std::Long &_long) const
+bool ls::Long::operator>(const ls::Long &_long) const
 {
   return this->value > _long;
 }
 
-bool ls_std::Long::operator>(ls_std::long_type _value) const
+bool ls::Long::operator>(ls::long_type _value) const
 {
   return this->value > _value;
 }
 
-bool ls_std::Long::operator>=(const ls_std::Long &_long) const
+bool ls::Long::operator>=(const ls::Long &_long) const
 {
   return this->value >= _long;
 }
 
-bool ls_std::Long::operator>=(ls_std::long_type _value) const
+bool ls::Long::operator>=(ls::long_type _value) const
 {
   return this->value >= _value;
 }
 
-bool ls_std::Long::operator<(const ls_std::Long &_long) const
+bool ls::Long::operator<(const ls::Long &_long) const
 {
   return this->value < _long;
 }
 
-bool ls_std::Long::operator<(ls_std::long_type _value) const
+bool ls::Long::operator<(ls::long_type _value) const
 {
   return this->value < _value;
 }
 
-bool ls_std::Long::operator<=(const ls_std::Long &_long) const
+bool ls::Long::operator<=(const ls::Long &_long) const
 {
   return this->value <= _long;
 }
 
-bool ls_std::Long::operator<=(ls_std::long_type _value) const
+bool ls::Long::operator<=(ls::long_type _value) const
 {
   return this->value <= _value;
 }
 
-bool ls_std::Long::operator&&(const ls_std::Long &_long) const
+bool ls::Long::operator&&(const ls::Long &_long) const
 {
   return this->value && _long;
 }
 
-bool ls_std::Long::operator&&(ls_std::long_type _value) const
+bool ls::Long::operator&&(ls::long_type _value) const
 {
   return this->value && _value;
 }
 
-bool ls_std::Long::operator&&(bool _expression) const
+bool ls::Long::operator&&(bool _expression) const
 {
   return this->value && _expression;
 }
 
-bool ls_std::Long::operator||(const ls_std::Long &_long) const
+bool ls::Long::operator||(const ls::Long &_long) const
 {
   return this->value || _long;
 }
 
-bool ls_std::Long::operator||(ls_std::long_type _value) const
+bool ls::Long::operator||(ls::long_type _value) const
 {
   return this->value || _value;
 }
 
-bool ls_std::Long::operator||(bool _expression) const
+bool ls::Long::operator||(bool _expression) const
 {
   return this->value || _expression;
 }
 
-void ls_std::Long::operator++()
+void ls::Long::operator++()
 {
   this->value += 1;
 }
 
-void ls_std::Long::operator--()
+void ls::Long::operator--()
 {
   this->value -= 1;
 }
 
-void ls_std::Long::parse(std::string _parseText)
+void ls::Long::parse(std::string _parseText)
 {
   this->value = std::stoll(_parseText);
 }
 
-std::string ls_std::Long::toString()
+std::string ls::Long::toString()
 {
   return std::to_string(this->value);
 }
 
-ls_std::long_type ls_std::Long::getValue() const
+ls::long_type ls::Long::getValue() const
 {
   return this->value;
 }

source/ls_std/boxing/String.cpp

@@ -11,142 +11,142 @@
 #include <ls_std/boxing/String.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::String::String() : ls_std::Class("String")
+ls::String::String() : ls::Class("String")
 {}
 
-ls_std::String::String(std::string _value)
-    : ls_std::Class("String"),
+ls::String::String(std::string _value)
+    : ls::Class("String"),
       value(std::move(_value))
 {}
 
-ls_std::String::operator const char *() const
+ls::String::operator const char *() const
 {
   return this->value.c_str();
 }
 
-ls_std::String::operator std::string() const
+ls::String::operator std::string() const
 {
   return this->value;
 }
 
-ls_std::String &ls_std::String::operator=(std::string _value)
+ls::String &ls::String::operator=(std::string _value)
 {
   this->value = std::move(_value);
   return *this;
 }
 
-std::string ls_std::String::operator+(ls_std::String _string) const
+std::string ls::String::operator+(ls::String _string) const
 {
   return this->value + _string.toString();
 }
 
-std::string ls_std::String::operator+(const std::string &_string) const
+std::string ls::String::operator+(const std::string &_string) const
 {
   return this->value + _string;
 }
 
-std::string ls_std::String::operator+(const char *_string) const
+std::string ls::String::operator+(const char *_string) const
 {
   return this->value + _string;
 }
 
-std::string ls_std::String::operator-(int _number)
+std::string ls::String::operator-(int _number)
 {
   std::string copy = this->value;
   return copy.substr(0, copy.size() - _number);
 }
 
-ls_std::String &ls_std::String::operator+=(ls_std::String _string)
+ls::String &ls::String::operator+=(ls::String _string)
 {
   this->value = this->value + _string.toString();
   return *this;
 }
 
-ls_std::String &ls_std::String::operator+=(const std::string &_text)
+ls::String &ls::String::operator+=(const std::string &_text)
 {
   this->value = this->value + _text;
   return *this;
 }
 
-bool ls_std::String::operator==(ls_std::String _string)
+bool ls::String::operator==(ls::String _string)
 {
   return this->value == _string.toString();
 }
 
-bool ls_std::String::operator==(const std::string &_value)
+bool ls::String::operator==(const std::string &_value)
 {
   return this->value == _value;
 }
 
-bool ls_std::String::operator==(const char *_value)
+bool ls::String::operator==(const char *_value)
 {
   return this->value == _value;
 }
 
-bool ls_std::String::operator!=(ls_std::String _string)
+bool ls::String::operator!=(ls::String _string)
 {
   return this->value != _string.toString();
 }
 
-bool ls_std::String::operator!=(const std::string &_value)
+bool ls::String::operator!=(const std::string &_value)
 {
   return this->value != _value;
 }
 
-bool ls_std::String::operator!=(const char *_value)
+bool ls::String::operator!=(const char *_value)
 {
   return this->value != _value;
 }
 
-void ls_std::String::parse(std::string _parseText)
+void ls::String::parse(std::string _parseText)
 {
   this->value = std::move(_parseText);
 }
 
-std::string ls_std::String::toString()
+std::string ls::String::toString()
 {
   return this->value;
 }
 
-bool ls_std::String::contains(const std::string &_text)
+bool ls::String::contains(const std::string &_text)
 {
   return this->value.find(_text) != std::string::npos;
 }
 
-bool ls_std::String::endsWith(const std::string &_text)
+bool ls::String::endsWith(const std::string &_text)
 {
   return this->value.rfind(_text) == (this->value.size() - _text.size());
 }
 
-bool ls_std::String::equalsIgnoreCase(ls_std::String _string)
+bool ls::String::equalsIgnoreCase(ls::String _string)
 {
   return this->toLowerCase() == _string.toLowerCase();
 }
 
-bool ls_std::String::equalsIgnoreCase(std::string _text)
+bool ls::String::equalsIgnoreCase(std::string _text)
 {
-  return this->toLowerCase() == ls_std::String{std::move(_text)}.toLowerCase();
+  return this->toLowerCase() == ls::String{std::move(_text)}.toLowerCase();
 }
 
-std::vector<ls_std::byte> ls_std::String::getByteData()
+std::vector<ls::byte> ls::String::getByteData()
 {
-  std::vector<ls_std::byte> byteData(this->value.begin(), this->value.end());
+  std::vector<ls::byte> byteData(this->value.begin(), this->value.end());
   byteData.push_back('\0');
 
   return byteData;
 }
 
-std::string ls_std::String::padLeft(size_t _width, const char _fillCharacter)
+std::string ls::String::padLeft(size_t _width, const char _fillCharacter)
 {
-  return ls_std::String::_createFillContent(this->value, _width, _fillCharacter) + this->value;
+  return ls::String::_createFillContent(this->value, _width, _fillCharacter) + this->value;
 }
 
-std::string ls_std::String::padRight(size_t _width, const char _fillCharacter)
+std::string ls::String::padRight(size_t _width, const char _fillCharacter)
 {
-  return this->value + ls_std::String::_createFillContent(this->value, _width, _fillCharacter);
+  return this->value + ls::String::_createFillContent(this->value, _width, _fillCharacter);
 }
 
-std::string ls_std::String::reverse()
+std::string ls::String::reverse()
 {
   std::string copy = this->value;
   std::reverse(copy.begin(), copy.end());
@@ -154,12 +154,12 @@ std::string ls_std::String::reverse()
   return copy;
 }
 
-bool ls_std::String::startsWith(const std::string &_text)
+bool ls::String::startsWith(const std::string &_text)
 {
   return this->value.rfind(_text, 0) == 0;
 }
 
-std::string ls_std::String::toLowerCase()
+std::string ls::String::toLowerCase()
 {
   std::string copy = this->value;
   std::transform(copy.begin(), copy.end(), copy.begin(), ::tolower);
@@ -167,7 +167,7 @@ std::string ls_std::String::toLowerCase()
   return copy;
 }
 
-std::string ls_std::String::toUpperCase()
+std::string ls::String::toUpperCase()
 {
   std::string copy = this->value;
   std::transform(copy.begin(), copy.end(), copy.begin(), ::toupper);
@@ -175,7 +175,7 @@ std::string ls_std::String::toUpperCase()
   return copy;
 }
 
-std::string ls_std::String::_buildCharacterChain(size_t _amount, const char _fillCharacter)
+std::string ls::String::_buildCharacterChain(size_t _amount, const char _fillCharacter)
 {
   std::string fillContent{};
 
@@ -187,14 +187,14 @@ std::string ls_std::String::_buildCharacterChain(size_t _amount, const char _fil
   return fillContent;
 }
 
-std::string ls_std::String::_createFillContent(const std::string &_text, size_t _width, const char _fillCharacter)
+std::string ls::String::_createFillContent(const std::string &_text, size_t _width, const char _fillCharacter)
 {
   size_t fillSize = _text.size() > _width ? 0 : _width - _text.size();
   std::string fillContent{};
 
   if (fillSize > 0)
   {
-    fillContent = ls_std::String::_buildCharacterChain(fillSize, _fillCharacter);
+    fillContent = ls::String::_buildCharacterChain(fillSize, _fillCharacter);
   }
 
   return fillContent;

source/ls_std/core/Class.cpp

@@ -10,21 +10,21 @@
 #include <ls_std/core/Class.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::Class::Class(const std::string &_name)
+ls::Class::Class(const std::string &_name)
 {
   this->_assignClassName(_name);
 }
 
-std::string ls_std::Class::getClassName()
+std::string ls::Class::getClassName()
 {
   return this->name;
 }
 
-void ls_std::Class::_assignClassName(const std::string &_name)
+void ls::Class::_assignClassName(const std::string &_name)
 {
   if (_name.empty())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->name = _name;

source/ls_std/core/Version.cpp

@@ -3,22 +3,22 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-28
- * Changed:         2022-04-29
+ * Changed:         2022-05-05
  *
  * */
 
 #include <regex>
 #include <ls_std/core/Version.hpp>
 
-ls_std::Version::Version(ls_std::version_type _majorVersion, ls_std::version_type _minorVersion, ls_std::version_type _patchVersion)
+ls::Version::Version(ls::version_type _majorVersion, ls::version_type _minorVersion, ls::version_type _patchVersion)
     : majorVersion(_majorVersion),
       minorVersion(_minorVersion),
       patchVersion(_patchVersion)
 {}
 
-ls_std::byte_field ls_std::Version::marshal()
+ls::byte_field ls::Version::marshal()
 {
-  ls_std::byte_field data{};
+  ls::byte_field data{};
 
   data += std::to_string(this->majorVersion) + ".";
   data += std::to_string(this->minorVersion) + ".";
@@ -27,11 +27,11 @@ ls_std::byte_field ls_std::Version::marshal()
   return data;
 }
 
-void ls_std::Version::unmarshal(const ls_std::byte_field &_data)
+void ls::Version::unmarshal(const ls::byte_field &_data)
 {
   std::string field = _data;
 
-  if (ls_std::Version::_isValid(_data))
+  if (ls::Version::_isValid(_data))
   {
     size_t position = field.find('.');
     std::string subSequence = field.substr(0, position);
@@ -47,42 +47,42 @@ void ls_std::Version::unmarshal(const ls_std::byte_field &_data)
   }
 }
 
-ls_std::version_type ls_std::Version::getMajorVersion() const
+ls::version_type ls::Version::getMajorVersion() const
 {
   return this->majorVersion;
 }
 
-ls_std::version_type ls_std::Version::getMinorVersion() const
+ls::version_type ls::Version::getMinorVersion() const
 {
   return this->minorVersion;
 }
 
-ls_std::version_type ls_std::Version::getPatchVersion() const
+ls::version_type ls::Version::getPatchVersion() const
 {
   return this->patchVersion;
 }
 
-bool ls_std::Version::isValid(const std::string &_versionString)
+bool ls::Version::isValid(const std::string &_versionString)
 {
-  return ls_std::Version::_isValid(_versionString);
+  return ls::Version::_isValid(_versionString);
 }
 
-void ls_std::Version::setMajorVersion(ls_std::version_type _major)
+void ls::Version::setMajorVersion(ls::version_type _major)
 {
   this->majorVersion = _major;
 }
 
-void ls_std::Version::setMinorVersion(ls_std::version_type _minor)
+void ls::Version::setMinorVersion(ls::version_type _minor)
 {
   this->minorVersion = _minor;
 }
 
-void ls_std::Version::setPatchVersion(ls_std::version_type _patch)
+void ls::Version::setPatchVersion(ls::version_type _patch)
 {
   this->patchVersion = _patch;
 }
 
-bool ls_std::Version::_isValid(const std::string &_versionString)
+bool ls::Version::_isValid(const std::string &_versionString)
 {
   bool isValidVersionString{};
   static std::regex versionRegex{R"(\d+[.]\d+[.]\d+)"};

source/ls_std/event/Event.cpp

@@ -10,12 +10,12 @@
 #include <ls_std/event/Event.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::Event::Event(const ls_std::event_id &_id) : ls_std::Class("Event")
+ls::Event::Event(const ls::event_id &_id) : ls::Class("Event")
 {
   this->_assignId(_id);
 }
 
-bool ls_std::Event::addParameter(const ls_std::event_parameter &_eventParameter)
+bool ls::Event::addParameter(const ls::event_parameter &_eventParameter)
 {
   bool wasAdded{};
 
@@ -27,42 +27,42 @@ bool ls_std::Event::addParameter(const ls_std::event_parameter &_eventParameter)
   return wasAdded;
 }
 
-void ls_std::Event::clearParameterList()
+void ls::Event::clearParameterList()
 {
   this->parameterList.clear();
 }
 
-ls_std::event_id ls_std::Event::getId()
+ls::event_id ls::Event::getId()
 {
   return this->id;
 }
 
-ls_std::event_parameter_list ls_std::Event::getParameterList()
+ls::event_parameter_list ls::Event::getParameterList()
 {
   return this->parameterList;
 }
 
-bool ls_std::Event::removeParameter(const ls_std::event_parameter_id &_id)
+bool ls::Event::removeParameter(const ls::event_parameter_id &_id)
 {
   return this->parameterList.erase(_id) == 1;
 }
 
-void ls_std::Event::setId(const ls_std::event_id &_id)
+void ls::Event::setId(const ls::event_id &_id)
 {
   this->_assignId(_id);
 }
 
-void ls_std::Event::_assignId(const ls_std::event_id &_id)
+void ls::Event::_assignId(const ls::event_id &_id)
 {
   if (_id.empty())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->id = _id;
 }
 
-bool ls_std::Event::_hasParameter(const ls_std::event_id &_id)
+bool ls::Event::_hasParameter(const ls::event_id &_id)
 {
   return this->parameterList.find(_id) != this->parameterList.end();
 }

source/ls_std/event/EventHandler.cpp

@@ -10,21 +10,21 @@
 #include <ls_std/event/EventHandler.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::EventHandler::EventHandler(const ls_std::event_id& _id) : ls_std::Narrator()
+ls::EventHandler::EventHandler(const ls::event_id& _id) : ls::Narrator()
 {
   this->_assignId(_id);
 }
 
-ls_std::event_id ls_std::EventHandler::getId()
+ls::event_id ls::EventHandler::getId()
 {
   return this->id;
 }
 
-void ls_std::EventHandler::_assignId(const ls_std::event_id &_id)
+void ls::EventHandler::_assignId(const ls::event_id &_id)
 {
   if (_id.empty())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->id = _id;

source/ls_std/event/EventManager.cpp

@@ -12,14 +12,14 @@
 #include <ls_std/core/exception/EventNotHandledException.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::EventManager::EventManager() : ls_std::Class("EventManager")
+ls::EventManager::EventManager() : ls::Class("EventManager")
 {}
 
-void ls_std::EventManager::subscribe(const ls_std::event_id &_id, const std::shared_ptr<ls_std::IListener> &_listener)
+void ls::EventManager::subscribe(const ls::event_id &_id, const std::shared_ptr<ls::IListener> &_listener)
 {
   if (_id.empty() || _listener == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   if (this->_hasEventHandler(_id))
@@ -28,15 +28,15 @@ void ls_std::EventManager::subscribe(const ls_std::event_id &_id, const std::sha
   }
   else
   {
-    throw ls_std::EventNotSubscribedException{};
+    throw ls::EventNotSubscribedException{};
   }
 }
 
-void ls_std::EventManager::unsubscribe(const ls_std::event_id &_id, const std::shared_ptr<ls_std::IListener> &_listener)
+void ls::EventManager::unsubscribe(const ls::event_id &_id, const std::shared_ptr<ls::IListener> &_listener)
 {
   if (_id.empty() || _listener == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   if (this->_hasEventHandler(_id))
@@ -45,25 +45,25 @@ void ls_std::EventManager::unsubscribe(const ls_std::event_id &_id, const std::s
   }
 }
 
-bool ls_std::EventManager::addEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
+bool ls::EventManager::addEventHandler(const std::shared_ptr<ls::EventHandler> &_eventHandler)
 {
   bool wasAdded{};
 
   if (_eventHandler == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::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);
+    std::pair<ls::event_id, std::shared_ptr<ls::EventHandler>> element = std::make_pair(_eventHandler->getId(), _eventHandler);
     wasAdded = this->eventHandlers.insert(element).second;
   }
 
   return wasAdded;
 }
 
-void ls_std::EventManager::fire(ls_std::Event _event)
+void ls::EventManager::fire(ls::Event _event)
 {
   if (this->_hasEventHandler(_event.getId()))
   {
@@ -71,36 +71,36 @@ void ls_std::EventManager::fire(ls_std::Event _event)
   }
   else
   {
-    throw ls_std::EventNotHandledException{};
+    throw ls::EventNotHandledException{};
   }
 }
 
-bool ls_std::EventManager::hasEventHandler(const ls_std::event_id &_id)
+bool ls::EventManager::hasEventHandler(const ls::event_id &_id)
 {
   if (_id.empty())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   return this->_hasEventHandler(_id);
 }
 
-bool ls_std::EventManager::removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
+bool ls::EventManager::removeEventHandler(const std::shared_ptr<ls::EventHandler> &_eventHandler)
 {
   if (_eventHandler == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   return this->_removeEventHandler(_eventHandler);
 }
 
-bool ls_std::EventManager::_hasEventHandler(const ls_std::event_id &_id)
+bool ls::EventManager::_hasEventHandler(const ls::event_id &_id)
 {
   return this->eventHandlers.find(_id) != this->eventHandlers.end();
 }
 
-bool ls_std::EventManager::_removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
+bool ls::EventManager::_removeEventHandler(const std::shared_ptr<ls::EventHandler> &_eventHandler)
 {
   return this->eventHandlers.erase(_eventHandler->getId()) == 1;
 }

source/ls_std/event/serialization/SerializableJsonEvent.cpp

@@ -10,18 +10,18 @@
 #include "ls_std/event/serialization/SerializableJsonEvent.hpp"
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::SerializableJsonEvent::SerializableJsonEvent(const std::shared_ptr<ls_std::Event> &_value) : ls_std::Class("SerializableJsonEvent")
+ls::SerializableJsonEvent::SerializableJsonEvent(const std::shared_ptr<ls::Event> &_value) : ls::Class("SerializableJsonEvent")
 {
   this->_assignValue(_value);
 }
 
-ls_std::byte_field ls_std::SerializableJsonEvent::marshal()
+ls::byte_field ls::SerializableJsonEvent::marshal()
 {
   this->_update();
   return this->jsonObject.dump();
 }
 
-void ls_std::SerializableJsonEvent::unmarshal(const ls_std::byte_field &_data)
+void ls::SerializableJsonEvent::unmarshal(const ls::byte_field &_data)
 {
   this->jsonObject = nlohmann::json::parse(_data);
 
@@ -29,45 +29,45 @@ 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::Event> ls::SerializableJsonEvent::getValue()
 {
   return this->value;
 }
 
-void ls_std::SerializableJsonEvent::setValue(const std::shared_ptr<ls_std::Event> &_value)
+void ls::SerializableJsonEvent::setValue(const std::shared_ptr<ls::Event> &_value)
 {
   this->_assignValue(_value);
 }
 
-void ls_std::SerializableJsonEvent::_assignValue(const std::shared_ptr<ls_std::Event> &_value)
+void ls::SerializableJsonEvent::_assignValue(const std::shared_ptr<ls::Event> &_value)
 {
   if (_value == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->value = _value;
 }
 
-void ls_std::SerializableJsonEvent::_unmarshalParameterList()
+void ls::SerializableJsonEvent::_unmarshalParameterList()
 {
   this->value->clearParameterList();
 
   for (const auto &parameterJson : this->jsonObject["parameterList"])
   {
-    ls_std::event_parameter parameter = {parameterJson.at(0), parameterJson.at(1)};
+    ls::event_parameter parameter = {parameterJson.at(0), parameterJson.at(1)};
     this->value->addParameter(parameter);
   }
 }
 
-void ls_std::SerializableJsonEvent::_update()
+void ls::SerializableJsonEvent::_update()
 {
   this->jsonObject = {{"id", this->value->getId()}};
 
   this->_updateEventParameterList();
 }
 
-void ls_std::SerializableJsonEvent::_updateEventParameterList()
+void ls::SerializableJsonEvent::_updateEventParameterList()
 {
   std::string jsonString{};
 

source/ls_std/io/File.cpp

@@ -30,109 +30,109 @@
 
 #endif
 
-ls_std::File::File(std::string _absoluteFilePath)
-    : ls_std::Class("File"),
-      absoluteFilePath(ls_std::File::_normalizePath(std::move(_absoluteFilePath)))
+ls::File::File(std::string _absoluteFilePath)
+    : ls::Class("File"),
+      absoluteFilePath(ls::File::_normalizePath(std::move(_absoluteFilePath)))
 {}
 
-bool ls_std::File::operator==(ls_std::File &_file)
+bool ls::File::operator==(ls::File &_file)
 {
-  return ls_std::File::_equals(*this, _file);
+  return ls::File::_equals(*this, _file);
 }
 
-bool ls_std::File::operator!=(ls_std::File &_file)
+bool ls::File::operator!=(ls::File &_file)
 {
-  return !ls_std::File::_equals(*this, _file);
+  return !ls::File::_equals(*this, _file);
 }
 
-bool ls_std::File::canExecute()
+bool ls::File::canExecute()
 {
-  return ls_std::File::_isExecutable(this->absoluteFilePath);
+  return ls::File::_isExecutable(this->absoluteFilePath);
 }
 
-bool ls_std::File::canRead()
+bool ls::File::canRead()
 {
   bool readable;
 
   #if defined(unix) || defined(__APPLE__)
-  readable = ls_std::File::_isReadableUnix(this->absoluteFilePath);
+  readable = ls::File::_isReadableUnix(this->absoluteFilePath);
   #endif
   #ifdef _WIN32
-  readable = ls_std::File::_isReadableWindows(this->absoluteFilePath);
+  readable = ls::File::_isReadableWindows(this->absoluteFilePath);
   #endif
 
   return readable;
 }
 
-bool ls_std::File::canWrite()
+bool ls::File::canWrite()
 {
-  return ls_std::File::_isWritable(this->absoluteFilePath);
+  return ls::File::_isWritable(this->absoluteFilePath);
 }
 
-void ls_std::File::createNewFile()
+void ls::File::createNewFile()
 {
-  if (!ls_std::File::_exists(this->absoluteFilePath))
+  if (!ls::File::_exists(this->absoluteFilePath))
   {
     std::ofstream file{this->absoluteFilePath};
     file.close();
   }
   else
   {
-    throw ls_std::FileOperationException{};
+    throw ls::FileOperationException{};
   }
 }
 
-bool ls_std::File::exists()
+bool ls::File::exists()
 {
-  return ls_std::File::_exists(this->absoluteFilePath);
+  return ls::File::_exists(this->absoluteFilePath);
 }
 
-std::string ls_std::File::getAbsoluteFilePath()
+std::string ls::File::getAbsoluteFilePath()
 {
   return this->absoluteFilePath;
 }
 
-std::string ls_std::File::getName()
+std::string ls::File::getName()
 {
   std::string copy = this->absoluteFilePath;
 
   // if it's a directory, remove separator from end, if it does exist
 
-  if (ls_std::File::_isDirectory(this->absoluteFilePath))
+  if (ls::File::_isDirectory(this->absoluteFilePath))
   {
-    copy.erase(std::remove_if(copy.end() - 1, copy.end(), ls_std::FilePathSeparatorMatch()), copy.end());
+    copy.erase(std::remove_if(copy.end() - 1, copy.end(), ls::FilePathSeparatorMatch()), copy.end());
   }
 
   // now get the file / directory name
 
-  auto base = std::find_if(copy.rbegin(), copy.rend(), ls_std::FilePathSeparatorMatch()).base();
+  auto base = std::find_if(copy.rbegin(), copy.rend(), ls::FilePathSeparatorMatch()).base();
   return std::string{base, copy.end()};
 }
 
-std::string ls_std::File::getParent()
+std::string ls::File::getParent()
 {
-  return ls_std::File::_getParent(this->absoluteFilePath);
+  return ls::File::_getParent(this->absoluteFilePath);
 }
 
-std::string ls_std::File::getWorkingDirectory()
+std::string ls::File::getWorkingDirectory()
 {
   std::string workingDirectory{};
 
   #if defined(unix) || defined(__APPLE__)
-  workingDirectory = ls_std::File::_getWorkingDirectoryUnix();
+  workingDirectory = ls::File::_getWorkingDirectoryUnix();
   #endif
   #ifdef _WIN32
-  workingDirectory = ls_std::File::_getWorkingDirectoryWindows();
+  workingDirectory = ls::File::_getWorkingDirectoryWindows();
   #endif
 
   return workingDirectory;
 }
 
-long ls_std::File::getSize()
+long ls::File::getSize()
 {
   std::streampos fileSize{};
 
-  if (ls_std::File::_exists(this->absoluteFilePath))
+  if (ls::File::_exists(this->absoluteFilePath))
   {
     std::ifstream fileHandler{this->absoluteFilePath, std::ios::in};
     fileSize = fileHandler.tellg();
@@ -144,88 +144,88 @@ long ls_std::File::getSize()
   return (long) fileSize;
 }
 
-bool ls_std::File::isDirectory()
+bool ls::File::isDirectory()
 {
-  return ls_std::File::_isDirectory(this->absoluteFilePath);
+  return ls::File::_isDirectory(this->absoluteFilePath);
 }
 
-bool ls_std::File::isFile()
+bool ls::File::isFile()
 {
-  return ls_std::File::_isFile(this->absoluteFilePath);
+  return ls::File::_isFile(this->absoluteFilePath);
 }
 
-time_t ls_std::File::lastModified()
+time_t ls::File::lastModified()
 {
-  return ls_std::File::_lastModified(this->absoluteFilePath);
+  return ls::File::_lastModified(this->absoluteFilePath);
 }
 
-std::list<std::string> ls_std::File::list()
+std::list<std::string> ls::File::list()
 {
   std::list<std::string> fileList{};
 
-  if (ls_std::File::_isDirectory(this->absoluteFilePath))
+  if (ls::File::_isDirectory(this->absoluteFilePath))
   {
-    fileList = ls_std::File::_list(this->absoluteFilePath);
+    fileList = ls::File::_list(this->absoluteFilePath);
   }
 
   return fileList;
 }
 
-std::list<std::string> ls_std::File::listFiles()
+std::list<std::string> ls::File::listFiles()
 {
   std::list<std::string> fileList{};
 
-  if (ls_std::File::_isDirectory(this->absoluteFilePath))
+  if (ls::File::_isDirectory(this->absoluteFilePath))
   {
-    fileList = ls_std::File::_listFiles(this->absoluteFilePath);
+    fileList = ls::File::_listFiles(this->absoluteFilePath);
   }
 
   return fileList;
 }
 
-void ls_std::File::makeDirectory()
+void ls::File::makeDirectory()
 {
-  if (ls_std::File::_mkdir(this->absoluteFilePath))
+  if (ls::File::_mkdir(this->absoluteFilePath))
   {
-    throw ls_std::FileOperationException{};
+    throw ls::FileOperationException{};
   }
 }
 
-void ls_std::File::makeDirectories()
+void ls::File::makeDirectories()
 {
-  std::vector<std::string> subDirectories = ls_std::File::_splitIntoSubDirectoryNames(this->absoluteFilePath);
-  const char separator = ls_std::FilePathSeparator::get();
+  std::vector<std::string> subDirectories = ls::File::_splitIntoSubDirectoryNames(this->absoluteFilePath);
+  const char separator = ls::FilePathSeparator::get();
   std::string currentHierarchy{};
 
   for (const auto &subDirectory: subDirectories)
   {
     currentHierarchy += subDirectory;
 
-    if (!ls_std::File::_exists(currentHierarchy))
+    if (!ls::File::_exists(currentHierarchy))
     {
-      ls_std::File::_mkdir(currentHierarchy);
+      ls::File::_mkdir(currentHierarchy);
     }
 
     currentHierarchy += separator;
   }
 }
 
-void ls_std::File::remove()
+void ls::File::remove()
 {
-  if (ls_std::File::_isFile(this->absoluteFilePath))
+  if (ls::File::_isFile(this->absoluteFilePath))
   {
     std::remove(this->absoluteFilePath.c_str());
   }
 
-  if (ls_std::File::_isDirectory(this->absoluteFilePath))
+  if (ls::File::_isDirectory(this->absoluteFilePath))
   {
-    ls_std::File::_remove(this->absoluteFilePath);
+    ls::File::_remove(this->absoluteFilePath);
   }
 }
 
-bool ls_std::File::renameTo(const std::string &_newName)
+bool ls::File::renameTo(const std::string &_newName)
 {
-  bool renamed = ls_std::File::_renameTo(this->absoluteFilePath, _newName);
+  bool renamed = ls::File::_renameTo(this->absoluteFilePath, _newName);
 
   if (renamed)
   {
@@ -235,16 +235,16 @@ bool ls_std::File::renameTo(const std::string &_newName)
   return renamed;
 }
 
-void ls_std::File::reset(const std::string &_newPath)
+void ls::File::reset(const std::string &_newPath)
 {
-  this->absoluteFilePath = ls_std::File::_normalizePath(_newPath);
+  this->absoluteFilePath = ls::File::_normalizePath(_newPath);
 }
 
 #ifdef _WIN32
 
-void ls_std::File::_addToFileListWindows(const std::string &_path, bool _withDirectories, WIN32_FIND_DATA _data, std::list<std::string> &_list)
+void ls::File::_addToFileListWindows(const std::string &_path, bool _withDirectories, WIN32_FIND_DATA _data, std::list<std::string> &_list)
 {
-  const char separator = ls_std::FilePathSeparator::get();
+  const char separator = ls::FilePathSeparator::get();
   std::string absolutePath = _path + separator + _data.cFileName;
 
   if (_withDirectories)
@@ -253,7 +253,7 @@ void ls_std::File::_addToFileListWindows(const std::string &_path, bool _withDir
   }
   else
   {
-    if (ls_std::File::_isFile(absolutePath))
+    if (ls::File::_isFile(absolutePath))
     {
       _list.emplace_back(absolutePath);
     }
@@ -264,9 +264,9 @@ void ls_std::File::_addToFileListWindows(const std::string &_path, bool _withDir
 
 #if defined(unix) || defined(__APPLE__)
 
-void ls_std::File::_addToFileListUnix(const std::string &_path, bool _withDirectories, dirent *directoryEntity, std::list<std::string> &_list)
+void ls::File::_addToFileListUnix(const std::string &_path, bool _withDirectories, dirent *directoryEntity, std::list<std::string> &_list)
 {
-  const char separator = ls_std::FilePathSeparator::get();
+  const char separator = ls::FilePathSeparator::get();
   std::string absolutePath = _path + separator + directoryEntity->d_name;
 
   if (_withDirectories)
@@ -275,7 +275,7 @@ void ls_std::File::_addToFileListUnix(const std::string &_path, bool _withDirect
   }
   else
   {
-    if (ls_std::File::_isFile(absolutePath))
+    if (ls::File::_isFile(absolutePath))
     {
       _list.emplace_back(absolutePath);
     }
@@ -284,7 +284,7 @@ void ls_std::File::_addToFileListUnix(const std::string &_path, bool _withDirect
 
 #endif
 
-bool ls_std::File::_equals(ls_std::File &_file, ls_std::File &_foreignFile)
+bool ls::File::_equals(ls::File &_file, ls::File &_foreignFile)
 {
   bool isEqual = _file.getAbsoluteFilePath() == _foreignFile.getAbsoluteFilePath();
 
@@ -298,17 +298,17 @@ bool ls_std::File::_equals(ls_std::File &_file, ls_std::File &_foreignFile)
   return isEqual;
 }
 
-bool ls_std::File::_exists(const std::string &_path)
+bool ls::File::_exists(const std::string &_path)
 {
   struct stat _stat{};
   return (stat(_path.c_str(), &_stat) == 0);
 }
 
-std::string ls_std::File::_getParent(const std::string &_path)
+std::string ls::File::_getParent(const std::string &_path)
 {
   std::string parent{};
-  std::vector<std::string> subDirectoryNames = ls_std::File::_splitIntoSubDirectoryNames(_path);
-  const char separator = ls_std::FilePathSeparator::get();
+  std::vector<std::string> subDirectoryNames = ls::File::_splitIntoSubDirectoryNames(_path);
+  const char separator = ls::FilePathSeparator::get();
   subDirectoryNames.pop_back();
 
   for (auto const &subDirectoryName: subDirectoryNames)
@@ -321,14 +321,14 @@ std::string ls_std::File::_getParent(const std::string &_path)
 
 #if defined(unix) || defined(__APPLE__)
 
-std::string ls_std::File::_getWorkingDirectoryUnix()
+std::string ls::File::_getWorkingDirectoryUnix()
 {
   std::string workingDirectory{};
   char buffer[PATH_MAX];
 
   if (getcwd(buffer, sizeof(buffer)) == nullptr)
   {
-    throw ls_std::FileOperationException{};
+    throw ls::FileOperationException{};
   }
   else
   {
@@ -342,14 +342,14 @@ std::string ls_std::File::_getWorkingDirectoryUnix()
 
 #ifdef _WIN32
 
-std::string ls_std::File::_getWorkingDirectoryWindows()
+std::string ls::File::_getWorkingDirectoryWindows()
 {
   std::string workingDirectory{};
   TCHAR buffer[MAX_PATH];
 
   if (!GetCurrentDirectory(MAX_PATH, buffer))
   {
-    throw ls_std::FileOperationException{};
+    throw ls::FileOperationException{};
   }
   else
   {
@@ -361,7 +361,7 @@ std::string ls_std::File::_getWorkingDirectoryWindows()
 
 #endif
 
-bool ls_std::File::_isDirectory(const std::string &_path)
+bool ls::File::_isDirectory(const std::string &_path)
 {
   bool match{};
   struct stat _stat{};
@@ -374,11 +374,11 @@ bool ls_std::File::_isDirectory(const std::string &_path)
   return match;
 }
 
-bool ls_std::File::_isExecutable(const std::string &_path)
+bool ls::File::_isExecutable(const std::string &_path)
 {
   bool executable{};
 
-  if (ls_std::File::_exists(_path))
+  if (ls::File::_exists(_path))
   {
     struct stat _stat{};
 
@@ -391,7 +391,7 @@ bool ls_std::File::_isExecutable(const std::string &_path)
   return executable;
 }
 
-bool ls_std::File::_isFile(const std::string &_path)
+bool ls::File::_isFile(const std::string &_path)
 {
   bool match{};
   struct stat _stat{};
@@ -406,11 +406,11 @@ bool ls_std::File::_isFile(const std::string &_path)
 
 #if defined(unix) || defined(__APPLE__)
 
-bool ls_std::File::_isReadableUnix(const std::string &_path)
+bool ls::File::_isReadableUnix(const std::string &_path)
 {
   bool readable{};
 
-  if (ls_std::File::_exists(_path))
+  if (ls::File::_exists(_path))
   {
     struct stat _stat{};
 
@@ -421,7 +421,7 @@ bool ls_std::File::_isReadableUnix(const std::string &_path)
   }
   else
   {
-    throw ls_std::FileOperationException{};
+    throw ls::FileOperationException{};
   }
 
   return readable;
@@ -431,7 +431,7 @@ bool ls_std::File::_isReadableUnix(const std::string &_path)
 
 #ifdef _WIN32
 
-bool ls_std::File::_isReadableWindows(const std::string &_path)
+bool ls::File::_isReadableWindows(const std::string &_path)
 {
   bool readable;
   WIN32_FIND_DATA data{};
@@ -443,7 +443,7 @@ bool ls_std::File::_isReadableWindows(const std::string &_path)
   }
   else
   {
-    throw ls_std::FileOperationException{};
+    throw ls::FileOperationException{};
   }
 
   return readable;
@@ -451,11 +451,11 @@ bool ls_std::File::_isReadableWindows(const std::string &_path)
 
 #endif
 
-bool ls_std::File::_isWritable(const std::string &_path)
+bool ls::File::_isWritable(const std::string &_path)
 {
   bool writable{};
 
-  if (ls_std::File::_exists(_path))
+  if (ls::File::_exists(_path))
   {
     struct stat _stat{};
 
@@ -468,7 +468,7 @@ bool ls_std::File::_isWritable(const std::string &_path)
   return writable;
 }
 
-time_t ls_std::File::_lastModified(const std::string &_path)
+time_t ls::File::_lastModified(const std::string &_path)
 {
   time_t lastModifiedTimeStamp{};
   struct stat _stat{};
@@ -481,29 +481,29 @@ time_t ls_std::File::_lastModified(const std::string &_path)
   return lastModifiedTimeStamp;
 }
 
-std::list<std::string> ls_std::File::_list(const std::string &_path)
+std::list<std::string> ls::File::_list(const std::string &_path)
 {
   std::list<std::string> filesInDirectory{};
 
   #if defined(unix) || defined(__APPLE__)
-  filesInDirectory = ls_std::File::_listUnix(_path, true);
+  filesInDirectory = ls::File::_listUnix(_path, true);
   #endif
   #ifdef _WIN32
-  filesInDirectory = ls_std::File::_listWindows(_path, true);
+  filesInDirectory = ls::File::_listWindows(_path, true);
   #endif
 
   return filesInDirectory;
 }
 
-std::list<std::string> ls_std::File::_listFiles(const std::string &_path)
+std::list<std::string> ls::File::_listFiles(const std::string &_path)
 {
   std::list<std::string> filesInDirectory{};
 
   #if defined(unix) || defined(__APPLE__)
-  filesInDirectory = ls_std::File::_listUnix(_path, false);
+  filesInDirectory = ls::File::_listUnix(_path, false);
   #endif
   #ifdef _WIN32
-  filesInDirectory = ls_std::File::_listWindows(_path, false);
+  filesInDirectory = ls::File::_listWindows(_path, false);
   #endif
 
   return filesInDirectory;
@@ -511,7 +511,7 @@ std::list<std::string> ls_std::File::_listFiles(const std::string &_path)
 
 #if defined(unix) || defined(__APPLE__)
 
-std::list<std::string> ls_std::File::_listUnix(const std::string &_path, bool withDirectories)
+std::list<std::string> ls::File::_listUnix(const std::string &_path, bool withDirectories)
 {
   std::list<std::string> filesInDirectory{};
   DIR *directory = opendir(_path.c_str());
@@ -520,7 +520,7 @@ std::list<std::string> ls_std::File::_listUnix(const std::string &_path, bool wi
 
   while ((directoryEntity = readdir(directory)) != nullptr)
   {
-    ls_std::File::_addToFileListUnix(_path, withDirectories, directoryEntity, filesInDirectory);
+    ls::File::_addToFileListUnix(_path, withDirectories, directoryEntity, filesInDirectory);
   }
 
   closedir(directory);
@@ -531,18 +531,18 @@ std::list<std::string> ls_std::File::_listUnix(const std::string &_path, bool wi
 
 #ifdef _WIN32
 
-std::list<std::string> ls_std::File::_listWindows(const std::string &_path, bool withDirectories)
+std::list<std::string> ls::File::_listWindows(const std::string &_path, bool withDirectories)
 {
   std::list<std::string> filesInDirectory{};
   WIN32_FIND_DATA data{};
   HANDLE hFind;
-  std::string pattern{_path + ls_std::FilePathSeparator::get() + "*"};
+  std::string pattern{_path + ls::FilePathSeparator::get() + "*"};
 
   if ((hFind = FindFirstFile(pattern.c_str(), &data)) != INVALID_HANDLE_VALUE)
   {
     do
     {
-      ls_std::File::_addToFileListWindows(_path, withDirectories, data, filesInDirectory);
+      ls::File::_addToFileListWindows(_path, withDirectories, data, filesInDirectory);
     } while (FindNextFile(hFind, &data) != 0);
 
     FindClose(hFind);
@@ -553,7 +553,7 @@ std::list<std::string> ls_std::File::_listWindows(const std::string &_path, bool
 
 #endif
 
-int ls_std::File::_mkdir(const std::string &_path)
+int ls::File::_mkdir(const std::string &_path)
 {
   int result;
 
@@ -568,17 +568,17 @@ int ls_std::File::_mkdir(const std::string &_path)
   return result;
 }
 
-std::string ls_std::File::_normalizePath(std::string _path)
+std::string ls::File::_normalizePath(std::string _path)
 {
-  _path = ls_std::File::_replaceWrongSeparator(_path);
-  _path = ls_std::File::_reduceSeparators(_path);
+  _path = ls::File::_replaceWrongSeparator(_path);
+  _path = ls::File::_reduceSeparators(_path);
 
   return _path;
 }
 
-std::string ls_std::File::_reduceSeparators(const std::string &_path)
+std::string ls::File::_reduceSeparators(const std::string &_path)
 {
-  static const char separator = {ls_std::FilePathSeparator::get()};
+  static const char separator = {ls::FilePathSeparator::get()};
   std::string normalizedPath{};
   int index{};
 
@@ -603,19 +603,19 @@ std::string ls_std::File::_reduceSeparators(const std::string &_path)
   return normalizedPath;
 }
 
-void ls_std::File::_remove(const std::string &_path)
+void ls::File::_remove(const std::string &_path)
 {
   #if defined(unix) || defined(__APPLE__)
-  ls_std::File::_removeUnix(_path);
+  ls::File::_removeUnix(_path);
   #endif
   #ifdef _WIN32
-  ls_std::File::_removeWindows(_path);
+  ls::File::_removeWindows(_path);
   #endif
 }
 
 #if defined(unix) || defined(__APPLE__)
 
-void ls_std::File::_removeUnix(const std::string &_path)
+void ls::File::_removeUnix(const std::string &_path)
 {
   rmdir(_path.c_str());
 }
@@ -624,22 +624,22 @@ void ls_std::File::_removeUnix(const std::string &_path)
 
 #ifdef _WIN32
 
-void ls_std::File::_removeWindows(const std::string &_path)
+void ls::File::_removeWindows(const std::string &_path)
 {
   _rmdir(_path.c_str());
 }
 
 #endif
 
-bool ls_std::File::_renameTo(const std::string &_oldName, const std::string &_newName)
+bool ls::File::_renameTo(const std::string &_oldName, const std::string &_newName)
 {
   return std::rename(_oldName.c_str(), _newName.c_str()) == 0;
 }
 
-std::string ls_std::File::_replaceWrongSeparator(std::string _path)
+std::string ls::File::_replaceWrongSeparator(std::string _path)
 {
-  static const char unixSeparator = ls_std::FilePathSeparator::getUnixFilePathSeparator();
-  static const char windowsSeparator = ls_std::FilePathSeparator::getWindowsFilePathSeparator();
+  static const char unixSeparator = ls::FilePathSeparator::getUnixFilePathSeparator();
+  static const char windowsSeparator = ls::FilePathSeparator::getWindowsFilePathSeparator();
 
   #if defined(unix) || defined(__APPLE__)
   std::replace(_path.begin(), _path.end(), windowsSeparator, unixSeparator);
@@ -652,12 +652,12 @@ std::string ls_std::File::_replaceWrongSeparator(std::string _path)
   return _path;
 }
 
-std::vector<std::string> ls_std::File::_splitIntoSubDirectoryNames(const std::string &_path)
+std::vector<std::string> ls::File::_splitIntoSubDirectoryNames(const std::string &_path)
 {
   std::vector<std::string> subDirectoryNames{};
   std::stringstream _stream{_path};
   std::string subDirectoryName{};
-  const char separator = ls_std::FilePathSeparator::get();
+  const char separator = ls::FilePathSeparator::get();
 
   while (std::getline(_stream, subDirectoryName, separator))
   {

source/ls_std/io/FileOutputStream.cpp

@@ -11,32 +11,32 @@
 #include <ls_std/core/exception/FileNotFoundException.hpp>
 #include <ls_std/core/exception/FileOperationException.hpp>
 
-ls_std::FileOutputStream::FileOutputStream(ls_std::File &_file)
-    : ls_std::Class("FileOutputStream"),
+ls::FileOutputStream::FileOutputStream(ls::File &_file)
+    : ls::Class("FileOutputStream"),
       file(_file)
 {
   this->_init();
 }
 
-ls_std::FileOutputStream::FileOutputStream(ls_std::File &_file, bool _append)
-    : ls_std::Class("FileOutputStream"),
+ls::FileOutputStream::FileOutputStream(ls::File &_file, bool _append)
+    : ls::Class("FileOutputStream"),
       append(_append),
       file(_file)
 {
   this->_init();
 }
 
-ls_std::FileOutputStream::~FileOutputStream()
+ls::FileOutputStream::~FileOutputStream()
 {
   this->_close();
 }
 
-void ls_std::FileOutputStream::close()
+void ls::FileOutputStream::close()
 {
   this->_close();
 }
 
-bool ls_std::FileOutputStream::write(const ls_std::byte_field &_data)
+bool ls::FileOutputStream::write(const ls::byte_field &_data)
 {
   bool succeeded{};
 
@@ -49,13 +49,13 @@ bool ls_std::FileOutputStream::write(const ls_std::byte_field &_data)
   }
   else
   {
-    throw ls_std::FileOperationException{};
+    throw ls::FileOperationException{};
   }
 
   return succeeded;
 }
 
-void ls_std::FileOutputStream::_close()
+void ls::FileOutputStream::_close()
 {
   if (this->outputStream.is_open())
   {
@@ -63,11 +63,11 @@ void ls_std::FileOutputStream::_close()
   }
 }
 
-void ls_std::FileOutputStream::_init()
+void ls::FileOutputStream::_init()
 {
   if (!this->file.exists())
   {
-    throw ls_std::FileNotFoundException{};
+    throw ls::FileNotFoundException{};
   }
   else
   {

source/ls_std/io/FileReader.cpp

@@ -12,43 +12,43 @@
 #include <ls_std/core/exception/FileNotFoundException.hpp>
 #include <ls_std/core/exception/FileOperationException.hpp>
 
-ls_std::FileReader::FileReader(ls_std::File &_file)
-    : ls_std::Class("FileReader"),
+ls::FileReader::FileReader(ls::File &_file)
+    : ls::Class("FileReader"),
       file(_file)
 {
-  ls_std::FileReader::_init(_file);
+  ls::FileReader::_init(_file);
 }
 
-ls_std::byte_field ls_std::FileReader::read()
+ls::byte_field ls::FileReader::read()
 {
-  ls_std::byte *data;
+  ls::byte *data;
   std::ifstream inputStream{this->file.getAbsoluteFilePath(), std::ifstream::binary};
   int length = (int) this->file.getSize();
-  data = new ls_std::byte[length];
+  data = new ls::byte[length];
   inputStream.read(data, length);
 
   if (inputStream.fail())
   {
-    throw ls_std::FileOperationException{};
+    throw ls::FileOperationException{};
   }
 
   inputStream.close();
-  ls_std::byte_field readData = ls_std::byte_field{data, (size_t) this->file.getSize()};
+  ls::byte_field readData = ls::byte_field{data, (size_t) this->file.getSize()};
   delete[] data;
 
   return readData;
 }
 
-void ls_std::FileReader::reset(ls_std::File &_file)
+void ls::FileReader::reset(ls::File &_file)
 {
-  ls_std::FileReader::_init(_file);
+  ls::FileReader::_init(_file);
   this->file = _file;
 }
 
-void ls_std::FileReader::_init(ls_std::File &_file)
+void ls::FileReader::_init(ls::File &_file)
 {
   if (!_file.exists())
   {
-    throw ls_std::FileNotFoundException{};
+    throw ls::FileNotFoundException{};
   }
 }

source/ls_std/io/FileWriter.cpp

@@ -12,20 +12,20 @@
 #include <ls_std/core/exception/FileNotFoundException.hpp>
 #include <ls_std/core/exception/FileOperationException.hpp>
 
-ls_std::FileWriter::FileWriter(ls_std::File &_file)
-    : ls_std::Class("FileWriter"),
+ls::FileWriter::FileWriter(ls::File &_file)
+    : ls::Class("FileWriter"),
       file(_file)
 {
-  ls_std::FileWriter::_init(_file);
+  ls::FileWriter::_init(_file);
 }
 
-void ls_std::FileWriter::reset(ls_std::File &_file)
+void ls::FileWriter::reset(ls::File &_file)
 {
-  ls_std::FileWriter::_init(_file);
+  ls::FileWriter::_init(_file);
   this->file = _file;
 }
 
-bool ls_std::FileWriter::write(const ls_std::byte_field &_data)
+bool ls::FileWriter::write(const ls::byte_field &_data)
 {
   std::ofstream outputStream{};
   outputStream.open(this->file.getAbsoluteFilePath());
@@ -34,10 +34,10 @@ bool ls_std::FileWriter::write(const ls_std::byte_field &_data)
   return !outputStream.fail();
 }
 
-void ls_std::FileWriter::_init(ls_std::File &_file)
+void ls::FileWriter::_init(ls::File &_file)
 {
   if (!_file.exists())
   {
-    throw ls_std::FileNotFoundException{};
+    throw ls::FileNotFoundException{};
   }
 }

source/ls_std/io/StandardOutputWriter.cpp

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

source/ls_std/io/StorableFile.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2021-04-23
+ * Changed:         2022-05-05
  *
  * */
 
@@ -11,38 +11,38 @@
 #include <ls_std/io/FileReader.hpp>
 #include <ls_std/io/FileWriter.hpp>
 
-ls_std::StorableFile::StorableFile(const std::string &_path)
+ls::StorableFile::StorableFile(const std::string &_path)
 {
   this->_init(_path);
 }
 
-std::shared_ptr<ls_std::File> ls_std::StorableFile::getFile()
+std::shared_ptr<ls::File> ls::StorableFile::getFile()
 {
   return this->file;
 }
 
-ls_std::byte_field ls_std::StorableFile::load()
+ls::byte_field ls::StorableFile::load()
 {
-  ls_std::FileReader reader{*this->file};
+  ls::FileReader reader{*this->file};
   return reader.read();
 }
 
-void ls_std::StorableFile::reset(const std::string &_path)
+void ls::StorableFile::reset(const std::string &_path)
 {
   this->_init(_path);
 }
 
-void ls_std::StorableFile::save(const ls_std::byte_field &_data)
+void ls::StorableFile::save(const ls::byte_field &_data)
 {
-  ls_std::FileWriter writer{*this->file};
+  ls::FileWriter writer{*this->file};
   writer.write(_data);
 }
 
-void ls_std::StorableFile::_init(const std::string &_path)
+void ls::StorableFile::_init(const std::string &_path)
 {
   if (this->file == nullptr)
   {
-    this->file = std::make_shared<ls_std::File>(_path);
+    this->file = std::make_shared<ls::File>(_path);
   }
   else
   {

source/ls_std/io/kv/KvDocument.cpp

@@ -3,49 +3,49 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2021-07-15
+ * Changed:         2022-05-05
  *
  * */
 
 #include <ls_std/io/kv/KvDocument.hpp>
 
-ls_std::KvDocument::KvDocument() : ls_std::Class("KvDocument")
+ls::KvDocument::KvDocument() : ls::Class("KvDocument")
 {}
 
-bool ls_std::KvDocument::addPair(ls_std::KvPair _pair)
+bool ls::KvDocument::addPair(ls::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::kv_key, ls::KvPair> pair = std::make_pair(_pair.getKey(), _pair);
     added = this->pairs.insert(pair).second;
   }
 
   return added;
 }
 
-void ls_std::KvDocument::clear()
+void ls::KvDocument::clear()
 {
   this->pairs.clear();
 }
 
-std::map<ls_std::kv_key, ls_std::KvPair> ls_std::KvDocument::getPairs()
+std::map<ls::kv_key, ls::KvPair> ls::KvDocument::getPairs()
 {
   return this->pairs;
 }
 
-bool ls_std::KvDocument::hasPair(const ls_std::kv_key &_key)
+bool ls::KvDocument::hasPair(const ls::kv_key &_key)
 {
   return this->_hasPair(_key);
 }
 
-bool ls_std::KvDocument::removePair(const ls_std::kv_key &_key)
+bool ls::KvDocument::removePair(const ls::kv_key &_key)
 {
   return this->pairs.erase(_key) == 1;
 }
 
-bool ls_std::KvDocument::_hasPair(const ls_std::kv_key &_key)
+bool ls::KvDocument::_hasPair(const ls::kv_key &_key)
 {
   return this->pairs.find(_key) != this->pairs.end();
 }

source/ls_std/io/kv/KvFileReader.cpp

@@ -12,52 +12,52 @@
 #include <ls_std/io/FileReader.hpp>
 #include <ls_std/io/kv/KvParser.hpp>
 
-ls_std::KvFileReader::KvFileReader(const std::shared_ptr<ls_std::KvDocument> &_document, const std::string &_absolutePath)
-    : ls_std::Class("KvFileReader"),
-      kvFile(ls_std::File{""})
+ls::KvFileReader::KvFileReader(const std::shared_ptr<ls::KvDocument> &_document, const std::string &_absolutePath)
+    : ls::Class("KvFileReader"),
+      kvFile(ls::File{""})
 {
   this->_assignDocument(_document);
-  this->_assignFile(ls_std::File{_absolutePath});
+  this->_assignFile(ls::File{_absolutePath});
 }
 
-ls_std::byte_field ls_std::KvFileReader::read()
+ls::byte_field ls::KvFileReader::read()
 {
-  ls_std::byte_field data = ls_std::FileReader{this->kvFile}.read();
-  ls_std::KvParser{this->document}.parse(data);
+  ls::byte_field data = ls::FileReader{this->kvFile}.read();
+  ls::KvParser{this->document}.parse(data);
 
   return data;
 }
 
-std::shared_ptr<ls_std::KvDocument> ls_std::KvFileReader::getDocument()
+std::shared_ptr<ls::KvDocument> ls::KvFileReader::getDocument()
 {
   return this->document;
 }
 
-void ls_std::KvFileReader::setDocument(const std::shared_ptr<ls_std::KvDocument> &_document)
+void ls::KvFileReader::setDocument(const std::shared_ptr<ls::KvDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-void ls_std::KvFileReader::setFile(const ls_std::File &_kvFile)
+void ls::KvFileReader::setFile(const ls::File &_kvFile)
 {
   this->_assignFile(_kvFile);
 }
 
-void ls_std::KvFileReader::_assignDocument(const std::shared_ptr<ls_std::KvDocument> &_document)
+void ls::KvFileReader::_assignDocument(const std::shared_ptr<ls::KvDocument> &_document)
 {
   if (_document == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->document = _document;
 }
 
-void ls_std::KvFileReader::_assignFile(ls_std::File _kvFile)
+void ls::KvFileReader::_assignFile(ls::File _kvFile)
 {
   if (!_kvFile.exists())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->kvFile = _kvFile;

source/ls_std/io/kv/KvPair.cpp

@@ -10,33 +10,33 @@
 #include <ls_std/io/kv/KvPair.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::KvPair::KvPair(const ls_std::kv_key &_key, ls_std::kv_value _value)
-    : ls_std::Class("KvPair"),
+ls::KvPair::KvPair(const ls::kv_key &_key, ls::kv_value _value)
+    : ls::Class("KvPair"),
       value(std::move(_value))
 {
   this->_assignKey(_key);
 }
 
-ls_std::kv_key ls_std::KvPair::getKey()
+ls::kv_key ls::KvPair::getKey()
 {
   return this->key;
 }
 
-ls_std::kv_value ls_std::KvPair::getValue()
+ls::kv_value ls::KvPair::getValue()
 {
   return this->value;
 }
 
-void ls_std::KvPair::setValue(const ls_std::kv_value &_value)
+void ls::KvPair::setValue(const ls::kv_value &_value)
 {
   this->value = _value;
 }
 
-void ls_std::KvPair::_assignKey(const ls_std::kv_key &_key)
+void ls::KvPair::_assignKey(const ls::kv_key &_key)
 {
   if (_key.empty())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->key = _key;

source/ls_std/io/kv/KvParser.cpp

@@ -11,78 +11,78 @@
 #include <ls_std/io/NewLine.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::KvParser::KvParser(const std::shared_ptr<ls_std::KvDocument> &_document) : ls_std::Class("KvParser")
+ls::KvParser::KvParser(const std::shared_ptr<ls::KvDocument> &_document) : ls::Class("KvParser")
 {
   this->_assignDocument(_document);
 }
 
-std::shared_ptr<ls_std::KvDocument> ls_std::KvParser::getDocument()
+std::shared_ptr<ls::KvDocument> ls::KvParser::getDocument()
 {
   return this->document;
 }
 
-void ls_std::KvParser::parse(const ls_std::byte_field &_data)
+void ls::KvParser::parse(const ls::byte_field &_data)
 {
   this->_parse(_data);
 }
 
-void ls_std::KvParser::setDocument(const std::shared_ptr<ls_std::KvDocument> &_document)
+void ls::KvParser::setDocument(const std::shared_ptr<ls::KvDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-void ls_std::KvParser::_assignDocument(const std::shared_ptr<ls_std::KvDocument> &_document)
+void ls::KvParser::_assignDocument(const std::shared_ptr<ls::KvDocument> &_document)
 {
   if (_document == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->document = _document;
 }
 
-bool ls_std::KvParser::_lineHasPair(ls_std::KvParseParameter _parseParameter)
+bool ls::KvParser::_lineHasPair(ls::KvParseParameter _parseParameter)
 {
   return _parseParameter.line.contains("=") && _parseParameter.line.contains(";");
 }
 
-void ls_std::KvParser::_parse(const ls_std::byte_field &_data)
+void ls::KvParser::_parse(const ls::byte_field &_data)
 {
   for (std::string::size_type index = 0; index < _data.size(); index++)
   {
-    ls_std::KvParseParameter parseParameter = ls_std::KvParser::_readLine(_data, index);
+    ls::KvParseParameter parseParameter = ls::KvParser::_readLine(_data, index);
     this->_parsePair(parseParameter);
     index = parseParameter.index;
   }
 }
 
-void ls_std::KvParser::_parsePair(ls_std::KvParseParameter _parseParameter)
+void ls::KvParser::_parsePair(ls::KvParseParameter _parseParameter)
 {
-  if (ls_std::KvParser::_lineHasPair(_parseParameter))
+  if (ls::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);
+    ls::kv_key key = _parseParameter.line.toString().substr(0, equalSignPosition);
+    ls::kv_value value = _parseParameter.line.toString().substr(equalSignPosition + 1);
     value = value.substr(0, value.find(';'));
 
-    this->document->addPair(ls_std::KvPair{key, value});
+    this->document->addPair(ls::KvPair{key, value});
   }
 }
 
-ls_std::KvParseParameter ls_std::KvParser::_readLine(const ls_std::byte_field &_data, std::string::size_type _index)
+ls::KvParseParameter ls::KvParser::_readLine(const ls::byte_field &_data, std::string::size_type _index)
 {
-  ls_std::KvParseParameter parseParameter{};
+  ls::KvParseParameter parseParameter{};
   parseParameter.line = _data.substr(_index);
 
-  if (parseParameter.line.contains(ls_std::NewLine::getWindowsNewLine()))
+  if (parseParameter.line.contains(ls::NewLine::getWindowsNewLine()))
   {
-    ls_std::KvParser::_readLineWithWindowsLineBreak(parseParameter);
+    ls::KvParser::_readLineWithWindowsLineBreak(parseParameter);
   }
   else
   {
-    if (parseParameter.line.contains(ls_std::NewLine::getUnixNewLine()))
+    if (parseParameter.line.contains(ls::NewLine::getUnixNewLine()))
     {
-      ls_std::KvParser::_readLineWithUnixLineBreak(parseParameter);
+      ls::KvParser::_readLineWithUnixLineBreak(parseParameter);
     }
   }
 
@@ -90,14 +90,14 @@ ls_std::KvParseParameter ls_std::KvParser::_readLine(const ls_std::byte_field &_
   return parseParameter;
 }
 
-void ls_std::KvParser::_readLineWithUnixLineBreak(ls_std::KvParseParameter &_parseParameter)
+void ls::KvParser::_readLineWithUnixLineBreak(ls::KvParseParameter &_parseParameter)
 {
-  size_t newLinePosition = _parseParameter.line.toString().find(ls_std::NewLine::getUnixNewLine());
+  size_t newLinePosition = _parseParameter.line.toString().find(ls::NewLine::getUnixNewLine());
   _parseParameter.line = _parseParameter.line.toString().substr(0, newLinePosition);
 }
 
-void ls_std::KvParser::_readLineWithWindowsLineBreak(ls_std::KvParseParameter &_parseParameter)
+void ls::KvParser::_readLineWithWindowsLineBreak(ls::KvParseParameter &_parseParameter)
 {
-  size_t newLinePosition = _parseParameter.line.toString().find(ls_std::NewLine::getWindowsNewLine());
+  size_t newLinePosition = _parseParameter.line.toString().find(ls::NewLine::getWindowsNewLine());
   _parseParameter.line = _parseParameter.line.toString().substr(0, newLinePosition + 1);
 }

source/ls_std/io/logging/LogLevel.cpp

@@ -10,60 +10,60 @@
 #include <ls_std/io/logging/LogLevel.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::LogLevel::LogLevel(const ls_std::LogLevelValue &_value)
-    : ls_std::Class("LogLevel"),
+ls::LogLevel::LogLevel(const ls::LogLevelValue &_value)
+    : ls::Class("LogLevel"),
       value(_value)
 {
   this->_init();
 }
 
-ls_std::LogLevel::LogLevel() : ls_std::Class("LogLevel")
+ls::LogLevel::LogLevel() : ls::Class("LogLevel")
 {
   this->_init();
 }
 
-ls_std::LogLevel::operator unsigned char() const
+ls::LogLevel::operator unsigned char() const
 {
   return this->value;
 }
 
-ls_std::LogLevel &ls_std::LogLevel::operator=(const ls_std::LogLevelValue &_value)
+ls::LogLevel &ls::LogLevel::operator=(const ls::LogLevelValue &_value)
 {
   this->value = _value;
   return *this;
 }
 
-bool ls_std::LogLevel::operator<(const ls_std::LogLevelValue &_value)
+bool ls::LogLevel::operator<(const ls::LogLevelValue &_value)
 {
   return this->value < _value;
 }
 
-bool ls_std::LogLevel::operator<=(const ls_std::LogLevelValue &_value)
+bool ls::LogLevel::operator<=(const ls::LogLevelValue &_value)
 {
   return this->value <= _value;
 }
 
-bool ls_std::LogLevel::operator>(const ls_std::LogLevelValue &_value)
+bool ls::LogLevel::operator>(const ls::LogLevelValue &_value)
 {
   return this->value > _value;
 }
 
-bool ls_std::LogLevel::operator>=(const ls_std::LogLevelValue &_value)
+bool ls::LogLevel::operator>=(const ls::LogLevelValue &_value)
 {
   return this->value >= _value;
 }
 
-bool ls_std::LogLevel::operator==(const ls_std::LogLevelValue &_value)
+bool ls::LogLevel::operator==(const ls::LogLevelValue &_value)
 {
   return this->value == _value;
 }
 
-void ls_std::LogLevel::setLogLevel(const ls_std::LogLevelValue &_value)
+void ls::LogLevel::setLogLevel(const ls::LogLevelValue &_value)
 {
   this->value = _value;
 }
 
-void ls_std::LogLevel::setLogLevel(const std::string &_value)
+void ls::LogLevel::setLogLevel(const std::string &_value)
 {
   if (this->_isValidLogLevelString(_value))
   {
@@ -71,24 +71,24 @@ void ls_std::LogLevel::setLogLevel(const std::string &_value)
   }
   else
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 }
 
-std::string ls_std::LogLevel::toString() const
+std::string ls::LogLevel::toString() const
 {
   return this->level.at(this->value);
 }
 
-ls_std::LogLevelValue ls_std::LogLevel::_getValueFromString(const std::string &_value)
+ls::LogLevelValue ls::LogLevel::_getValueFromString(const std::string &_value)
 {
-  ls_std::LogLevelValue logLevelValue{};
+  ls::LogLevelValue logLevelValue{};
 
   for (const auto &logLevelString : this->level)
   {
     if (logLevelString.second == _value)
     {
-      logLevelValue = (ls_std::LogLevelValue) logLevelString.first;
+      logLevelValue = (ls::LogLevelValue) logLevelString.first;
       break;
     }
   }
@@ -96,17 +96,17 @@ ls_std::LogLevelValue ls_std::LogLevel::_getValueFromString(const std::string &_
   return logLevelValue;
 }
 
-void ls_std::LogLevel::_init()
+void ls::LogLevel::_init()
 {
-  this->level.insert({ls_std::LogLevelValue::FATAL, "FATAL"});
-  this->level.insert({ls_std::LogLevelValue::ERR, "ERROR"});
-  this->level.insert({ls_std::LogLevelValue::WARN, "WARN"});
-  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::LogLevelValue::FATAL, "FATAL"});
+  this->level.insert({ls::LogLevelValue::ERR, "ERROR"});
+  this->level.insert({ls::LogLevelValue::WARN, "WARN"});
+  this->level.insert({ls::LogLevelValue::INFO, "INFO"});
+  this->level.insert({ls::LogLevelValue::DEBUG, "DEBUG"});
+  this->level.insert({ls::LogLevelValue::TRACE, "TRACE"});
 }
 
-bool ls_std::LogLevel::_isValidLogLevelString(const std::string &_value)
+bool ls::LogLevel::_isValidLogLevelString(const std::string &_value)
 {
   bool isValidString{};
 

source/ls_std/io/logging/Logger.cpp

@@ -13,84 +13,84 @@
 #include <ls_std/boxing/String.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::Logger::Logger(const std::shared_ptr<ls_std::IWriter> &_writer)
-    : ls_std::Class("Logger"),
-      logLevel(ls_std::LogLevelValue::INFO)
+ls::Logger::Logger(const std::shared_ptr<ls::IWriter> &_writer)
+    : ls::Class("Logger"),
+      logLevel(ls::LogLevelValue::INFO)
 {
   this->_assignWriter(_writer);
 }
 
-void ls_std::Logger::debug(const ls_std::byte *_data)
+void ls::Logger::debug(const ls::byte *_data)
 {
-  if (this->logLevel >= ls_std::LogLevelValue::DEBUG)
+  if (this->logLevel >= ls::LogLevelValue::DEBUG)
   {
-    this->_log(_data, ls_std::LogLevel(ls_std::LogLevelValue::DEBUG));
+    this->_log(_data, ls::LogLevel(ls::LogLevelValue::DEBUG));
   }
 }
 
-void ls_std::Logger::error(const ls_std::byte *_data)
+void ls::Logger::error(const ls::byte *_data)
 {
-  if (this->logLevel >= ls_std::LogLevelValue::ERR)
+  if (this->logLevel >= ls::LogLevelValue::ERR)
   {
-    this->_log(_data, ls_std::LogLevel(ls_std::LogLevelValue::ERR));
+    this->_log(_data, ls::LogLevel(ls::LogLevelValue::ERR));
   }
 }
 
-void ls_std::Logger::fatal(const ls_std::byte *_data)
+void ls::Logger::fatal(const ls::byte *_data)
 {
-  if (this->logLevel >= ls_std::LogLevelValue::FATAL)
+  if (this->logLevel >= ls::LogLevelValue::FATAL)
   {
-    this->_log(_data, ls_std::LogLevel(ls_std::LogLevelValue::FATAL));
+    this->_log(_data, ls::LogLevel(ls::LogLevelValue::FATAL));
   }
 }
 
-ls_std::LogLevel ls_std::Logger::getLogLevel()
+ls::LogLevel ls::Logger::getLogLevel()
 {
   return this->logLevel;
 }
 
-void ls_std::Logger::info(const ls_std::byte *_data)
+void ls::Logger::info(const ls::byte *_data)
 {
-  if (this->logLevel >= ls_std::LogLevelValue::INFO)
+  if (this->logLevel >= ls::LogLevelValue::INFO)
   {
-    this->_log(_data, ls_std::LogLevel(ls_std::LogLevelValue::INFO));
+    this->_log(_data, ls::LogLevel(ls::LogLevelValue::INFO));
   }
 }
 
-void ls_std::Logger::setLogLevel(const ls_std::LogLevelValue &_logLevelValue)
+void ls::Logger::setLogLevel(const ls::LogLevelValue &_logLevelValue)
 {
   this->logLevel = _logLevelValue;
 }
 
-void ls_std::Logger::trace(const ls_std::byte *_data)
+void ls::Logger::trace(const ls::byte *_data)
 {
-  if (this->logLevel >= ls_std::LogLevelValue::TRACE)
+  if (this->logLevel >= ls::LogLevelValue::TRACE)
   {
-    this->_log(_data, ls_std::LogLevel(ls_std::LogLevelValue::TRACE));
+    this->_log(_data, ls::LogLevel(ls::LogLevelValue::TRACE));
   }
 }
 
-void ls_std::Logger::warn(const ls_std::byte *_data)
+void ls::Logger::warn(const ls::byte *_data)
 {
-  if (this->logLevel >= ls_std::LogLevelValue::WARN)
+  if (this->logLevel >= ls::LogLevelValue::WARN)
   {
-    this->_log(_data, ls_std::LogLevel(ls_std::LogLevelValue::WARN));
+    this->_log(_data, ls::LogLevel(ls::LogLevelValue::WARN));
   }
 }
 
-void ls_std::Logger::_assignWriter(const std::shared_ptr<ls_std::IWriter> &_writer)
+void ls::Logger::_assignWriter(const std::shared_ptr<ls::IWriter> &_writer)
 {
   if (_writer == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->writer = _writer;
 }
 
-void ls_std::Logger::_log(const ls_std::byte *_data, const ls_std::LogLevel &_logLevel)
+void ls::Logger::_log(const ls::byte *_data, const ls::LogLevel &_logLevel)
 {
-  ls_std::Date date{};
-  std::string message = "[" + date.toString() + "] " + ls_std::String{_logLevel.toString() + ":"}.padRight(10, ' ') + std::string(_data) + ls_std::NewLine::getUnixNewLine();
+  ls::Date date{};
+  std::string message = "[" + date.toString() + "] " + ls::String{_logLevel.toString() + ":"}.padRight(10, ' ') + std::string(_data) + ls::NewLine::getUnixNewLine();
   this->writer->write(message);
 }

source/ls_std/io/xml/XmlAttribute.cpp

@@ -10,51 +10,51 @@
 #include <ls_std/io/xml/XmlAttribute.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::XmlAttribute::XmlAttribute(const std::string& _name) : ls_std::Class("XmlAttribute")
+ls::XmlAttribute::XmlAttribute(const std::string& _name) : ls::Class("XmlAttribute")
 {
   this->_assignName(_name);
 }
 
-std::string ls_std::XmlAttribute::getName()
+std::string ls::XmlAttribute::getName()
 {
   return this->name;
 }
 
-std::string ls_std::XmlAttribute::getValue()
+std::string ls::XmlAttribute::getValue()
 {
   return this->value;
 }
 
-void ls_std::XmlAttribute::setName(const std::string& _name)
+void ls::XmlAttribute::setName(const std::string& _name)
 {
   this->_assignName(_name);
 }
 
-void ls_std::XmlAttribute::setValue(const std::string& _value)
+void ls::XmlAttribute::setValue(const std::string& _value)
 {
   this->_assignValue(_value);
 }
 
-std::string ls_std::XmlAttribute::toXml()
+std::string ls::XmlAttribute::toXml()
 {
   return this->name + "=\"" + this->value + "\"";
 }
 
-void ls_std::XmlAttribute::_assignName(const std::string &_name)
+void ls::XmlAttribute::_assignName(const std::string &_name)
 {
   if (_name.empty())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->name = _name;
 }
 
-void ls_std::XmlAttribute::_assignValue(const std::string &_value)
+void ls::XmlAttribute::_assignValue(const std::string &_value)
 {
   if (_value.empty())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->value = _value;

source/ls_std/io/xml/XmlDeclaration.cpp

@@ -3,59 +3,59 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-29
- * Changed:         2021-07-16
+ * Changed:         2022-05-05
  *
  * */
 
 #include <ls_std/io/xml/XmlDeclaration.hpp>
 
-ls_std::XmlDeclaration::XmlDeclaration(const std::string& _version) : ls_std::Class("XmlDeclaration")
+ls::XmlDeclaration::XmlDeclaration(const std::string& _version) : ls::Class("XmlDeclaration")
 {
   this->version.setValue(_version);
 }
 
-std::string ls_std::XmlDeclaration::getEncoding()
+std::string ls::XmlDeclaration::getEncoding()
 {
   return this->encoding.getValue();
 }
 
-std::string ls_std::XmlDeclaration::getStandalone()
+std::string ls::XmlDeclaration::getStandalone()
 {
   return this->standalone.getValue();
 }
 
-std::string ls_std::XmlDeclaration::getVersion()
+std::string ls::XmlDeclaration::getVersion()
 {
   return this->version.getValue();
 }
 
-void ls_std::XmlDeclaration::setEncoding(const std::string& _encoding)
+void ls::XmlDeclaration::setEncoding(const std::string& _encoding)
 {
   this->encoding.setValue(_encoding);
 }
 
-void ls_std::XmlDeclaration::setStandalone(const std::string& _standalone)
+void ls::XmlDeclaration::setStandalone(const std::string& _standalone)
 {
   this->standalone.setValue(_standalone);
 }
 
-void ls_std::XmlDeclaration::setVersion(const std::string& _version)
+void ls::XmlDeclaration::setVersion(const std::string& _version)
 {
   this->version.setValue(_version);
 }
 
-std::string ls_std::XmlDeclaration::toXml()
+std::string ls::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);
+  declaration += ls::XmlDeclaration::_toXmlAttribute(this->version);
+  declaration += ls::XmlDeclaration::_toXmlAttribute(this->encoding);
+  declaration += ls::XmlDeclaration::_toXmlAttribute(this->standalone);
 
   return declaration + " ?>";
 }
 
-std::string ls_std::XmlDeclaration::_toXmlAttribute(ls_std::XmlAttribute _attribute)
+std::string ls::XmlDeclaration::_toXmlAttribute(ls::XmlAttribute _attribute)
 {
   std::string xmlString{};
 

source/ls_std/io/xml/XmlDocument.cpp

@@ -10,30 +10,30 @@
 #include <ls_std/io/xml/XmlDocument.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::XmlDocument::XmlDocument() : ls_std::Class("XmlDocument")
+ls::XmlDocument::XmlDocument() : ls::Class("XmlDocument")
 {}
 
-std::shared_ptr<ls_std::XmlDeclaration> ls_std::XmlDocument::getDeclaration()
+std::shared_ptr<ls::XmlDeclaration> ls::XmlDocument::getDeclaration()
 {
   return this->declaration;
 }
 
-std::shared_ptr<ls_std::XmlNode> ls_std::XmlDocument::getRootElement()
+std::shared_ptr<ls::XmlNode> ls::XmlDocument::getRootElement()
 {
   return this->rootElement;
 }
 
-void ls_std::XmlDocument::setDeclaration(const std::shared_ptr<ls_std::XmlDeclaration> &_declaration)
+void ls::XmlDocument::setDeclaration(const std::shared_ptr<ls::XmlDeclaration> &_declaration)
 {
   this->_assignDeclaration(_declaration);
 }
 
-void ls_std::XmlDocument::setRootElement(const std::shared_ptr<ls_std::XmlNode> &_rootElement)
+void ls::XmlDocument::setRootElement(const std::shared_ptr<ls::XmlNode> &_rootElement)
 {
   this->_assignRootElement(_rootElement);
 }
 
-std::string ls_std::XmlDocument::toXml()
+std::string ls::XmlDocument::toXml()
 {
   std::string xmlString{};
 
@@ -50,21 +50,21 @@ std::string ls_std::XmlDocument::toXml()
   return xmlString + this->rootElement->toXml();
 }
 
-void ls_std::XmlDocument::_assignDeclaration(const std::shared_ptr<ls_std::XmlDeclaration> &_declaration)
+void ls::XmlDocument::_assignDeclaration(const std::shared_ptr<ls::XmlDeclaration> &_declaration)
 {
   if (_declaration == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->declaration = _declaration;
 }
 
-void ls_std::XmlDocument::_assignRootElement(const std::shared_ptr<ls_std::XmlNode> &_rootElement)
+void ls::XmlDocument::_assignRootElement(const std::shared_ptr<ls::XmlNode> &_rootElement)
 {
   if (_rootElement == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->rootElement = _rootElement;

source/ls_std/io/xml/XmlNode.cpp

@@ -11,12 +11,12 @@
 #include <ls_std/core/utils/STLUtils.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::XmlNode::XmlNode(std::string _name)
-    : ls_std::Class("XmlNode"),
+ls::XmlNode::XmlNode(std::string _name)
+    : ls::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::XmlNode::addAttributeAfter(const std::shared_ptr<ls::XmlAttribute> &_attribute, const std::string &_name)
 {
   bool added{};
   auto iterator = this->attributes.begin();
@@ -42,7 +42,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::XmlNode::addAttributeBefore(const std::shared_ptr<ls::XmlAttribute> &_attribute, const std::string &_name)
 {
   bool added{};
   auto iterator = this->attributes.begin();
@@ -67,7 +67,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::XmlNode::addAttributeToBeginning(const std::shared_ptr<ls::XmlAttribute> &_attribute)
 {
   bool added{};
   _checkIfAttributeReferenceIsValid(_attribute);
@@ -81,7 +81,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::XmlNode::addAttributeToEnd(const std::shared_ptr<ls::XmlAttribute> &_attribute)
 {
   bool added{};
   _checkIfAttributeReferenceIsValid(_attribute);
@@ -95,7 +95,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::XmlNode::addChildAfter(const std::shared_ptr<ls::XmlNode> &_child, const std::shared_ptr<ls::XmlNode> &_search)
 {
   bool added{};
   auto iterator = this->children.begin();
@@ -121,7 +121,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::XmlNode::addChildBefore(const std::shared_ptr<ls::XmlNode> &_child, const std::shared_ptr<ls::XmlNode> &_search)
 {
   bool added{};
   auto iterator = this->children.begin();
@@ -146,7 +146,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::XmlNode::addChildToBeginning(const std::shared_ptr<ls::XmlNode> &_child)
 {
   bool added{};
   _checkIfNodeReferenceIsValid(_child);
@@ -160,7 +160,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::XmlNode::addChildToEnd(const std::shared_ptr<ls::XmlNode> &_child)
 {
   bool added{};
   _checkIfNodeReferenceIsValid(_child);
@@ -174,24 +174,24 @@ bool ls_std::XmlNode::addChildToEnd(const std::shared_ptr<ls_std::XmlNode> &_chi
   return added;
 }
 
-void ls_std::XmlNode::clearValue()
+void ls::XmlNode::clearValue()
 {
   this->value.clear();
 }
 
-std::list<std::shared_ptr<ls_std::XmlAttribute>> ls_std::XmlNode::getAttributes()
+std::list<std::shared_ptr<ls::XmlAttribute>> ls::XmlNode::getAttributes()
 {
   return this->attributes;
 }
 
-std::list<std::shared_ptr<ls_std::XmlNode>> ls_std::XmlNode::getChildren()
+std::list<std::shared_ptr<ls::XmlNode>> ls::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::XmlNode>> ls::XmlNode::getChildren(const std::string &_name)
 {
-  std::list<std::shared_ptr<ls_std::XmlNode>> childrenWithName{};
+  std::list<std::shared_ptr<ls::XmlNode>> childrenWithName{};
 
   for (const auto &child : this->children)
   {
@@ -204,32 +204,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::XmlNode::getName()
 {
   return this->name;
 }
 
-std::string ls_std::XmlNode::getValue()
+std::string ls::XmlNode::getValue()
 {
   return this->value;
 }
 
-bool ls_std::XmlNode::hasAttribute(const std::string &_name)
+bool ls::XmlNode::hasAttribute(const std::string &_name)
 {
   return this->_hasAttribute(_name);
 }
 
-bool ls_std::XmlNode::hasChild(const std::string &_name)
+bool ls::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::XmlNode::hasChild(const std::shared_ptr<ls::XmlNode> &_child)
 {
   return this->_hasChild(_child);
 }
 
-bool ls_std::XmlNode::removeFirstAttribute()
+bool ls::XmlNode::removeFirstAttribute()
 {
   bool isValidOperation = !this->attributes.empty();
 
@@ -241,7 +241,7 @@ bool ls_std::XmlNode::removeFirstAttribute()
   return isValidOperation;
 }
 
-bool ls_std::XmlNode::removeLastAttribute()
+bool ls::XmlNode::removeLastAttribute()
 {
   bool isValidOperation = !this->attributes.empty();
 
@@ -253,7 +253,7 @@ bool ls_std::XmlNode::removeLastAttribute()
   return isValidOperation;
 }
 
-bool ls_std::XmlNode::removeFirstChild()
+bool ls::XmlNode::removeFirstChild()
 {
   bool isValidOperation = !this->children.empty();
 
@@ -265,7 +265,7 @@ bool ls_std::XmlNode::removeFirstChild()
   return isValidOperation;
 }
 
-bool ls_std::XmlNode::removeLastChild()
+bool ls::XmlNode::removeLastChild()
 {
   bool isValidOperation = !this->children.empty();
 
@@ -277,82 +277,82 @@ bool ls_std::XmlNode::removeLastChild()
   return isValidOperation;
 }
 
-void ls_std::XmlNode::setName(const std::string &_name)
+void ls::XmlNode::setName(const std::string &_name)
 {
   this->_assignName(_name);
 }
 
-void ls_std::XmlNode::setValue(const std::string &_value)
+void ls::XmlNode::setValue(const std::string &_value)
 {
   this->_assignValue(_value);
 }
 
-std::string ls_std::XmlNode::toXml()
+std::string ls::XmlNode::toXml()
 {
   return this->_toXml_(0);
 }
 
-std::string ls_std::XmlNode::_toXml_(uint8_t _tabSize)
+std::string ls::XmlNode::_toXml_(uint8_t _tabSize)
 {
   std::string xmlStream{};
 
-  xmlStream += ls_std::XmlNode::_getTab(_tabSize);
+  xmlStream += ls::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->value.empty() ? ls::XmlNode::_getTab(_tabSize) : "";
   xmlStream += this->_toXmlCloseTag() + "\n";
 
   return xmlStream;
 }
 
-void ls_std::XmlNode::_assignName(const std::string &_name)
+void ls::XmlNode::_assignName(const std::string &_name)
 {
   if (_name.empty())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->name = _name;
 }
 
-void ls_std::XmlNode::_assignValue(const std::string &_value)
+void ls::XmlNode::_assignValue(const std::string &_value)
 {
   if (_value.empty())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->value = _value;
 }
 
-void ls_std::XmlNode::_checkIfAttributeReferenceIsValid(const std::shared_ptr<ls_std::XmlAttribute> &_attribute)
+void ls::XmlNode::_checkIfAttributeReferenceIsValid(const std::shared_ptr<ls::XmlAttribute> &_attribute)
 {
   if (_attribute == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 }
 
-void ls_std::XmlNode::_checkIfNameIsNotEmpty(const std::string &_name)
+void ls::XmlNode::_checkIfNameIsNotEmpty(const std::string &_name)
 {
   if (_name.empty())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 }
 
-void ls_std::XmlNode::_checkIfNodeReferenceIsValid(const std::shared_ptr<ls_std::XmlNode> &_child)
+void ls::XmlNode::_checkIfNodeReferenceIsValid(const std::shared_ptr<ls::XmlNode> &_child)
 {
   if (_child == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 }
 
-std::string ls_std::XmlNode::_getTab(uint8_t _tabSize)
+std::string ls::XmlNode::_getTab(uint8_t _tabSize)
 {
   std::string tab{};
 
@@ -364,13 +364,13 @@ std::string ls_std::XmlNode::_getTab(uint8_t _tabSize)
   return tab;
 }
 
-bool ls_std::XmlNode::_hasAttribute(const std::string &_name)
+bool ls::XmlNode::_hasAttribute(const std::string &_name)
 {
   bool exists{};
 
   if (_name.empty())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
   else
   {
@@ -387,19 +387,19 @@ 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::XmlNode::_hasChild(const std::shared_ptr<ls::XmlNode> &_child)
 {
   _checkIfNodeReferenceIsValid(_child);
-  return ls_std::STLUtils::contains(this->children, _child);
+  return ls::STLUtils::contains(this->children, _child);
 }
 
-bool ls_std::XmlNode::_hasChild(const std::string &_name)
+bool ls::XmlNode::_hasChild(const std::string &_name)
 {
   bool exists{};
 
   if (_name.empty())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
   else
   {
@@ -416,7 +416,7 @@ bool ls_std::XmlNode::_hasChild(const std::string &_name)
   return exists;
 }
 
-std::string ls_std::XmlNode::_toXmlAttributes()
+std::string ls::XmlNode::_toXmlAttributes()
 {
   std::string stream{};
 
@@ -428,7 +428,7 @@ std::string ls_std::XmlNode::_toXmlAttributes()
   return stream;
 }
 
-std::string ls_std::XmlNode::_toXmlChildren(uint8_t _tabSize)
+std::string ls::XmlNode::_toXmlChildren(uint8_t _tabSize)
 {
   std::string stream{};
 
@@ -443,7 +443,7 @@ std::string ls_std::XmlNode::_toXmlChildren(uint8_t _tabSize)
   return stream;
 }
 
-std::string ls_std::XmlNode::_toXmlCloseTag()
+std::string ls::XmlNode::_toXmlCloseTag()
 {
   std::string stream{};
 
@@ -455,12 +455,12 @@ std::string ls_std::XmlNode::_toXmlCloseTag()
   return stream;
 }
 
-std::string ls_std::XmlNode::_toXmlOpenTag()
+std::string ls::XmlNode::_toXmlOpenTag()
 {
   return "<" + this->name;
 }
 
-std::string ls_std::XmlNode::_toXmlOpenTagClose()
+std::string ls::XmlNode::_toXmlOpenTagClose()
 {
   std::string stream{};
 
@@ -476,7 +476,7 @@ std::string ls_std::XmlNode::_toXmlOpenTagClose()
   return stream;
 }
 
-std::string ls_std::XmlNode::_toXmlValue()
+std::string ls::XmlNode::_toXmlValue()
 {
   return this->value.empty() ? "\n" : this->value;
 }

source/ls_std/io/xml/XmlParser.cpp

@@ -11,40 +11,40 @@
 #include <ls_std/core/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::XmlParser::XmlParser(const std::shared_ptr<ls::XmlDocument> &_document) : ls::Class("XmlParser")
 {
   this->_assignDocument(_document);
   this->_reset();
 }
 
-std::shared_ptr<ls_std::XmlDocument> ls_std::XmlParser::getDocument()
+std::shared_ptr<ls::XmlDocument> ls::XmlParser::getDocument()
 {
   return this->document;
 }
 
-void ls_std::XmlParser::parse(const ls_std::byte_field &_data)
+void ls::XmlParser::parse(const ls::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::XmlParser::setDocument(const std::shared_ptr<ls::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::XmlParser::_readAttribute_(const ls::byte_field &_data)
 {
-  return ls_std::XmlParser::_parseAttribute(_data);
+  return ls::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::XmlParser::_readAttributes_(ls::byte_field _data)
 {
-  return ls_std::XmlParser::_parseAttributes(std::move(_data));
+  return ls::XmlParser::_parseAttributes(std::move(_data));
 }
 
-void ls_std::XmlParser::_analyze(const ls_std::byte_field &_data, std::string::size_type _index)
+void ls::XmlParser::_analyze(const ls::byte_field &_data, std::string::size_type _index)
 {
   this->_isDeclaration(_data, _index);
   this->_isClosingTag(_data, _index);
@@ -52,34 +52,34 @@ 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::XmlParser::_assignDocument(const std::shared_ptr<ls::XmlDocument> &_document)
 {
   if (_document == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   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::XmlDeclaration> ls::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::XmlDeclaration> declaration = std::make_shared<ls::XmlDeclaration>("1.0");
+  std::pair<std::string, std::string> attribute = ls::XmlParser::_findAttribute(_attributes, "version");
 
   if (!attribute.first.empty())
   {
     declaration->setVersion(attribute.second);
   }
 
-  attribute = ls_std::XmlParser::_findAttribute(_attributes, "encoding");
+  attribute = ls::XmlParser::_findAttribute(_attributes, "encoding");
 
   if (!attribute.first.empty())
   {
     declaration->setEncoding(attribute.second);
   }
 
-  attribute = ls_std::XmlParser::_findAttribute(_attributes, "standalone");
+  attribute = ls::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::XmlNode> ls::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::XmlNode> node = std::make_shared<ls::XmlNode>(_name);
+  std::shared_ptr<ls::XmlAttribute> attribute{};
 
   for (const auto &parsedAttribute : _attributes)
   {
-    attribute = std::make_shared<ls_std::XmlAttribute>(parsedAttribute.first);
+    attribute = std::make_shared<ls::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::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::XmlParser::_findAttributeEndPosition(const ls::byte_field &_data)
 {
   std::string::size_type position = std::string::npos;
   std::string::size_type counter{};
@@ -143,9 +143,9 @@ 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::byte_field ls::XmlParser::_getNextTagString(const ls::byte_field &_data, std::string::size_type _index)
 {
-  ls_std::byte_field tag{};
+  ls::byte_field tag{};
   size_t closingCharacterPosition = _index + _data.substr(_index).find('>');
 
   if (closingCharacterPosition != std::string::npos)
@@ -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::XmlParser::_isClosingTag(const ls::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::XmlParser::_isDeclaration(const ls::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::XmlParser::_isOpeningTag(const ls::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::XmlParser::_isValue(const ls::byte_field &_data, std::string::size_type _index)
 {
   if (this->mode == XML_PARSE_MODE_ANALYZE)
   {
@@ -189,7 +189,7 @@ void ls_std::XmlParser::_isValue(const ls_std::byte_field &_data, std::string::s
 
     if (isValue)
     {
-      ls_std::String value{_data.substr(_index, end)};
+      ls::String value{_data.substr(_index, end)};
 
       if (!value.contains("\n") && !value.contains("\r\n"))
       {
@@ -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::XmlParser::_mergeNodes()
 {
   while (this->maxLevel > 1)
   {
@@ -210,7 +210,7 @@ void ls_std::XmlParser::_mergeNodes()
   this->document->setRootElement(this->parseParameters.front().node);
 }
 
-void ls_std::XmlParser::_mergeChildrenToParentNode(const std::shared_ptr<ls_std::XmlNode> &_parent, std::list<ls_std::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel)
+void ls::XmlParser::_mergeChildrenToParentNode(const std::shared_ptr<ls::XmlNode> &_parent, std::list<ls::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel)
 {
   do
   {
@@ -230,7 +230,7 @@ void ls_std::XmlParser::_mergeChildrenToParentNode(const std::shared_ptr<ls_std:
   } while (_iterator->level > _parentLevel);
 }
 
-void ls_std::XmlParser::_mergeNodesOnCurrentLevel()
+void ls::XmlParser::_mergeNodesOnCurrentLevel()
 {
   auto iterator = this->parseParameters.begin();
   uint8_t parentLevel = this->maxLevel - 1;
@@ -248,7 +248,7 @@ void ls_std::XmlParser::_mergeNodesOnCurrentLevel()
   }
 }
 
-void ls_std::XmlParser::_parse(const ls_std::byte_field &_data)
+void ls::XmlParser::_parse(const ls::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::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::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::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::XmlParser::_parseAttribute(const ls::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::XmlParser::_parseAttributes(ls::byte_field _data)
 {
   std::list<std::pair<std::string, std::string>> attributes{};
   size_t position = _data.find(' ');
@@ -314,49 +314,49 @@ std::list<std::pair<std::string, std::string>> ls_std::XmlParser::_parseAttribut
       position = _data.find(' ') + 1;
     } while (_data[position] == ' ');
 
-    if (_data.size() <= 3 && ls_std::String{_data}.endsWith(">"))
+    if (_data.size() <= 3 && ls::String{_data}.endsWith(">"))
     {
       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::XmlParser::_findAttributeEndPosition(_data) + 1);
+    attributes.push_back(ls::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::XmlParser::_parseClosingTag(const ls::byte_field &_data, std::string::size_type _index)
 {
-  std::string tagString = ls_std::XmlParser::_getNextTagString(_data, _index);
+  std::string tagString = ls::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::XmlParser::_parseDeclaration(const ls::byte_field &_data, std::string::size_type _index)
 {
-  std::string tagString = ls_std::XmlParser::_getNextTagString(_data, _index);
+  std::string tagString = ls::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::XmlDeclaration> declaration = this->_createDeclaration(ls::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::XmlParser::_parseOpeningTag(const ls::byte_field &_data, std::string::size_type _index)
 {
-  ls_std::String tagString{ls_std::XmlParser::_getNextTagString(_data, _index)};
+  ls::String tagString{ls::XmlParser::_getNextTagString(_data, _index)};
   bool isValidTagString = !tagString.toString().empty();
-  ls_std::XmlParseParameter singleParseParameter{};
+  ls::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::XmlNode> node = ls::XmlParser::_createNode(ls::XmlParser::_parseAttributes(tagString), ls::XmlParser::_parseTagName(tagString));
 
     singleParseParameter.level = this->currentLevel;
     singleParseParameter.node = node;
@@ -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::byte_field ls::XmlParser::_parseTagName(const ls::byte_field &_data)
 {
   std::string::size_type position = _data.find(' ');
 
@@ -384,15 +384,15 @@ 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::XmlParser::_parseValue(const ls::byte_field &_data, std::string::size_type _index)
 {
-  ls_std::byte_field value = _data.substr(_index, _data.substr(_index).find('<'));
+  ls::byte_field value = _data.substr(_index, _data.substr(_index).find('<'));
   this->parseParameters.back().node->setValue(value);
 
   return _index + (value.size() - 1);
 }
 
-void ls_std::XmlParser::_reset()
+void ls::XmlParser::_reset()
 {
   this->currentLevel = 1;
   this->maxLevel = 1;
@@ -400,7 +400,7 @@ void ls_std::XmlParser::_reset()
   this->parseParameters.clear();
 }
 
-void ls_std::XmlParser::_setMaxLevel()
+void ls::XmlParser::_setMaxLevel()
 {
   if (this->currentLevel > this->maxLevel)
   {

source/ls_std/io/xml/XmlReader.cpp

@@ -13,52 +13,52 @@
 #include <ls_std/boxing/String.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"),
-      xmlFile(ls_std::File{""})
+ls::XmlReader::XmlReader(const std::shared_ptr<ls::XmlDocument> &_document, const std::string &_absolutePath)
+    : ls::Class("XmlReader"),
+      xmlFile(ls::File{""})
 {
   this->_assignDocument(_document);
-  this->_assignFile(ls_std::File{_absolutePath});
+  this->_assignFile(ls::File{_absolutePath});
 }
 
-ls_std::byte_field ls_std::XmlReader::read()
+ls::byte_field ls::XmlReader::read()
 {
-  ls_std::byte_field data = ls_std::FileReader{this->xmlFile}.read();
-  ls_std::XmlParser{this->document}.parse(data);
+  ls::byte_field data = ls::FileReader{this->xmlFile}.read();
+  ls::XmlParser{this->document}.parse(data);
 
   return data;
 }
 
-std::shared_ptr<ls_std::XmlDocument> ls_std::XmlReader::getDocument()
+std::shared_ptr<ls::XmlDocument> ls::XmlReader::getDocument()
 {
   return this->document;
 }
 
-void ls_std::XmlReader::setDocument(const std::shared_ptr<ls_std::XmlDocument> &_document)
+void ls::XmlReader::setDocument(const std::shared_ptr<ls::XmlDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-void ls_std::XmlReader::setFile(const ls_std::File &_xmlFile)
+void ls::XmlReader::setFile(const ls::File &_xmlFile)
 {
   this->_assignFile(_xmlFile);
 }
 
-void ls_std::XmlReader::_assignDocument(const std::shared_ptr<ls_std::XmlDocument> &_document)
+void ls::XmlReader::_assignDocument(const std::shared_ptr<ls::XmlDocument> &_document)
 {
   if (_document == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->document = _document;
 }
 
-void ls_std::XmlReader::_assignFile(ls_std::File _xmlFile)
+void ls::XmlReader::_assignFile(ls::File _xmlFile)
 {
   if (!_xmlFile.exists())
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
 
   this->xmlFile = _xmlFile;

source/ls_std/logic/Narrator.cpp

@@ -11,20 +11,20 @@
 #include <ls_std/logic/Narrator.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls_std::Narrator::Narrator() : ls_std::Class("Narrator")
+ls::Narrator::Narrator() : ls::Class("Narrator")
 {}
 
-bool ls_std::Narrator::addListener(const std::shared_ptr<ls_std::IListener> &_listener)
+bool ls::Narrator::addListener(const std::shared_ptr<ls::IListener> &_listener)
 {
   bool wasAdded{};
 
   if (_listener == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
   else
   {
-    if (!ls_std::STLUtils::contains(this->listeners, _listener))
+    if (!ls::STLUtils::contains(this->listeners, _listener))
     {
       this->listeners.push_back(_listener);
       wasAdded = true;
@@ -34,27 +34,27 @@ bool ls_std::Narrator::addListener(const std::shared_ptr<ls_std::IListener> &_li
   return wasAdded;
 }
 
-void ls_std::Narrator::clear()
+void ls::Narrator::clear()
 {
   this->listeners.clear();
 }
 
-std::list<std::shared_ptr<ls_std::IListener>> ls_std::Narrator::getListeners()
+std::list<std::shared_ptr<ls::IListener>> ls::Narrator::getListeners()
 {
   return this->listeners;
 }
 
-bool ls_std::Narrator::removeListener(const std::shared_ptr<ls_std::IListener> &_listener)
+bool ls::Narrator::removeListener(const std::shared_ptr<ls::IListener> &_listener)
 {
   bool wasRemoved{};
 
   if (_listener == nullptr)
   {
-    throw ls_std::IllegalArgumentException{};
+    throw ls::IllegalArgumentException{};
   }
   else
   {
-    if (ls_std::STLUtils::contains(this->listeners, _listener))
+    if (ls::STLUtils::contains(this->listeners, _listener))
     {
       this->listeners.remove(_listener);
       wasRemoved = true;
@@ -64,7 +64,7 @@ bool ls_std::Narrator::removeListener(const std::shared_ptr<ls_std::IListener> &
   return wasRemoved;
 }
 
-void ls_std::Narrator::tell(const ls_std::Class &_info)
+void ls::Narrator::tell(const ls::Class &_info)
 {
   for (const auto &listener : this->listeners)
   {