Fix ls::std::boxing dependencies

include/ls_std/boxing/Integer.hpp

@@ -18,94 +18,100 @@
 
 namespace ls
 {
-  class Integer : public ls::Class, public ls::std::boxing::IBoxing
+  namespace std
   {
-    public:
-
-      explicit Integer(int _value);
-      Integer();
-      ~Integer() override = default;
-
-      // conversion operator
-
-      operator int() const;
-
-      // assignment operators
-
-      ls::Integer &operator=(int _value);
-
-      // arithmetic operators
-
-      int operator-() const;
-      int operator+(const ls::Integer &_integer) const;
-      int operator+(int _value) const;
-      int operator*(const ls::Integer &_integer) const;
-      int operator*(int _value) const;
-      int operator-(const ls::Integer &_integer) const;
-      int operator-(int _value) const;
-      int operator/(const ls::Integer &_integer) const;
-      int operator/(int _value) const;
-      int operator%(const ls::Integer &_integer) const;
-      int operator%(int _value) const;
-
-      // compound operators
-
-      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::Integer &_integer) const;
-      bool operator==(int _value) const;
-      bool operator!=(const ls::Integer &_integer) const;
-      bool operator!=(int _value) const;
-      bool operator>(const ls::Integer &_integer) const;
-      bool operator>(int _value) const;
-      bool operator>=(const ls::Integer &_integer) const;
-      bool operator>=(int _value) const;
-      bool operator<(const ls::Integer &_integer) const;
-      bool operator<(int _value) const;
-      bool operator<=(const ls::Integer &_integer) const;
-      bool operator<=(int _value) const;
-
-      // logical operators
-
-      friend bool operator!(const ls::Integer &_integer)
+    namespace boxing
+    {
+      class Integer : public ls::Class, public ls::std::boxing::IBoxing
       {
-        return !_integer.value;
-      }
+        public:
 
-      bool operator&&(const ls::Integer &_integer) const;
-      bool operator&&(int _value) const;
-      bool operator&&(bool _expression) const;
-      bool operator||(const ls::Integer &_integer) const;
-      bool operator||(int _value) const;
-      bool operator||(bool _expression) const;
+          explicit Integer(int _value);
+          Integer();
+          ~Integer() override = default;
 
-      // increment / decrement operator
+          // conversion operator
 
-      void operator++();
-      void operator--();
+          operator int() const;
 
-      // implementation
+          // assignment operators
 
-      void parse(::std::string _parseText) override;
-      ::std::string toString() override;
+          ls::std::boxing::Integer &operator=(int _value);
 
-      // additional functionality
+          // arithmetic operators
 
-      int getValue() const;
+          int operator-() const;
+          int operator+(const ls::std::boxing::Integer &_integer) const;
+          int operator+(int _value) const;
+          int operator*(const ls::std::boxing::Integer &_integer) const;
+          int operator*(int _value) const;
+          int operator-(const ls::std::boxing::Integer &_integer) const;
+          int operator-(int _value) const;
+          int operator/(const ls::std::boxing::Integer &_integer) const;
+          int operator/(int _value) const;
+          int operator%(const ls::std::boxing::Integer &_integer) const;
+          int operator%(int _value) const;
 
-    private:
+          // compound operators
 
-      int value{};
-  };
+          ls::std::boxing::Integer &operator+=(const ls::std::boxing::Integer &_integer);
+          ls::std::boxing::Integer &operator+=(int _value);
+          ls::std::boxing::Integer &operator-=(const ls::std::boxing::Integer &_integer);
+          ls::std::boxing::Integer &operator-=(int _value);
+          ls::std::boxing::Integer &operator*=(const ls::std::boxing::Integer &_integer);
+          ls::std::boxing::Integer &operator*=(int _value);
+          ls::std::boxing::Integer &operator/=(const ls::std::boxing::Integer &_integer);
+          ls::std::boxing::Integer &operator/=(int _value);
+
+          // comparison operators
+
+          bool operator==(const ls::std::boxing::Integer &_integer) const;
+          bool operator==(int _value) const;
+          bool operator!=(const ls::std::boxing::Integer &_integer) const;
+          bool operator!=(int _value) const;
+          bool operator>(const ls::std::boxing::Integer &_integer) const;
+          bool operator>(int _value) const;
+          bool operator>=(const ls::std::boxing::Integer &_integer) const;
+          bool operator>=(int _value) const;
+          bool operator<(const ls::std::boxing::Integer &_integer) const;
+          bool operator<(int _value) const;
+          bool operator<=(const ls::std::boxing::Integer &_integer) const;
+          bool operator<=(int _value) const;
+
+          // logical operators
+
+          friend bool operator!(const ls::std::boxing::Integer &_integer)
+          {
+            return !_integer.value;
+          }
+
+          bool operator&&(const ls::std::boxing::Integer &_integer) const;
+          bool operator&&(int _value) const;
+          bool operator&&(bool _expression) const;
+          bool operator||(const ls::std::boxing::Integer &_integer) const;
+          bool operator||(int _value) const;
+          bool operator||(bool _expression) const;
+
+          // increment / decrement operator
+
+          void operator++();
+          void operator--();
+
+          // implementation
+
+          void parse(::std::string _parseText) override;
+          ::std::string toString() override;
+
+          // additional functionality
+
+          int getValue() const;
+
+        private:
+
+          int value{};
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/boxing/Long.hpp

@@ -19,94 +19,100 @@
 
 namespace ls
 {
-  class Long : public ls::Class, public ls::std::boxing::IBoxing
+  namespace std
   {
-    public:
-
-      explicit Long(ls::long_type _value);
-      Long();
-      ~Long() override = default;
-
-      // conversion operator
-
-      operator ls::long_type() const;
-
-      // assignment operators
-
-      ls::Long &operator=(ls::long_type _value);
-
-      // arithmetic operators
-
-      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::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::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::Long &_long)
+    namespace boxing
+    {
+      class Long : public ls::Class, public ls::std::boxing::IBoxing
       {
-        return !_long.value;
-      }
+        public:
 
-      bool operator&&(const ls::Long &_long) const;
-      bool operator&&(ls::long_type _value) const;
-      bool operator&&(bool _expression) const;
-      bool operator||(const ls::Long &_long) const;
-      bool operator||(ls::long_type _value) const;
-      bool operator||(bool _expression) const;
+          explicit Long(ls::long_type _value);
+          Long();
+          ~Long() override = default;
 
-      // increment / decrement operator
+          // conversion operator
 
-      void operator++();
-      void operator--();
+          operator ls::long_type() const;
 
-      // implementation
+          // assignment operators
 
-      void parse(::std::string _parseText) override;
-      ::std::string toString() override;
+          ls::std::boxing::Long &operator=(ls::long_type _value);
 
-      // additional functionality
+          // arithmetic operators
 
-      ls::long_type getValue() const;
+          ls::long_type operator-() const;
+          ls::long_type operator+(const ls::std::boxing::Long &_long) const;
+          ls::long_type operator+(ls::long_type _value) const;
+          ls::long_type operator*(const ls::std::boxing::Long &_long) const;
+          ls::long_type operator*(ls::long_type _value) const;
+          ls::long_type operator-(const ls::std::boxing::Long &_long) const;
+          ls::long_type operator-(ls::long_type _value) const;
+          ls::long_type operator/(const ls::std::boxing::Long &_long) const;
+          ls::long_type operator/(ls::long_type _value) const;
+          ls::long_type operator%(const ls::std::boxing::Long &_long) const;
+          ls::long_type operator%(ls::long_type _value) const;
 
-    private:
+          // compound operators
 
-      ls::long_type value{};
-  };
+          ls::std::boxing::Long &operator+=(const ls::std::boxing::Long &_long);
+          ls::std::boxing::Long &operator+=(ls::long_type _value);
+          ls::std::boxing::Long &operator-=(const ls::std::boxing::Long &_long);
+          ls::std::boxing::Long &operator-=(ls::long_type _value);
+          ls::std::boxing::Long &operator*=(const ls::std::boxing::Long &_long);
+          ls::std::boxing::Long &operator*=(ls::long_type _value);
+          ls::std::boxing::Long &operator/=(const ls::std::boxing::Long &_long);
+          ls::std::boxing::Long &operator/=(ls::long_type _value);
+
+          // comparison operators
+
+          bool operator==(const ls::std::boxing::Long &_long) const;
+          bool operator==(ls::long_type _value) const;
+          bool operator!=(const ls::std::boxing::Long &_long) const;
+          bool operator!=(ls::long_type _value) const;
+          bool operator>(const ls::std::boxing::Long &_long) const;
+          bool operator>(ls::long_type _value) const;
+          bool operator>=(const ls::std::boxing::Long &_long) const;
+          bool operator>=(ls::long_type _value) const;
+          bool operator<(const ls::std::boxing::Long &_long) const;
+          bool operator<(ls::long_type _value) const;
+          bool operator<=(const ls::std::boxing::Long &_long) const;
+          bool operator<=(ls::long_type _value) const;
+
+          // logical operators
+
+          friend bool operator!(const ls::std::boxing::Long &_long)
+          {
+            return !_long.value;
+          }
+
+          bool operator&&(const ls::std::boxing::Long &_long) const;
+          bool operator&&(ls::long_type _value) const;
+          bool operator&&(bool _expression) const;
+          bool operator||(const ls::std::boxing::Long &_long) const;
+          bool operator||(ls::long_type _value) const;
+          bool operator||(bool _expression) const;
+
+          // increment / decrement operator
+
+          void operator++();
+          void operator--();
+
+          // implementation
+
+          void parse(::std::string _parseText) override;
+          ::std::string toString() override;
+
+          // additional functionality
+
+          ls::long_type getValue() const;
+
+        private:
+
+          ls::long_type value{};
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/boxing/String.hpp

@@ -19,70 +19,76 @@
 
 namespace ls
 {
-  class String : public ls::Class, public ls::std::boxing::IBoxing
+  namespace std
   {
-    public:
+    namespace boxing
+    {
+      class String : public ls::Class, public ls::std::boxing::IBoxing
+      {
+        public:
 
-      String();
-      explicit String(::std::string _value);
-      ~String() override = default;
+          String();
+          explicit String(::std::string _value);
+          ~String() override = default;
 
-      // conversion operator
+          // conversion operator
 
-      operator const char *() const; // do not make explicit!
-      operator ::std::string() const; // do not make explicit!
+          operator const char *() const; // do not make explicit!
+          operator ::std::string() const; // do not make explicit!
 
-      // assignment operators
+          // assignment operators
 
-      ls::String &operator=(::std::string _value);
+          ls::std::boxing::String &operator=(::std::string _value);
 
-      // arithmetic operators
+          // arithmetic operators
 
-      ::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);
+          ::std::string operator+(ls::std::boxing::String _string) const;
+          ::std::string operator+(const ::std::string &_string) const;
+          ::std::string operator+(const char *_string) const;
+          ::std::string operator-(int _number);
 
-      // compound operators
+          // compound operators
 
-      ls::String &operator+=(ls::String _string);
-      ls::String &operator+=(const ::std::string &_text);
+          ls::std::boxing::String &operator+=(ls::std::boxing::String _string);
+          ls::std::boxing::String &operator+=(const ::std::string &_text);
 
-      // comparison operators
+          // comparison operators
 
-      bool operator==(ls::String _string);
-      bool operator==(const ::std::string &_value);
-      bool operator==(const char *_value);
-      bool operator!=(ls::String _string);
-      bool operator!=(const ::std::string &_value);
-      bool operator!=(const char *_value);
+          bool operator==(ls::std::boxing::String _string);
+          bool operator==(const ::std::string &_value);
+          bool operator==(const char *_value);
+          bool operator!=(ls::std::boxing::String _string);
+          bool operator!=(const ::std::string &_value);
+          bool operator!=(const char *_value);
 
-      // implementation
+          // implementation
 
-      void parse(::std::string _parseText) override;
-      ::std::string toString() override;
+          void parse(::std::string _parseText) override;
+          ::std::string toString() override;
 
-      // additional functionality
+          // additional functionality
 
-      bool contains(const ::std::string &_text);
-      bool endsWith(const ::std::string &_text);
-      bool equalsIgnoreCase(ls::String _string);
-      bool equalsIgnoreCase(::std::string _text);
-      ::std::vector<ls::byte> getByteData();
-      ::std::string padLeft(size_t _width, char _fillCharacter);
-      ::std::string padRight(size_t _width, char _fillCharacter);
-      ::std::string reverse();
-      bool startsWith(const ::std::string &_text);
-      ::std::string toLowerCase();
-      ::std::string toUpperCase();
+          bool contains(const ::std::string &_text);
+          bool endsWith(const ::std::string &_text);
+          bool equalsIgnoreCase(ls::std::boxing::String _string);
+          bool equalsIgnoreCase(::std::string _text);
+          ::std::vector<ls::byte> getByteData();
+          ::std::string padLeft(size_t _width, char _fillCharacter);
+          ::std::string padRight(size_t _width, char _fillCharacter);
+          ::std::string reverse();
+          bool startsWith(const ::std::string &_text);
+          ::std::string toLowerCase();
+          ::std::string toUpperCase();
 
-    private:
+        private:
 
-      ::std::string value{};
+          ::std::string value{};
 
-      static ::std::string _buildCharacterChain(size_t _amount, char _fillCharacter);
-      static ::std::string _createFillContent(const ::std::string &_text, size_t _width, char _fillCharacter);
-  };
+          static ::std::string _buildCharacterChain(size_t _amount, char _fillCharacter);
+          static ::std::string _createFillContent(const ::std::string &_text, size_t _width, char _fillCharacter);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/kv/KvParseParameter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -18,7 +18,7 @@ namespace ls
   struct KvParseParameter
   {
     ::std::string::size_type index{};
-    ls::String line{};
+    ls::std::boxing::String line{};
   };
 }
 

source/ls_std/boxing/Integer.cpp

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

source/ls_std/boxing/Long.cpp

@@ -3,68 +3,68 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
 #include <ls_std/boxing/Long.hpp>
 #include <ls_std/core/exception/IllegalArithmeticOperationException.hpp>
 
-ls::Long::Long(ls::long_type _value)
+ls::std::boxing::Long::Long(ls::long_type _value)
     : ls::Class("Long"),
       value(_value)
 {}
 
-ls::Long::Long() : ls::Class("Long")
+ls::std::boxing::Long::Long() : ls::Class("Long")
 {}
 
-ls::Long::operator ls::long_type() const
+ls::std::boxing::Long::operator ls::long_type() const
 {
   return this->value;
 }
 
-ls::Long &ls::Long::operator=(ls::long_type _value)
+ls::std::boxing::Long &ls::std::boxing::Long::operator=(ls::long_type _value)
 {
   this->value = _value;
   return *this;
 }
 
-ls::long_type ls::Long::operator-() const
+ls::long_type ls::std::boxing::Long::operator-() const
 {
   return -this->value;
 }
 
-ls::long_type ls::Long::operator+(const ls::Long &_long) const
+ls::long_type ls::std::boxing::Long::operator+(const ls::std::boxing::Long &_long) const
 {
   return this->value + _long;
 }
 
-ls::long_type ls::Long::operator+(ls::long_type _value) const
+ls::long_type ls::std::boxing::Long::operator+(ls::long_type _value) const
 {
   return this->value + _value;
 }
 
-ls::long_type ls::Long::operator*(const ls::Long &_long) const
+ls::long_type ls::std::boxing::Long::operator*(const ls::std::boxing::Long &_long) const
 {
   return this->value * _long;
 }
 
-ls::long_type ls::Long::operator*(ls::long_type _value) const
+ls::long_type ls::std::boxing::Long::operator*(ls::long_type _value) const
 {
   return this->value * _value;
 }
 
-ls::long_type ls::Long::operator-(const ls::Long &_long) const
+ls::long_type ls::std::boxing::Long::operator-(const ls::std::boxing::Long &_long) const
 {
   return this->value - _long;
 }
 
-ls::long_type ls::Long::operator-(ls::long_type _value) const
+ls::long_type ls::std::boxing::Long::operator-(ls::long_type _value) const
 {
   return this->value - _value;
 }
 
-ls::long_type ls::Long::operator/(const ls::Long &_long) const
+ls::long_type ls::std::boxing::Long::operator/(const ls::std::boxing::Long &_long) const
 {
   if (_long == (ls::long_type) 0)
   {
@@ -74,7 +74,7 @@ ls::long_type ls::Long::operator/(const ls::Long &_long) const
   return this->value / _long;
 }
 
-ls::long_type ls::Long::operator/(ls::long_type _value) const
+ls::long_type ls::std::boxing::Long::operator/(ls::long_type _value) const
 {
   if (_value == 0)
   {
@@ -84,53 +84,53 @@ ls::long_type ls::Long::operator/(ls::long_type _value) const
   return this->value / _value;
 }
 
-ls::long_type ls::Long::operator%(const ls::Long &_long) const
+ls::long_type ls::std::boxing::Long::operator%(const ls::std::boxing::Long &_long) const
 {
   return this->value % _long;
 }
 
-ls::long_type ls::Long::operator%(ls::long_type _value) const
+ls::long_type ls::std::boxing::Long::operator%(ls::long_type _value) const
 {
   return this->value % _value;
 }
 
-ls::Long &ls::Long::operator+=(const ls::Long &_long)
+ls::std::boxing::Long &ls::std::boxing::Long::operator+=(const ls::std::boxing::Long &_long)
 {
   this->value += _long;
   return *this;
 }
 
-ls::Long &ls::Long::operator+=(ls::long_type _value)
+ls::std::boxing::Long &ls::std::boxing::Long::operator+=(ls::long_type _value)
 {
   this->value += _value;
   return *this;
 }
 
-ls::Long &ls::Long::operator-=(const ls::Long &_long)
+ls::std::boxing::Long &ls::std::boxing::Long::operator-=(const ls::std::boxing::Long &_long)
 {
   this->value -= _long;
   return *this;
 }
 
-ls::Long &ls::Long::operator-=(ls::long_type _value)
+ls::std::boxing::Long &ls::std::boxing::Long::operator-=(ls::long_type _value)
 {
   this->value -= _value;
   return *this;
 }
 
-ls::Long &ls::Long::operator*=(const ls::Long &_long)
+ls::std::boxing::Long &ls::std::boxing::Long::operator*=(const ls::std::boxing::Long &_long)
 {
   this->value *= _long;
   return *this;
 }
 
-ls::Long &ls::Long::operator*=(ls::long_type _value)
+ls::std::boxing::Long &ls::std::boxing::Long::operator*=(ls::long_type _value)
 {
   this->value *= _value;
   return *this;
 }
 
-ls::Long &ls::Long::operator/=(const ls::Long &_long)
+ls::std::boxing::Long &ls::std::boxing::Long::operator/=(const ls::std::boxing::Long &_long)
 {
   if (_long == (ls::long_type) 0)
   {
@@ -141,7 +141,7 @@ ls::Long &ls::Long::operator/=(const ls::Long &_long)
   return *this;
 }
 
-ls::Long &ls::Long::operator/=(ls::long_type _value)
+ls::std::boxing::Long &ls::std::boxing::Long::operator/=(ls::long_type _value)
 {
   if (_value == 0)
   {
@@ -152,117 +152,117 @@ ls::Long &ls::Long::operator/=(ls::long_type _value)
   return *this;
 }
 
-bool ls::Long::operator==(const ls::Long &_long) const
+bool ls::std::boxing::Long::operator==(const ls::std::boxing::Long &_long) const
 {
   return this->value == _long;
 }
 
-bool ls::Long::operator==(ls::long_type _value) const
+bool ls::std::boxing::Long::operator==(ls::long_type _value) const
 {
   return this->value == _value;
 }
 
-bool ls::Long::operator!=(const ls::Long &_long) const
+bool ls::std::boxing::Long::operator!=(const ls::std::boxing::Long &_long) const
 {
   return this->value != _long;
 }
 
-bool ls::Long::operator!=(ls::long_type _value) const
+bool ls::std::boxing::Long::operator!=(ls::long_type _value) const
 {
   return this->value != _value;
 }
 
-bool ls::Long::operator>(const ls::Long &_long) const
+bool ls::std::boxing::Long::operator>(const ls::std::boxing::Long &_long) const
 {
   return this->value > _long;
 }
 
-bool ls::Long::operator>(ls::long_type _value) const
+bool ls::std::boxing::Long::operator>(ls::long_type _value) const
 {
   return this->value > _value;
 }
 
-bool ls::Long::operator>=(const ls::Long &_long) const
+bool ls::std::boxing::Long::operator>=(const ls::std::boxing::Long &_long) const
 {
   return this->value >= _long;
 }
 
-bool ls::Long::operator>=(ls::long_type _value) const
+bool ls::std::boxing::Long::operator>=(ls::long_type _value) const
 {
   return this->value >= _value;
 }
 
-bool ls::Long::operator<(const ls::Long &_long) const
+bool ls::std::boxing::Long::operator<(const ls::std::boxing::Long &_long) const
 {
   return this->value < _long;
 }
 
-bool ls::Long::operator<(ls::long_type _value) const
+bool ls::std::boxing::Long::operator<(ls::long_type _value) const
 {
   return this->value < _value;
 }
 
-bool ls::Long::operator<=(const ls::Long &_long) const
+bool ls::std::boxing::Long::operator<=(const ls::std::boxing::Long &_long) const
 {
   return this->value <= _long;
 }
 
-bool ls::Long::operator<=(ls::long_type _value) const
+bool ls::std::boxing::Long::operator<=(ls::long_type _value) const
 {
   return this->value <= _value;
 }
 
-bool ls::Long::operator&&(const ls::Long &_long) const
+bool ls::std::boxing::Long::operator&&(const ls::std::boxing::Long &_long) const
 {
   return this->value && _long;
 }
 
-bool ls::Long::operator&&(ls::long_type _value) const
+bool ls::std::boxing::Long::operator&&(ls::long_type _value) const
 {
   return this->value && _value;
 }
 
-bool ls::Long::operator&&(bool _expression) const
+bool ls::std::boxing::Long::operator&&(bool _expression) const
 {
   return this->value && _expression;
 }
 
-bool ls::Long::operator||(const ls::Long &_long) const
+bool ls::std::boxing::Long::operator||(const ls::std::boxing::Long &_long) const
 {
   return this->value || _long;
 }
 
-bool ls::Long::operator||(ls::long_type _value) const
+bool ls::std::boxing::Long::operator||(ls::long_type _value) const
 {
   return this->value || _value;
 }
 
-bool ls::Long::operator||(bool _expression) const
+bool ls::std::boxing::Long::operator||(bool _expression) const
 {
   return this->value || _expression;
 }
 
-void ls::Long::operator++()
+void ls::std::boxing::Long::operator++()
 {
   this->value += 1;
 }
 
-void ls::Long::operator--()
+void ls::std::boxing::Long::operator--()
 {
   this->value -= 1;
 }
 
-void ls::Long::parse(::std::string _parseText)
+void ls::std::boxing::Long::parse(::std::string _parseText)
 {
   this->value = ::std::stoll(_parseText);
 }
 
-std::string ls::Long::toString()
+std::string ls::std::boxing::Long::toString()
 {
   return ::std::to_string(this->value);
 }
 
-ls::long_type ls::Long::getValue() const
+ls::long_type ls::std::boxing::Long::getValue() const
 {
   return this->value;
 }

source/ls_std/boxing/String.cpp

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

source/ls_std/io/kv/KvFileReader.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -12,7 +12,7 @@
 #include <ls_std/io/FileReader.hpp>
 #include <ls_std/io/kv/KvParser.hpp>
 
-ls::KvFileReader::KvFileReader(const std::shared_ptr<ls::KvDocument> &_document, const std::string &_absolutePath)
+ls::KvFileReader::KvFileReader(const ::std::shared_ptr<ls::KvDocument> &_document, const ::std::string &_absolutePath)
     : ls::Class("KvFileReader"),
       kvFile(ls::File{""})
 {
@@ -33,7 +33,7 @@ std::shared_ptr<ls::KvDocument> ls::KvFileReader::getDocument()
   return this->document;
 }
 
-void ls::KvFileReader::setDocument(const std::shared_ptr<ls::KvDocument> &_document)
+void ls::KvFileReader::setDocument(const ::std::shared_ptr<ls::KvDocument> &_document)
 {
   this->_assignDocument(_document);
 }
@@ -43,7 +43,7 @@ void ls::KvFileReader::setFile(const ls::File &_kvFile)
   this->_assignFile(_kvFile);
 }
 
-void ls::KvFileReader::_assignDocument(const std::shared_ptr<ls::KvDocument> &_document)
+void ls::KvFileReader::_assignDocument(const ::std::shared_ptr<ls::KvDocument> &_document)
 {
   if (_document == nullptr)
   {

source/ls_std/io/logging/Logger.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -13,7 +13,7 @@
 #include <ls_std/boxing/String.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::Logger::Logger(const std::shared_ptr<ls::IWriter> &_writer)
+ls::Logger::Logger(const ::std::shared_ptr<ls::IWriter> &_writer)
     : ls::Class("Logger"),
       logLevel(ls::LogLevelValue::INFO)
 {
@@ -78,7 +78,7 @@ void ls::Logger::warn(const ls::byte *_data)
   }
 }
 
-void ls::Logger::_assignWriter(const std::shared_ptr<ls::IWriter> &_writer)
+void ls::Logger::_assignWriter(const ::std::shared_ptr<ls::IWriter> &_writer)
 {
   if (_writer == nullptr)
   {
@@ -91,6 +91,6 @@ void ls::Logger::_assignWriter(const std::shared_ptr<ls::IWriter> &_writer)
 void ls::Logger::_log(const ls::byte *_data, const ls::LogLevel &_logLevel)
 {
   ls::Date date{};
-  std::string message = "[" + date.toString() + "] " + ls::String{_logLevel.toString() + ":"}.padRight(10, ' ') + std::string(_data) + ls::NewLine::getUnixNewLine();
+  ::std::string message = "[" + date.toString() + "] " + ls::std::boxing::String{_logLevel.toString() + ":"}.padRight(10, ' ') + ::std::string(_data) + ls::NewLine::getUnixNewLine();
   this->writer->write(message);
 }

source/ls_std/io/xml/XmlParser.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -11,13 +11,13 @@
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 #include <ls_std/boxing/String.hpp>
 
-ls::XmlParser::XmlParser(const std::shared_ptr<ls::XmlDocument> &_document) : ls::Class("XmlParser")
+ls::XmlParser::XmlParser(const ::std::shared_ptr<ls::XmlDocument> &_document) : ls::Class("XmlParser")
 {
   this->_assignDocument(_document);
   this->_reset();
 }
 
-std::shared_ptr<ls::XmlDocument> ls::XmlParser::getDocument()
+::std::shared_ptr<ls::XmlDocument> ls::XmlParser::getDocument()
 {
   return this->document;
 }
@@ -29,22 +29,22 @@ void ls::XmlParser::parse(const ls::byte_field &_data)
   this->_reset();
 }
 
-void ls::XmlParser::setDocument(const std::shared_ptr<ls::XmlDocument> &_document)
+void ls::XmlParser::setDocument(const ::std::shared_ptr<ls::XmlDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-std::pair<std::string, std::string> ls::XmlParser::_readAttribute_(const ls::byte_field &_data)
+::std::pair<::std::string, ::std::string> ls::XmlParser::_readAttribute_(const ls::byte_field &_data)
 {
   return ls::XmlParser::_parseAttribute(_data);
 }
 
-std::list<std::pair<std::string, std::string>> ls::XmlParser::_readAttributes_(ls::byte_field _data)
+::std::list<::std::pair<::std::string, ::std::string>> ls::XmlParser::_readAttributes_(ls::byte_field _data)
 {
-  return ls::XmlParser::_parseAttributes(std::move(_data));
+  return ls::XmlParser::_parseAttributes(::std::move(_data));
 }
 
-void ls::XmlParser::_analyze(const ls::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,7 +52,7 @@ void ls::XmlParser::_analyze(const ls::byte_field &_data, std::string::size_type
   this->_isValue(_data, _index);
 }
 
-void ls::XmlParser::_assignDocument(const std::shared_ptr<ls::XmlDocument> &_document)
+void ls::XmlParser::_assignDocument(const ::std::shared_ptr<ls::XmlDocument> &_document)
 {
   if (_document == nullptr)
   {
@@ -62,10 +62,10 @@ void ls::XmlParser::_assignDocument(const std::shared_ptr<ls::XmlDocument> &_doc
   this->document = _document;
 }
 
-std::shared_ptr<ls::XmlDeclaration> ls::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::XmlDeclaration> declaration = std::make_shared<ls::XmlDeclaration>("1.0");
-  std::pair<std::string, std::string> attribute = ls::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())
   {
@@ -89,14 +89,14 @@ std::shared_ptr<ls::XmlDeclaration> ls::XmlParser::_createDeclaration(const std:
   return declaration;
 }
 
-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::XmlNode> ls::XmlParser::_createNode(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name)
 {
-  std::shared_ptr<ls::XmlNode> node = std::make_shared<ls::XmlNode>(_name);
-  std::shared_ptr<ls::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::XmlAttribute>(parsedAttribute.first);
+    attribute = ::std::make_shared<ls::XmlAttribute>(parsedAttribute.first);
     attribute->setValue(parsedAttribute.second);
     node->addAttributeToEnd(attribute);
   }
@@ -104,9 +104,9 @@ std::shared_ptr<ls::XmlNode> ls::XmlParser::_createNode(const std::list<std::pai
   return node;
 }
 
-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> ls::XmlParser::_findAttribute(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name)
 {
-  std::pair<std::string, std::string> attribute{};
+  ::std::pair<::std::string, ::std::string> attribute{};
 
   for (const auto &currentAttribute : _attributes)
   {
@@ -122,8 +122,8 @@ std::pair<std::string, std::string> ls::XmlParser::_findAttribute(const std::lis
 
 size_t ls::XmlParser::_findAttributeEndPosition(const ls::byte_field &_data)
 {
-  std::string::size_type position = std::string::npos;
-  std::string::size_type counter{};
+  ::std::string::size_type position = ::std::string::npos;
+  ::std::string::size_type counter{};
 
   for (char letter : _data)
   {
@@ -143,12 +143,12 @@ size_t ls::XmlParser::_findAttributeEndPosition(const ls::byte_field &_data)
   return position;
 }
 
-ls::byte_field ls::XmlParser::_getNextTagString(const ls::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::byte_field tag{};
   size_t closingCharacterPosition = _index + _data.substr(_index).find('>');
 
-  if (closingCharacterPosition != std::string::npos)
+  if (closingCharacterPosition != ::std::string::npos)
   {
     tag = _data.substr(_index, (closingCharacterPosition - _index) + 1);
   }
@@ -156,7 +156,7 @@ ls::byte_field ls::XmlParser::_getNextTagString(const ls::byte_field &_data, std
   return tag;
 }
 
-void ls::XmlParser::_isClosingTag(const ls::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::XmlParser::_isClosingTag(const ls::byte_field &_data, std::string::size
   }
 }
 
-void ls::XmlParser::_isDeclaration(const ls::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::XmlParser::_isDeclaration(const ls::byte_field &_data, std::string::siz
   }
 }
 
-void ls::XmlParser::_isOpeningTag(const ls::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,16 +180,16 @@ void ls::XmlParser::_isOpeningTag(const ls::byte_field &_data, std::string::size
   }
 }
 
-void ls::XmlParser::_isValue(const ls::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)
   {
-    std::string::size_type end = _data.substr(_index).find('<');
-    bool isValue = _data[_index - 1] == '>' && end != std::string::npos && end > 0;
+    ::std::string::size_type end = _data.substr(_index).find('<');
+    bool isValue = _data[_index - 1] == '>' && end != ::std::string::npos && end > 0;
 
     if (isValue)
     {
-      ls::String value{_data.substr(_index, end)};
+      ls::std::boxing::String value{_data.substr(_index, end)};
 
       if (!value.contains("\n") && !value.contains("\r\n"))
       {
@@ -210,7 +210,7 @@ void ls::XmlParser::_mergeNodes()
   this->document->setRootElement(this->parseParameters.front().node);
 }
 
-void ls::XmlParser::_mergeChildrenToParentNode(const std::shared_ptr<ls::XmlNode> &_parent, std::list<ls::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
   {
@@ -250,7 +250,7 @@ void ls::XmlParser::_mergeNodesOnCurrentLevel()
 
 void ls::XmlParser::_parse(const ls::byte_field &_data)
 {
-  for (std::string::size_type index = 0; index < _data.size(); index++)
+  for (::std::string::size_type index = 0; index < _data.size(); index++)
   {
     switch (this->mode)
     {
@@ -291,9 +291,9 @@ void ls::XmlParser::_parse(const ls::byte_field &_data)
   }
 }
 
-std::pair<std::string, std::string> ls::XmlParser::_parseAttribute(const ls::byte_field &_data)
+::std::pair<::std::string, ::std::string> ls::XmlParser::_parseAttribute(const ls::byte_field &_data)
 {
-  std::pair<std::string, std::string> parsedAttribute{};
+  ::std::pair<::std::string, ::std::string> parsedAttribute{};
   parsedAttribute.first = _data.substr(0, _data.find('='));
   parsedAttribute.second = _data.substr(_data.find('"') + 1);
   parsedAttribute.second.pop_back();
@@ -301,11 +301,11 @@ std::pair<std::string, std::string> ls::XmlParser::_parseAttribute(const ls::byt
   return parsedAttribute;
 }
 
-std::list<std::pair<std::string, std::string>> ls::XmlParser::_parseAttributes(ls::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{};
+  ::std::list<::std::pair<::std::string, ::std::string>> attributes{};
   size_t position = _data.find(' ');
-  _data = position == std::string::npos ? "" : _data.substr(position);
+  _data = position == ::std::string::npos ? "" : _data.substr(position);
 
   while (!_data.empty())
   {
@@ -314,12 +314,12 @@ std::list<std::pair<std::string, std::string>> ls::XmlParser::_parseAttributes(l
       position = _data.find(' ') + 1;
     } while (_data[position] == ' ');
 
-    if (_data.size() <= 3 && ls::String{_data}.endsWith(">"))
+    if (_data.size() <= 3 && ls::std::boxing::String{_data}.endsWith(">"))
     {
       break;
     }
 
-    std::string attributeString = _data.substr(position, ls::XmlParser::_findAttributeEndPosition(_data) + 1);
+    ::std::string attributeString = _data.substr(position, ls::XmlParser::_findAttributeEndPosition(_data) + 1);
     attributes.push_back(ls::XmlParser::_parseAttribute(attributeString));
     _data = _data.substr(position + attributeString.size());
   }
@@ -327,36 +327,36 @@ std::list<std::pair<std::string, std::string>> ls::XmlParser::_parseAttributes(l
   return attributes;
 }
 
-size_t ls::XmlParser::_parseClosingTag(const ls::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::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::XmlParser::_parseDeclaration(const ls::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::XmlParser::_getNextTagString(_data, _index);
+  ::std::string tagString = ls::XmlParser::_getNextTagString(_data, _index);
   bool isValidTagString = !tagString.empty();
 
   if (isValidTagString)
   {
-    std::shared_ptr<ls::XmlDeclaration> declaration = this->_createDeclaration(ls::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::XmlParser::_parseOpeningTag(const ls::byte_field &_data, std::string::size_type _index)
+size_t ls::XmlParser::_parseOpeningTag(const ls::byte_field &_data, ::std::string::size_type _index)
 {
-  ls::String tagString{ls::XmlParser::_getNextTagString(_data, _index)};
+  ls::std::boxing::String tagString{ls::XmlParser::_getNextTagString(_data, _index)};
   bool isValidTagString = !tagString.toString().empty();
   ls::XmlParseParameter singleParseParameter{};
 
   if (isValidTagString)
   {
-    std::shared_ptr<ls::XmlNode> node = ls::XmlParser::_createNode(ls::XmlParser::_parseAttributes(tagString), ls::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;
@@ -374,9 +374,9 @@ size_t ls::XmlParser::_parseOpeningTag(const ls::byte_field &_data, std::string:
 
 ls::byte_field ls::XmlParser::_parseTagName(const ls::byte_field &_data)
 {
-  std::string::size_type position = _data.find(' ');
+  ::std::string::size_type position = _data.find(' ');
 
-  if (position == std::string::npos)
+  if (position == ::std::string::npos)
   {
     position = _data.find('>');
   }
@@ -384,7 +384,7 @@ ls::byte_field ls::XmlParser::_parseTagName(const ls::byte_field &_data)
   return _data.substr(1, position - 1);
 }
 
-size_t ls::XmlParser::_parseValue(const ls::byte_field &_data, std::string::size_type _index)
+size_t ls::XmlParser::_parseValue(const ls::byte_field &_data, ::std::string::size_type _index)
 {
   ls::byte_field value = _data.substr(_index, _data.substr(_index).find('<'));
   this->parseParameters.back().node->setValue(value);

source/ls_std/io/xml/XmlReader.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-10
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -13,7 +13,7 @@
 #include <ls_std/boxing/String.hpp>
 #include <ls_std/io/xml/XmlParser.hpp>
 
-ls::XmlReader::XmlReader(const std::shared_ptr<ls::XmlDocument> &_document, const std::string &_absolutePath)
+ls::XmlReader::XmlReader(const ::std::shared_ptr<ls::XmlDocument> &_document, const ::std::string &_absolutePath)
     : ls::Class("XmlReader"),
       xmlFile(ls::File{""})
 {
@@ -29,12 +29,12 @@ ls::byte_field ls::XmlReader::read()
   return data;
 }
 
-std::shared_ptr<ls::XmlDocument> ls::XmlReader::getDocument()
+::std::shared_ptr<ls::XmlDocument> ls::XmlReader::getDocument()
 {
   return this->document;
 }
 
-void ls::XmlReader::setDocument(const std::shared_ptr<ls::XmlDocument> &_document)
+void ls::XmlReader::setDocument(const ::std::shared_ptr<ls::XmlDocument> &_document)
 {
   this->_assignDocument(_document);
 }
@@ -44,7 +44,7 @@ void ls::XmlReader::setFile(const ls::File &_xmlFile)
   this->_assignFile(_xmlFile);
 }
 
-void ls::XmlReader::_assignDocument(const std::shared_ptr<ls::XmlDocument> &_document)
+void ls::XmlReader::_assignDocument(const ::std::shared_ptr<ls::XmlDocument> &_document)
 {
   if (_document == nullptr)
   {

test/cases/boxing/IntegerTest.cpp

@@ -3,13 +3,12 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
 #include <gtest/gtest.h>
 #include <ls_std/ls_std.hpp>
-#include <TestHelper.hpp>
 
 namespace
 {
@@ -31,8 +30,8 @@ namespace
 
   TEST_F(IntegerTest, operator_assignment_with_reference)
   {
-    ls::Integer x{};
-    ls::Integer y{3};
+    ls::std::boxing::Integer x{};
+    ls::std::boxing::Integer y{3};
     x = y;
 
     ASSERT_EQ(3, x);
@@ -40,7 +39,7 @@ namespace
 
   TEST_F(IntegerTest, operator_assignment_with_value)
   {
-    ls::Integer x{};
+    ls::std::boxing::Integer x{};
     x = 44;
 
     ASSERT_EQ(44, x);
@@ -50,8 +49,8 @@ namespace
 
   TEST_F(IntegerTest, operator_negative)
   {
-    ls::Integer x{13};
-    ls::Integer y{-13};
+    ls::std::boxing::Integer x{13};
+    ls::std::boxing::Integer y{-13};
 
     ASSERT_EQ(-13, -x);
     ASSERT_EQ(13, -y);
@@ -59,57 +58,57 @@ namespace
 
   TEST_F(IntegerTest, operator_add_with_reference)
   {
-    ls::Integer x{13};
-    ls::Integer y{7};
+    ls::std::boxing::Integer x{13};
+    ls::std::boxing::Integer y{7};
 
     ASSERT_EQ(20, x + y);
   }
 
   TEST_F(IntegerTest, operator_add_with_value)
   {
-    ls::Integer x{13};
+    ls::std::boxing::Integer x{13};
     ASSERT_EQ(20, x + 7);
   }
 
   TEST_F(IntegerTest, operator_mul_with_reference)
   {
-    ls::Integer x{3};
-    ls::Integer y{7};
+    ls::std::boxing::Integer x{3};
+    ls::std::boxing::Integer y{7};
 
     ASSERT_EQ(21, x * y);
   }
 
   TEST_F(IntegerTest, operator_mul_with_value)
   {
-    ls::Integer x{3};
+    ls::std::boxing::Integer x{3};
     ASSERT_EQ(21, x * 7);
   }
 
   TEST_F(IntegerTest, operator_sub_with_reference)
   {
-    ls::Integer x{51};
-    ls::Integer y{17};
+    ls::std::boxing::Integer x{51};
+    ls::std::boxing::Integer y{17};
 
     ASSERT_EQ(34, x - y);
   }
 
   TEST_F(IntegerTest, operator_sub_with_value)
   {
-    ls::Integer x{51};
+    ls::std::boxing::Integer x{51};
     ASSERT_EQ(34, x - 17);
   }
 
   TEST_F(IntegerTest, operator_div_with_reference)
   {
-    ls::Integer x{81};
-    ls::Integer y{9};
+    ls::std::boxing::Integer x{81};
+    ls::std::boxing::Integer y{9};
 
     ASSERT_EQ(9, x / y);
   }
 
   TEST_F(IntegerTest, operator_div_with_value)
   {
-    ls::Integer x{81};
+    ls::std::boxing::Integer x{81};
     ASSERT_EQ(9, x / 9);
   }
 
@@ -118,8 +117,8 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::Integer x{9};
-                     ls::Integer y{0};
+                     ls::std::boxing::Integer x{9};
+                     ls::std::boxing::Integer y{0};
 
                      x = x / y;
                    } catch (const ls::IllegalArithmeticOperationException &_exception)
@@ -134,7 +133,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::Integer x{9};
+                     ls::std::boxing::Integer x{9};
                      x = x / 0;
                    } catch (const ls::IllegalArithmeticOperationException &_exception)
                    {
@@ -145,15 +144,15 @@ namespace
 
   TEST_F(IntegerTest, operator_mod_with_reference)
   {
-    ls::Integer x{85};
-    ls::Integer y{9};
+    ls::std::boxing::Integer x{85};
+    ls::std::boxing::Integer y{9};
 
     ASSERT_EQ(4, x % y);
   }
 
   TEST_F(IntegerTest, operator_mod_with_value)
   {
-    ls::Integer x{85};
+    ls::std::boxing::Integer x{85};
     ASSERT_EQ(4, x % 9);
   }
 
@@ -161,8 +160,8 @@ namespace
 
   TEST_F(IntegerTest, operator_add_assign_with_reference)
   {
-    ls::Integer x{4};
-    ls::Integer y{2};
+    ls::std::boxing::Integer x{4};
+    ls::std::boxing::Integer y{2};
     x += y;
 
     ASSERT_EQ(6, x);
@@ -170,7 +169,7 @@ namespace
 
   TEST_F(IntegerTest, operator_add_assign_with_value)
   {
-    ls::Integer x{4};
+    ls::std::boxing::Integer x{4};
     x += 2;
 
     ASSERT_EQ(6, x);
@@ -178,8 +177,8 @@ namespace
 
   TEST_F(IntegerTest, operator_sub_assign_with_reference)
   {
-    ls::Integer x{14};
-    ls::Integer y{2};
+    ls::std::boxing::Integer x{14};
+    ls::std::boxing::Integer y{2};
     x -= y;
 
     ASSERT_EQ(12, x);
@@ -187,7 +186,7 @@ namespace
 
   TEST_F(IntegerTest, operator_sub_assign_with_value)
   {
-    ls::Integer x{14};
+    ls::std::boxing::Integer x{14};
     x -= 2;
 
     ASSERT_EQ(12, x);
@@ -195,8 +194,8 @@ namespace
 
   TEST_F(IntegerTest, operator_mul_assign_with_reference)
   {
-    ls::Integer x{6};
-    ls::Integer y{3};
+    ls::std::boxing::Integer x{6};
+    ls::std::boxing::Integer y{3};
     x *= y;
 
     ASSERT_EQ(18, x);
@@ -204,7 +203,7 @@ namespace
 
   TEST_F(IntegerTest, operator_mul_assign_with_value)
   {
-    ls::Integer x{6};
+    ls::std::boxing::Integer x{6};
     x *= 3;
 
     ASSERT_EQ(18, x);
@@ -212,8 +211,8 @@ namespace
 
   TEST_F(IntegerTest, operator_div_assign_with_reference)
   {
-    ls::Integer x{12};
-    ls::Integer y{3};
+    ls::std::boxing::Integer x{12};
+    ls::std::boxing::Integer y{3};
     x /= y;
 
     ASSERT_EQ(4, x);
@@ -221,7 +220,7 @@ namespace
 
   TEST_F(IntegerTest, operator_div_assign_with_value)
   {
-    ls::Integer x{12};
+    ls::std::boxing::Integer x{12};
     x /= 3;
 
     ASSERT_EQ(4, x);
@@ -232,8 +231,8 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::Integer x{9};
-                     ls::Integer y{0};
+                     ls::std::boxing::Integer x{9};
+                     ls::std::boxing::Integer y{0};
 
                      x = x /= y;
                    } catch (const ls::IllegalArithmeticOperationException &_exception)
@@ -248,7 +247,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::Integer x{9};
+                     ls::std::boxing::Integer x{9};
                      x = x /= 0;
                    } catch (const ls::IllegalArithmeticOperationException &_exception)
                    {
@@ -261,86 +260,86 @@ namespace
 
   TEST_F(IntegerTest, operator_equals_with_reference)
   {
-    ls::Integer x{12};
-    ls::Integer y{12};
+    ls::std::boxing::Integer x{12};
+    ls::std::boxing::Integer y{12};
 
     ASSERT_TRUE(x == y);
   }
 
   TEST_F(IntegerTest, operator_equals_with_value)
   {
-    ls::Integer x{12};
+    ls::std::boxing::Integer x{12};
 
     ASSERT_TRUE(x == 12);
   }
 
   TEST_F(IntegerTest, operator_not_equals_with_reference)
   {
-    ls::Integer x{12};
-    ls::Integer y{3};
+    ls::std::boxing::Integer x{12};
+    ls::std::boxing::Integer y{3};
 
     ASSERT_TRUE(x != y);
   }
 
   TEST_F(IntegerTest, operator_not_equals_with_value)
   {
-    ls::Integer x{12};
+    ls::std::boxing::Integer x{12};
     ASSERT_TRUE(x != 3);
   }
 
   TEST_F(IntegerTest, operator_greater_than_with_reference)
   {
-    ls::Integer x{12};
-    ls::Integer y{3};
+    ls::std::boxing::Integer x{12};
+    ls::std::boxing::Integer y{3};
 
     ASSERT_TRUE(x > y);
   }
 
   TEST_F(IntegerTest, operator_greater_than_with_value)
   {
-    ls::Integer x{12};
+    ls::std::boxing::Integer x{12};
     ASSERT_TRUE(x > 3);
   }
 
   TEST_F(IntegerTest, operator_greater_than_equals_with_reference)
   {
-    ls::Integer x{12};
-    ls::Integer y{12};
+    ls::std::boxing::Integer x{12};
+    ls::std::boxing::Integer y{12};
 
     ASSERT_TRUE(x >= y);
   }
 
   TEST_F(IntegerTest, operator_greater_than_equals_with_value)
   {
-    ls::Integer x{12};
+    ls::std::boxing::Integer x{12};
     ASSERT_TRUE(x >= 12);
   }
 
   TEST_F(IntegerTest, operator_less_than_with_reference)
   {
-    ls::Integer x{10};
-    ls::Integer y{12};
+    ls::std::boxing::Integer x{10};
+    ls::std::boxing::Integer y{12};
 
     ASSERT_TRUE(x < y);
   }
 
   TEST_F(IntegerTest, operator_less_than_with_value)
   {
-    ls::Integer x{10};
+    ls::std::boxing::Integer x{10};
     ASSERT_TRUE(x < 12);
   }
 
   TEST_F(IntegerTest, operator_less_than_equals_with_reference)
   {
-    ls::Integer x{10};
-    ls::Integer y{10};
+    ls::std::boxing::Integer x{10};
+    ls::std::boxing::Integer y{10};
 
     ASSERT_TRUE(x <= y);
   }
 
   TEST_F(IntegerTest, operator_less_than_equals_with_value)
   {
-    ls::Integer x{10};
+    ls::std::boxing::Integer x{10};
     ASSERT_TRUE(x <= 10);
   }
 
@@ -348,47 +347,47 @@ namespace
 
   TEST_F(IntegerTest, operator_negation)
   {
-    ls::Integer x{};
+    ls::std::boxing::Integer x{};
     ASSERT_TRUE(!x);
   }
 
   TEST_F(IntegerTest, operator_and_with_reference)
   {
-    ls::Integer x{1};
-    ls::Integer y{1};
+    ls::std::boxing::Integer x{1};
+    ls::std::boxing::Integer y{1};
 
     ASSERT_TRUE(x && y);
   }
 
   TEST_F(IntegerTest, operator_and_with_value)
   {
-    ls::Integer x{1};
+    ls::std::boxing::Integer x{1};
     ASSERT_TRUE(x && 1);
   }
 
   TEST_F(IntegerTest, operator_and_with_boolean)
   {
-    ls::Integer x{1};
+    ls::std::boxing::Integer x{1};
     ASSERT_TRUE(x && true);
   }
 
   TEST_F(IntegerTest, operator_or_with_reference)
   {
-    ls::Integer x{};
-    ls::Integer y{1};
+    ls::std::boxing::Integer x{};
+    ls::std::boxing::Integer y{1};
 
     ASSERT_TRUE(x || y);
   }
 
   TEST_F(IntegerTest, operator_or_with_value)
   {
-    ls::Integer x{};
+    ls::std::boxing::Integer x{};
     ASSERT_TRUE(x || 1);
   }
 
   TEST_F(IntegerTest, operator_or_with_boolean)
   {
-    ls::Integer x{};
+    ls::std::boxing::Integer x{};
     ASSERT_TRUE(x || true);
   }
 
@@ -396,7 +395,7 @@ namespace
 
   TEST_F(IntegerTest, operator_increment)
   {
-    ls::Integer x{};
+    ls::std::boxing::Integer x{};
     ++x;
 
     ASSERT_EQ(1, x);
@@ -404,7 +403,7 @@ namespace
 
   TEST_F(IntegerTest, operator_decrement)
   {
-    ls::Integer x{};
+    ls::std::boxing::Integer x{};
 
     --x;
     ASSERT_EQ(-1, x);
@@ -414,7 +413,7 @@ namespace
 
   TEST_F(IntegerTest, parse_with_positive_value)
   {
-    ls::Integer number{};
+    ls::std::boxing::Integer number{};
 
     number.parse("1989");
     ASSERT_EQ(1989, number);
@@ -422,7 +421,7 @@ namespace
 
   TEST_F(IntegerTest, parse_with_negative_value)
   {
-    ls::Integer number{};
+    ls::std::boxing::Integer number{};
 
     number.parse("-13");
     ASSERT_EQ(-13, number);
@@ -430,7 +429,7 @@ namespace
 
   TEST_F(IntegerTest, toString)
   {
-    ls::Integer number{112};
+    ls::std::boxing::Integer number{112};
     ASSERT_STREQ("112", number.toString().c_str());
   }
 
@@ -438,7 +437,7 @@ namespace
 
   TEST_F(IntegerTest, getValue)
   {
-    ls::Integer x{3};
+    ls::std::boxing::Integer x{3};
     ASSERT_EQ(3, x.getValue());
   }
 
@@ -446,7 +445,7 @@ namespace
 
   TEST_F(IntegerTest, constApproach)
   {
-    const ls::Integer x{3};
+    const ls::std::boxing::Integer x{3};
     ASSERT_EQ(3, x);
 
     // x = 4; // wouldn't work

test/cases/boxing/LongTest.cpp

@@ -3,13 +3,12 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
 #include <gtest/gtest.h>
 #include <ls_std/ls_std.hpp>
-#include <TestHelper.hpp>
 
 namespace
 {
@@ -32,8 +31,8 @@ namespace
 
   TEST_F(LongTest, operator_assignment_with_reference)
   {
-    ls::Long x{13};
-    ls::Long y{3};
+    ls::std::boxing::Long x{13};
+    ls::std::boxing::Long y{3};
     x = y;
 
     ASSERT_EQ(3, x);
@@ -41,7 +40,7 @@ namespace
 
   TEST_F(LongTest, operator_assignment_with_value)
   {
-    ls::Long x{13};
+    ls::std::boxing::Long x{13};
     x = (ls::long_type) 3;
 
     ASSERT_EQ(3, x);
@@ -51,8 +50,8 @@ namespace
 
   TEST_F(LongTest, operator_negative)
   {
-    ls::Long x{13};
-    ls::Long y{-13};
+    ls::std::boxing::Long x{13};
+    ls::std::boxing::Long y{-13};
 
     ASSERT_EQ(-13, -x);
     ASSERT_EQ(13, -y);
@@ -60,57 +59,57 @@ namespace
 
   TEST_F(LongTest, operator_add_with_reference)
   {
-    ls::Long x{13};
-    ls::Long y{7};
+    ls::std::boxing::Long x{13};
+    ls::std::boxing::Long y{7};
 
     ASSERT_EQ(20, x + y);
   }
 
   TEST_F(LongTest, operator_add_with_value)
   {
-    ls::Long x{13};
+    ls::std::boxing::Long x{13};
     ASSERT_EQ(20, x + (ls::long_type) 7);
   }
 
   TEST_F(LongTest, operator_mul_with_reference)
   {
-    ls::Long x{3};
-    ls::Long y{7};
+    ls::std::boxing::Long x{3};
+    ls::std::boxing::Long y{7};
 
     ASSERT_EQ(21, x * y);
   }
 
   TEST_F(LongTest, operator_mul_with_value)
   {
-    ls::Long x{3};
+    ls::std::boxing::Long x{3};
     ASSERT_EQ(21, x * (ls::long_type) 7);
   }
 
   TEST_F(LongTest, operator_sub_with_reference)
   {
-    ls::Long x{51};
-    ls::Long y{17};
+    ls::std::boxing::Long x{51};
+    ls::std::boxing::Long y{17};
 
     ASSERT_EQ(34, x - y);
   }
 
   TEST_F(LongTest, operator_sub_with_value)
   {
-    ls::Long x{51};
+    ls::std::boxing::Long x{51};
     ASSERT_EQ(34, x - (ls::long_type) 17);
   }
 
   TEST_F(LongTest, operator_div_with_reference)
   {
-    ls::Long x{81};
-    ls::Long y{9};
+    ls::std::boxing::Long x{81};
+    ls::std::boxing::Long y{9};
 
     ASSERT_EQ(9, x / y);
   }
 
   TEST_F(LongTest, operator_div_with_value)
   {
-    ls::Long x{81};
+    ls::std::boxing::Long x{81};
     ASSERT_EQ(9, x / (ls::long_type) 9);
   }
 
@@ -119,8 +118,8 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::Long x{9};
-                     ls::Long y{0};
+                     ls::std::boxing::Long x{9};
+                     ls::std::boxing::Long y{0};
 
                      x = x / y;
                    } catch (const ls::IllegalArithmeticOperationException &_exception)
@@ -135,7 +134,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::Long x{9};
+                     ls::std::boxing::Long x{9};
                      x = x / (ls::long_type) 0;
                    } catch (const ls::IllegalArithmeticOperationException &_exception)
                    {
@@ -146,15 +145,15 @@ namespace
 
   TEST_F(LongTest, operator_mod_with_reference)
   {
-    ls::Long x{85};
-    ls::Long y{9};
+    ls::std::boxing::Long x{85};
+    ls::std::boxing::Long y{9};
 
     ASSERT_EQ(4, x % y);
   }
 
   TEST_F(LongTest, operator_mod_with_value)
   {
-    ls::Long x{85};
+    ls::std::boxing::Long x{85};
     ASSERT_EQ(4, x % (ls::long_type) 9);
   }
 
@@ -162,8 +161,8 @@ namespace
 
   TEST_F(LongTest, operator_add_equals_with_reference)
   {
-    ls::Long x{4};
-    ls::Long y{2};
+    ls::std::boxing::Long x{4};
+    ls::std::boxing::Long y{2};
     x += y;
 
     ASSERT_EQ(6, x);
@@ -171,7 +170,7 @@ namespace
 
   TEST_F(LongTest, operator_add_equals_with_value)
   {
-    ls::Long x{4};
+    ls::std::boxing::Long x{4};
     x += (ls::long_type) 2;
 
     ASSERT_EQ(6, x);
@@ -179,8 +178,8 @@ namespace
 
   TEST_F(LongTest, operator_sub_equals_with_reference)
   {
-    ls::Long x{14};
-    ls::Long y{2};
+    ls::std::boxing::Long x{14};
+    ls::std::boxing::Long y{2};
     x -= y;
 
     ASSERT_EQ(12, x);
@@ -188,7 +187,7 @@ namespace
 
   TEST_F(LongTest, operator_sub_equals_with_value)
   {
-    ls::Long x{14};
+    ls::std::boxing::Long x{14};
     x -= (ls::long_type) 2;
 
     ASSERT_EQ(12, x);
@@ -196,8 +195,8 @@ namespace
 
   TEST_F(LongTest, operator_mul_equals_with_reference)
   {
-    ls::Long x{6};
-    ls::Long y{3};
+    ls::std::boxing::Long x{6};
+    ls::std::boxing::Long y{3};
     x *= y;
 
     ASSERT_EQ(18, x);
@@ -205,7 +204,7 @@ namespace
 
   TEST_F(LongTest, operator_mul_equals_with_value)
   {
-    ls::Long x{6};
+    ls::std::boxing::Long x{6};
     x *= (ls::long_type) 3;
 
     ASSERT_EQ(18, x);
@@ -213,8 +212,8 @@ namespace
 
   TEST_F(LongTest, operator_div_equals_with_reference)
   {
-    ls::Long x{12};
-    ls::Long y{3};
+    ls::std::boxing::Long x{12};
+    ls::std::boxing::Long y{3};
     x /= y;
 
     ASSERT_EQ(4, x);
@@ -222,7 +221,7 @@ namespace
 
   TEST_F(LongTest, operator_div_equals_with_value)
   {
-    ls::Long x{12};
+    ls::std::boxing::Long x{12};
     x /= (ls::long_type) 3;
 
     ASSERT_EQ(4, x);
@@ -233,8 +232,8 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::Long x{9};
-                     ls::Long y{0};
+                     ls::std::boxing::Long x{9};
+                     ls::std::boxing::Long y{0};
 
                      x = x /= y;
                    } catch (const ls::IllegalArithmeticOperationException &_exception)
@@ -249,7 +248,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::Long x{9};
+                     ls::std::boxing::Long x{9};
                      x = x /= (ls::long_type) 0;
                    } catch (const ls::IllegalArithmeticOperationException &_exception)
                    {
@@ -262,87 +261,87 @@ namespace
 
   TEST_F(LongTest, operator_equals_with_reference)
   {
-    ls::Long x{12};
-    ls::Long y{12};
+    ls::std::boxing::Long x{12};
+    ls::std::boxing::Long y{12};
 
     ASSERT_TRUE(x == y);
   }
 
   TEST_F(LongTest, operator_equals_with_value)
   {
-    ls::Long x{12};
+    ls::std::boxing::Long x{12};
     ASSERT_TRUE(x == (ls::long_type) 12);
   }
 
   TEST_F(LongTest, operator_not_equals_with_reference)
   {
-    ls::Long x{12};
-    ls::Long y{3};
+    ls::std::boxing::Long x{12};
+    ls::std::boxing::Long y{3};
 
     ASSERT_TRUE(x != y);
   }
 
   TEST_F(LongTest, operator_not_equals_with_value)
   {
-    ls::Long x{12};
+    ls::std::boxing::Long x{12};
     ASSERT_TRUE(x != (ls::long_type) 3);
   }
 
   TEST_F(LongTest, operator_greater_than_with_reference)
   {
-    ls::Long x{12};
-    ls::Long y{3};
+    ls::std::boxing::Long x{12};
+    ls::std::boxing::Long y{3};
 
     ASSERT_TRUE(x > y);
   }
 
   TEST_F(LongTest, operator_greater_than_with_value)
   {
-    ls::Long x{12};
+    ls::std::boxing::Long x{12};
     ASSERT_TRUE(x > (ls::long_type) 3);
   }
 
   TEST_F(LongTest, operator_greater_than_equals_with_reference)
   {
-    ls::Long x{12};
-    ls::Long y{12};
+    ls::std::boxing::Long x{12};
+    ls::std::boxing::Long y{12};
 
     ASSERT_TRUE(x >= y);
   }
 
   TEST_F(LongTest, operator_greater_than_equals_with_value)
   {
-    ls::Long x{12};
+    ls::std::boxing::Long x{12};
     ASSERT_TRUE(x >= (ls::long_type) 12);
   }
 
   TEST_F(LongTest, operator_less_than_with_reference)
   {
-    ls::Long x{10};
-    ls::Long y{12};
+    ls::std::boxing::Long x{10};
+    ls::std::boxing::Long y{12};
 
     ASSERT_TRUE(x < y);
   }
 
   TEST_F(LongTest, operator_less_than_with_value)
   {
-    ls::Long x{10};
-    ls::Long y{12};
+    ls::std::boxing::Long x{10};
+    ls::std::boxing::Long y{12};
 
     ASSERT_TRUE(x < (ls::long_type) 12);
   }
 
   TEST_F(LongTest, operator_less_than_equals_with_reference)
   {
-    ls::Long x{10};
-    ls::Long y{10};
+    ls::std::boxing::Long x{10};
+    ls::std::boxing::Long y{10};
 
     ASSERT_TRUE(x <= y);
   }
 
   TEST_F(LongTest, operator_less_than_equals_with_value)
   {
-    ls::Long x{10};
+    ls::std::boxing::Long x{10};
     ASSERT_TRUE(x <= (ls::long_type) 10);
   }
 
@@ -350,47 +349,47 @@ namespace
 
   TEST_F(LongTest, operator_negation)
   {
-    ls::Long x{};
+    ls::std::boxing::Long x{};
     ASSERT_TRUE(!x);
   }
 
   TEST_F(LongTest, operator_and_with_reference)
   {
-    ls::Long x{1};
-    ls::Long y{1};
+    ls::std::boxing::Long x{1};
+    ls::std::boxing::Long y{1};
 
     ASSERT_TRUE(x && y);
   }
 
   TEST_F(LongTest, operator_and_with_value)
   {
-    ls::Long x{1};
+    ls::std::boxing::Long x{1};
     ASSERT_TRUE(x && (ls::long_type) 1);
   }
 
   TEST_F(LongTest, operator_and_with_boolean)
   {
-    ls::Long x{1};
+    ls::std::boxing::Long x{1};
     ASSERT_TRUE(x && true);
   }
 
   TEST_F(LongTest, operator_or_with_reference)
   {
-    ls::Long x{};
-    ls::Long y{1};
+    ls::std::boxing::Long x{};
+    ls::std::boxing::Long y{1};
 
     ASSERT_TRUE(x || y);
   }
 
   TEST_F(LongTest, operator_or_with_value)
   {
-    ls::Long x{};
+    ls::std::boxing::Long x{};
     ASSERT_TRUE(x || (ls::long_type) 1);
   }
 
   TEST_F(LongTest, operator_or_with_boolean)
   {
-    ls::Long x{};
+    ls::std::boxing::Long x{};
     ASSERT_TRUE(x || true);
   }
 
@@ -398,7 +397,7 @@ namespace
 
   TEST_F(LongTest, operator_increment)
   {
-    ls::Long x{};
+    ls::std::boxing::Long x{};
     ++x;
 
     ASSERT_EQ(1, x);
@@ -406,7 +405,7 @@ namespace
 
   TEST_F(LongTest, operator_decrement)
   {
-    ls::Long x{};
+    ls::std::boxing::Long x{};
     --x;
 
     ASSERT_EQ(-1, x);
@@ -416,7 +415,7 @@ namespace
 
   TEST_F(LongTest, parse_with_positive_value)
   {
-    ls::Long x{};
+    ls::std::boxing::Long x{};
 
     x.parse("1989");
     ASSERT_EQ(1989, x);
@@ -424,7 +423,7 @@ namespace
 
   TEST_F(LongTest, parse_with_negative_value)
   {
-    ls::Long x{};
+    ls::std::boxing::Long x{};
 
     x.parse("-17");
     ASSERT_EQ(-17, x);
@@ -432,7 +431,7 @@ namespace
 
   TEST_F(LongTest, toString)
   {
-    ls::Long x{112};
+    ls::std::boxing::Long x{112};
     ASSERT_STREQ("112", x.toString().c_str());
   }
 
@@ -440,7 +439,7 @@ namespace
 
   TEST_F(LongTest, getValue)
   {
-    ls::Long x{3};
+    ls::std::boxing::Long x{3};
     ASSERT_EQ(3, x.getValue());
   }
 
@@ -448,7 +447,7 @@ namespace
 
   TEST_F(LongTest, constApproach)
   {
-    const ls::Long x{3};
+    const ls::std::boxing::Long x{3};
     ASSERT_EQ(3, x);
 
     // x = 4; // wouldn't work

test/cases/boxing/StringTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -30,7 +30,7 @@ namespace
 
   TEST_F(StringTest, operator_assignment)
   {
-    ls::String text{};
+    ls::std::boxing::String text{};
     text = "Hi!";
 
     ASSERT_STREQ("Hi!", text.toString().c_str());
@@ -40,8 +40,8 @@ namespace
 
   TEST_F(StringTest, operator_add)
   {
-    ls::String greetings{"Hello! "};
-    ls::String question{"How are you? "};
+    ls::std::boxing::String greetings{"Hello! "};
+    ls::std::boxing::String question{"How are you? "};
     const std::string& answer = "I'm good by the way!";
 
     greetings = greetings + question + answer;
@@ -51,7 +51,7 @@ namespace
 
   TEST_F(StringTest, operator_minus)
   {
-    ls::String text{"abcdefghij"};
+    ls::std::boxing::String text{"abcdefghij"};
     text = text - 5;
 
     ASSERT_STREQ("abcde", text.toString().c_str());
@@ -61,8 +61,8 @@ namespace
 
   TEST_F(StringTest, operator_add_assign_with_reference)
   {
-    ls::String text{};
-    ls::String hello{"Hi!"};
+    ls::std::boxing::String text{};
+    ls::std::boxing::String hello{"Hi!"};
 
     text += hello;
     ASSERT_STREQ("Hi!", text.toString().c_str());
@@ -70,7 +70,7 @@ namespace
 
   TEST_F(StringTest, operator_add_assign_with_value)
   {
-    ls::String text{};
+    ls::std::boxing::String text{};
 
     text += "Hi!";
     ASSERT_STREQ("Hi!", text.toString().c_str());
@@ -80,8 +80,8 @@ namespace
 
   TEST_F(StringTest, operator_equals_with_reference)
   {
-    ls::String text{"Hi!"};
-    ls::String hello{"Hi!"};
+    ls::std::boxing::String text{"Hi!"};
+    ls::std::boxing::String hello{"Hi!"};
 
     ASSERT_TRUE(text == hello);
     ASSERT_TRUE(hello == text);
@@ -89,21 +89,21 @@ namespace
 
   TEST_F(StringTest, operator_equals_with_value)
   {
-    ls::String hello{"Hi!"};
+    ls::std::boxing::String hello{"Hi!"};
     ASSERT_TRUE(hello == "Hi!");
   }
 
   TEST_F(StringTest, operator_not_equals_with_reference)
   {
-    ls::String text{"Hi!"};
-    ls::String hello{"Hello!"};
+    ls::std::boxing::String text{"Hi!"};
+    ls::std::boxing::String hello{"Hello!"};
 
     ASSERT_TRUE(text != hello);
   }
 
   TEST_F(StringTest, operator_not_equals_with_value)
   {
-    ls::String text{"Hi!"};
+    ls::std::boxing::String text{"Hi!"};
     ASSERT_TRUE(text != "Hello!");
   }
 
@@ -111,7 +111,7 @@ namespace
 
   TEST_F(StringTest, parse)
   {
-    ls::String text{};
+    ls::std::boxing::String text{};
     text.parse("Hello!");
 
     ASSERT_STREQ("Hello!", text.toString().c_str());
@@ -119,7 +119,7 @@ namespace
 
   TEST_F(StringTest, toString)
   {
-    ls::String text{"Hello!"};
+    ls::std::boxing::String text{"Hello!"};
     ASSERT_STREQ("Hello!", text.toString().c_str());
   }
 
@@ -127,7 +127,7 @@ namespace
 
   TEST_F(StringTest, contains)
   {
-    ls::String text{};
+    ls::std::boxing::String text{};
     text = "Hey, I'm searching for the keyword 'cake'!";
 
     ASSERT_TRUE(text.contains("cake"));
@@ -135,7 +135,7 @@ namespace
 
   TEST_F(StringTest, contains_does_not_contain_search_word)
   {
-    ls::String text{};
+    ls::std::boxing::String text{};
     text = "Hey, I'm searching for the keyword 'cake'!";
 
     ASSERT_FALSE(text.contains("butter"));
@@ -143,7 +143,7 @@ namespace
 
   TEST_F(StringTest, endsWith)
   {
-    ls::String text{};
+    ls::std::boxing::String text{};
     text = "abcdef";
 
     ASSERT_TRUE(text.endsWith("ef"));
@@ -151,7 +151,7 @@ namespace
 
   TEST_F(StringTest, endsWith_does_not_end_with_pattern)
   {
-    ls::String text{};
+    ls::std::boxing::String text{};
     text = "abcdef";
 
     ASSERT_FALSE(text.endsWith("efg"));
@@ -159,8 +159,8 @@ namespace
 
   TEST_F(StringTest, equalsIgnoreCase)
   {
-    ls::String text{"Hello!"};
-    ls::String hello{"HeLLo!"};
+    ls::std::boxing::String text{"Hello!"};
+    ls::std::boxing::String hello{"HeLLo!"};
 
     ASSERT_TRUE(text.equalsIgnoreCase(hello));
     ASSERT_TRUE(text.equalsIgnoreCase("HeLLO!"));
@@ -168,16 +168,16 @@ namespace
 
   TEST_F(StringTest, getByteData)
   {
-    ls::String text{"Hallo!"};
+    ls::std::boxing::String text{"Hallo!"};
     ASSERT_STREQ("Hallo!", text.getByteData().data());
   }
 
   TEST_F(StringTest, padLeft)
   {
-    ls::String text{"abcdef"};
-    ls::String anotherText{"ab"};
-    ls::String emptyText{};
-    ls::String longText{"This text is too long to fill!"};
+    ls::std::boxing::String text{"abcdef"};
+    ls::std::boxing::String anotherText{"ab"};
+    ls::std::boxing::String emptyText{};
+    ls::std::boxing::String longText{"This text is too long to fill!"};
 
     ASSERT_STREQ("    abcdef", text.padLeft(10, ' ').c_str());
     ASSERT_STREQ("        ab", anotherText.padLeft(10, ' ').c_str());
@@ -187,10 +187,10 @@ namespace
 
   TEST_F(StringTest, padRight)
   {
-    ls::String text{"abcdef"};
-    ls::String anotherText{"ab"};
-    ls::String emptyText{};
-    ls::String longText{"This text is too long to fill!"};
+    ls::std::boxing::String text{"abcdef"};
+    ls::std::boxing::String anotherText{"ab"};
+    ls::std::boxing::String emptyText{};
+    ls::std::boxing::String longText{"This text is too long to fill!"};
 
     ASSERT_STREQ("abcdef    ", text.padRight(10, ' ').c_str());
     ASSERT_STREQ("ab        ", anotherText.padRight(10, ' ').c_str());
@@ -200,7 +200,7 @@ namespace
 
   TEST_F(StringTest, reverse)
   {
-    ls::String text{};
+    ls::std::boxing::String text{};
     text = "abcdef";
 
     ASSERT_STREQ("fedcba", text.reverse().c_str());
@@ -209,7 +209,7 @@ namespace
 
   TEST_F(StringTest, startsWith)
   {
-    ls::String text{};
+    ls::std::boxing::String text{};
     text = "abcdef";
 
     ASSERT_TRUE(text.startsWith("abc"));
@@ -217,7 +217,7 @@ namespace
 
   TEST_F(StringTest, startsWith_does_not_start_with_pattern)
   {
-    ls::String text{};
+    ls::std::boxing::String text{};
     text = "abcdef";
 
     ASSERT_FALSE(text.startsWith("bc"));
@@ -225,7 +225,7 @@ namespace
 
   TEST_F(StringTest, toLowerCase)
   {
-    ls::String text{};
+    ls::std::boxing::String text{};
     text = "aBCdeFgHIJKLmn";
 
     ASSERT_STREQ("abcdefghijklmn", text.toLowerCase().c_str());
@@ -234,7 +234,7 @@ namespace
 
   TEST_F(StringTest, toUpperCase)
   {
-    ls::String text{};
+    ls::std::boxing::String text{};
     text = "aBCdeFgHIJKLmn";
 
     ASSERT_STREQ("ABCDEFGHIJKLMN", text.toUpperCase().c_str());

test/cases/io/FileOutputStreamTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -80,7 +80,7 @@ namespace
     // validation
 
     ls::FileReader reader{file};
-    ls::String content{reader.read()};
+    ls::std::boxing::String content{reader.read()};
 
     ASSERT_TRUE(content.contains("Hello! How are you? I'm fine! Thank you!"));
 

test/cases/io/logging/LoggerTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -41,11 +41,11 @@ namespace
         return writer;
       }
 
-      static ls::String getContentFromLogFile(const std::string &_logName)
+      static ls::std::boxing::String getContentFromLogFile(const std::string &_logName)
       {
         ls::File file{TestHelper::getResourcesFolderLocation() + _logName};
         ls::FileReader reader{file};
-        ls::String content{reader.read()};
+        ls::std::boxing::String content{reader.read()};
         file.remove();
 
         return content;
@@ -85,7 +85,7 @@ namespace
     // get content and check
 
     std::dynamic_pointer_cast<ls::FileOutputStream>(writer)->close();
-    ls::String content = getContentFromLogFile(logName);
+    ls::std::boxing::String content = getContentFromLogFile(logName);
 
     ASSERT_TRUE(content.contains("1. line!"));
     ASSERT_TRUE(content.contains("2. line!"));
@@ -114,7 +114,7 @@ namespace
     // get content and check
 
     std::dynamic_pointer_cast<ls::FileOutputStream>(writer)->close();
-    ls::String content = getContentFromLogFile(logName);
+    ls::std::boxing::String content = getContentFromLogFile(logName);
 
     ASSERT_FALSE(content.contains("1. line!"));
     ASSERT_FALSE(content.contains("2. line!"));
@@ -143,7 +143,7 @@ namespace
     // get content and check
 
     std::dynamic_pointer_cast<ls::FileOutputStream>(writer)->close();
-    ls::String content = getContentFromLogFile(logName);
+    ls::std::boxing::String content = getContentFromLogFile(logName);
 
     ASSERT_FALSE(content.contains("1. line!"));
     ASSERT_FALSE(content.contains("2. line!"));
@@ -178,7 +178,7 @@ namespace
     // get content and check
 
     std::dynamic_pointer_cast<ls::FileOutputStream>(writer)->close();
-    ls::String content = getContentFromLogFile(logName);
+    ls::std::boxing::String content = getContentFromLogFile(logName);
 
     ASSERT_TRUE(content.contains("1. line!"));
     ASSERT_TRUE(content.contains("2. line!"));
@@ -215,7 +215,7 @@ namespace
     // get content and check
 
     std::dynamic_pointer_cast<ls::FileOutputStream>(writer)->close();
-    ls::String content = getContentFromLogFile(logName);
+    ls::std::boxing::String content = getContentFromLogFile(logName);
 
     ASSERT_TRUE(content.contains("1. line!"));
     ASSERT_TRUE(content.contains("2. line!"));
@@ -244,7 +244,7 @@ namespace
     // get content and check
 
     std::dynamic_pointer_cast<ls::FileOutputStream>(writer)->close();
-    ls::String content = getContentFromLogFile(logName);
+    ls::std::boxing::String content = getContentFromLogFile(logName);
 
     ASSERT_TRUE(content.contains("1. line!"));
     ASSERT_TRUE(content.contains("2. line!"));

test/cases/io/xml/XmlNodeTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-25
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -905,7 +905,7 @@ namespace
     attribute->setValue("important");
     singleLineElement->addAttributeToEnd(attribute);
 
-    ls::String xmlContent{singleLineElement->toXml()};
+    ls::std::boxing::String xmlContent{singleLineElement->toXml()};
     std::string expectedXmlString = R"(<info id="important" />)";
 
     ASSERT_TRUE(xmlContent.contains(expectedXmlString));

test/cases/logic/NarratorTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -142,7 +142,7 @@ namespace
     ASSERT_STREQ("blue", this->mercedes2->getColor().c_str());
     ASSERT_STREQ("red", this->mercedes3->getColor().c_str());
 
-    ls::String newColor{"black"};
+    ls::std::boxing::String newColor{"black"};
     paintingMachine.tell(static_cast<const ls::Class &>(newColor));
 
     ASSERT_STREQ("black", this->mercedes1->getColor().c_str());

test/cases/logic/serialization/SerializableJsonStateConnectionTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-14
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -46,7 +46,7 @@ namespace
   {
     ls::StateConnection x{"AB", "B"};
     ls::SerializableJsonStateConnection serializable{std::make_shared<ls::StateConnection>(x)};
-    ls::String jsonString{serializable.marshal()};
+    ls::std::boxing::String jsonString{serializable.marshal()};
 
     ASSERT_STREQ(R"({"condition":false,"connectionId":"AB","stateId":"B"})", jsonString.toString().c_str());
   }
@@ -77,7 +77,7 @@ namespace
   {
     ls::StateConnection x{"AB", "B"};
     ls::SerializableJsonStateConnection serializable{std::make_shared<ls::StateConnection>(x)};
-    ls::String jsonString{serializable.marshal()};
+    ls::std::boxing::String jsonString{serializable.marshal()};
 
     ASSERT_STREQ(R"({"condition":false,"connectionId":"AB","stateId":"B"})", jsonString.toString().c_str());
 

test/cases/logic/serialization/SerializableJsonStateMachineTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-17
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -56,7 +56,7 @@ namespace
 
     ls::File file{TestHelper::getResourcesFolderLocation() + "/state_machine_test.json"};
     ls::FileReader reader{file};
-    ls::String data{reader.read()};
+    ls::std::boxing::String data{reader.read()};
 
     ASSERT_TRUE(data.contains(jsonString));
   }

test/classes/observer/TestDataMercedesCar.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -17,5 +17,5 @@ ls_std_test::TestDataMercedesCar::TestDataMercedesCar() : TestDataCar()
 
 void ls_std_test::TestDataMercedesCar::listen(const ls::Class &_info)
 {
-  this->setColor(dynamic_cast<const ls::String &>(_info));
+  this->setColor(dynamic_cast<const ls::std::boxing::String &>(_info));
 }