Create namespace "boxing" for boxing module

include/ls_std/boxing/Boolean.hpp

@@ -16,68 +16,74 @@
 
 namespace ls
 {
-  class Boolean : public ls::Class, public ls::IBoxing
+  namespace std
   {
-    public:
+    namespace boxing
+    {
+      class Boolean : public ls::Class, public ls::std::boxing::IBoxing
+      {
+        public:
 
-      explicit Boolean(bool _value);
-      Boolean();
-      ~Boolean() override = default;
+          explicit Boolean(bool _value);
+          Boolean();
+          ~Boolean() override = default;
 
-      // conversion operator
+          // conversion operator
 
-      operator bool() const;
+          operator bool() const;
 
-      // assignment operators
+          // assignment operators
 
-      ls::Boolean &operator=(int _value);
-      ls::Boolean &operator=(bool _value);
+          ls::std::boxing::Boolean &operator=(int _value);
+          ls::std::boxing::Boolean &operator=(bool _value);
 
-      // stream operators
+          // stream operators
 
-      friend std::ostream &operator<<(std::ostream &_outputStream, const ls::Boolean &_boolean)
-      {
-        _outputStream << _boolean._toString();
-        return _outputStream;
-      }
+          friend ::std::ostream &operator<<(::std::ostream &_outputStream, const ls::std::boxing::Boolean &_boolean)
+          {
+            _outputStream << _boolean._toString();
+            return _outputStream;
+          }
 
-      // logical operators
+          // logical operators
 
-      friend bool operator!(const ls::Boolean &_boolean)
-      {
-        return !_boolean.value;
-      }
+          friend bool operator!(const ls::std::boxing::Boolean &_boolean)
+          {
+            return !_boolean.value;
+          }
 
-      bool operator&&(const ls::Boolean &_boolean) const;
-      bool operator&&(bool _value) const;
-      bool operator&&(int _value) const;
-      bool operator||(const ls::Boolean &_boolean) const;
-      bool operator||(bool _value) const;
-      bool operator||(int _value) const;
-      // INFO: operator ^ can not be taken for XOR, since it's not possible to implement it respecting commutative law
+          bool operator&&(const ls::std::boxing::Boolean &_boolean) const;
+          bool operator&&(bool _value) const;
+          bool operator&&(int _value) const;
+          bool operator||(const ls::std::boxing::Boolean &_boolean) const;
+          bool operator||(bool _value) const;
+          bool operator||(int _value) const;
+          // INFO: operator ^ can not be taken for XOR, since it's not possible to implement it respecting commutative law
 
-      // 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 getValue() const;
-      static bool XOR(const ls::Boolean &_leftExpression, const ls::Boolean &_rightExpression);
-      static bool XOR(const ls::Boolean &_leftExpression, bool _rightExpression);
-      static bool XOR(bool _leftExpression, const ls::Boolean &_rightExpression);
-      static bool XOR(bool _leftExpression, bool _rightExpression);
+          bool getValue() const;
+          static bool XOR(const ls::std::boxing::Boolean &_leftExpression, const ls::std::boxing::Boolean &_rightExpression);
+          static bool XOR(const ls::std::boxing::Boolean &_leftExpression, bool _rightExpression);
+          static bool XOR(bool _leftExpression, const ls::std::boxing::Boolean &_rightExpression);
+          static bool XOR(bool _leftExpression, bool _rightExpression);
 
-    private:
+        private:
 
-      bool value{};
+          bool value{};
 
-      const std::string FALSE_STRING = "false";
-      const std::string TRUE_STRING = "true";
+          const ::std::string FALSE_STRING = "false";
+          const ::std::string TRUE_STRING = "true";
 
-      std::string _toString() const;
-  };
+          ::std::string _toString() const;
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/boxing/Double.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -16,83 +16,89 @@
 
 namespace ls
 {
-  class Double : public ls::Class, public ls::IBoxing
+  namespace std
   {
-    public:
+    namespace boxing
+    {
+      class Double : public ls::Class, public ls::std::boxing::IBoxing
+      {
+        public:
 
-      Double();
-      explicit Double(double _value);
-      ~Double() override = default;
+          Double();
+          explicit Double(double _value);
+          ~Double() override = default;
 
-      // conversion operator
+          // conversion operator
 
-      operator double() const; // do not make explicit!
+          operator double() const; // do not make explicit!
 
-      // assignment operators
+          // assignment operators
 
-      ls::Double &operator=(double _value);
+          ls::std::boxing::Double &operator=(double _value);
 
-      // arithmetic operators
+          // arithmetic operators
 
-      double operator-() const;
-      double operator+(const ls::Double &_double) const;
-      double operator+(double _value) const;
-      double operator*(const ls::Double &_double) const;
-      double operator*(double _value) const;
-      double operator-(const ls::Double &_double) const;
-      double operator-(double _value) const;
-      double operator/(const ls::Double &_double) const;
-      double operator/(double _value) const;
+          double operator-() const;
+          double operator+(const ls::std::boxing::Double &_double) const;
+          double operator+(double _value) const;
+          double operator*(const ls::std::boxing::Double &_double) const;
+          double operator*(double _value) const;
+          double operator-(const ls::std::boxing::Double &_double) const;
+          double operator-(double _value) const;
+          double operator/(const ls::std::boxing::Double &_double) const;
+          double operator/(double _value) const;
 
-      // compound operators
+          // compound operators
 
-      ls::Double &operator+=(const ls::Double &_double);
-      ls::Double &operator+=(double _value);
-      ls::Double &operator-=(const ls::Double &_double);
-      ls::Double &operator-=(double _value);
-      ls::Double &operator*=(const ls::Double &_double);
-      ls::Double &operator*=(double _value);
-      ls::Double &operator/=(const ls::Double &_double);
-      ls::Double &operator/=(double _value);
+          ls::std::boxing::Double &operator+=(const ls::std::boxing::Double &_double);
+          ls::std::boxing::Double &operator+=(double _value);
+          ls::std::boxing::Double &operator-=(const ls::std::boxing::Double &_double);
+          ls::std::boxing::Double &operator-=(double _value);
+          ls::std::boxing::Double &operator*=(const ls::std::boxing::Double &_double);
+          ls::std::boxing::Double &operator*=(double _value);
+          ls::std::boxing::Double &operator/=(const ls::std::boxing::Double &_double);
+          ls::std::boxing::Double &operator/=(double _value);
 
-      // comparison operators
+          // comparison operators
 
-      bool operator==(const ls::Double &_double) const;
-      bool operator==(double _value) const;
-      bool operator!=(const ls::Double &_double) const;
-      bool operator!=(double _value) const;
-      bool operator>(const ls::Double &_double) const;
-      bool operator>(double _value) const;
-      bool operator>=(const ls::Double &_double) const;
-      bool operator>=(double _value) const;
-      bool operator<(const ls::Double &_double) const;
-      bool operator<(double _value) const;
-      bool operator<=(const ls::Double &_double) const;
-      bool operator<=(double _value) const;
+          bool operator==(const ls::std::boxing::Double &_double) const;
+          bool operator==(double _value) const;
+          bool operator!=(const ls::std::boxing::Double &_double) const;
+          bool operator!=(double _value) const;
+          bool operator>(const ls::std::boxing::Double &_double) const;
+          bool operator>(double _value) const;
+          bool operator>=(const ls::std::boxing::Double &_double) const;
+          bool operator>=(double _value) const;
+          bool operator<(const ls::std::boxing::Double &_double) const;
+          bool operator<(double _value) const;
+          bool operator<=(const ls::std::boxing::Double &_double) const;
+          bool operator<=(double _value) const;
 
-      // increment / decrement operator
+          // increment / decrement operator
 
-      void operator++();
-      void operator--();
+          void operator++();
+          void operator--();
 
-      // 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
 
-      double getEpsilon();
-      double getValue();
-      void setEpsilon(double _epsilon);
+          double getEpsilon();
+          double getValue();
+          void setEpsilon(double _epsilon);
 
-    private:
+        private:
 
-      double epsilon{};
-      double value{};
+          double epsilon{};
+          double value{};
 
-      void _assignEpsilon(double _epsilon);
-  };
+          void _assignEpsilon(double _epsilon);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/boxing/Float.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -16,83 +16,89 @@
 
 namespace ls
 {
-  class Float : public ls::Class, public ls::IBoxing
+  namespace std
   {
-    public:
+    namespace boxing
+    {
+      class Float : public ls::Class, public ls::std::boxing::IBoxing
+      {
+        public:
 
-      Float();
-      explicit Float(float _value);
-      ~Float() override = default;
+          Float();
+          explicit Float(float _value);
+          ~Float() override = default;
 
-      // conversion operator
+          // conversion operator
 
-      operator float() const; // do not make explicit!
+          operator float() const; // do not make explicit!
 
-      // assignment operators
+          // assignment operators
 
-      ls::Float &operator=(float _value);
+          ls::std::boxing::Float &operator=(float _value);
 
-      // arithmetic operators
+          // arithmetic operators
 
-      float operator-() const;
-      float operator+(const ls::Float &_float) const;
-      float operator+(float _value) const;
-      float operator*(const ls::Float &_float) const;
-      float operator*(float _value) const;
-      float operator-(const ls::Float &_float) const;
-      float operator-(float _value) const;
-      float operator/(const ls::Float &_float) const;
-      float operator/(float _value) const;
+          float operator-() const;
+          float operator+(const ls::std::boxing::Float &_float) const;
+          float operator+(float _value) const;
+          float operator*(const ls::std::boxing::Float &_float) const;
+          float operator*(float _value) const;
+          float operator-(const ls::std::boxing::Float &_float) const;
+          float operator-(float _value) const;
+          float operator/(const ls::std::boxing::Float &_float) const;
+          float operator/(float _value) const;
 
-      // compound operators
+          // compound operators
 
-      ls::Float &operator+=(const ls::Float &_float);
-      ls::Float &operator+=(float _value);
-      ls::Float &operator-=(const ls::Float &_float);
-      ls::Float &operator-=(float _value);
-      ls::Float &operator*=(const ls::Float &_float);
-      ls::Float &operator*=(float _value);
-      ls::Float &operator/=(const ls::Float &_float);
-      ls::Float &operator/=(float _value);
+          ls::std::boxing::Float &operator+=(const ls::std::boxing::Float &_float);
+          ls::std::boxing::Float &operator+=(float _value);
+          ls::std::boxing::Float &operator-=(const ls::std::boxing::Float &_float);
+          ls::std::boxing::Float &operator-=(float _value);
+          ls::std::boxing::Float &operator*=(const ls::std::boxing::Float &_float);
+          ls::std::boxing::Float &operator*=(float _value);
+          ls::std::boxing::Float &operator/=(const ls::std::boxing::Float &_float);
+          ls::std::boxing::Float &operator/=(float _value);
 
-      // comparison operators
+          // comparison operators
 
-      bool operator==(const ls::Float &_float) const;
-      bool operator==(float _value) const;
-      bool operator!=(const ls::Float &_float) const;
-      bool operator!=(float _value) const;
-      bool operator>(const ls::Float &_float) const;
-      bool operator>(float _value) const;
-      bool operator>=(const ls::Float &_float) const;
-      bool operator>=(float _value) const;
-      bool operator<(const ls::Float &_float) const;
-      bool operator<(float _value) const;
-      bool operator<=(const ls::Float &_float) const;
-      bool operator<=(float _value) const;
+          bool operator==(const ls::std::boxing::Float &_float) const;
+          bool operator==(float _value) const;
+          bool operator!=(const ls::std::boxing::Float &_float) const;
+          bool operator!=(float _value) const;
+          bool operator>(const ls::std::boxing::Float &_float) const;
+          bool operator>(float _value) const;
+          bool operator>=(const ls::std::boxing::Float &_float) const;
+          bool operator>=(float _value) const;
+          bool operator<(const ls::std::boxing::Float &_float) const;
+          bool operator<(float _value) const;
+          bool operator<=(const ls::std::boxing::Float &_float) const;
+          bool operator<=(float _value) const;
 
-      // increment / decrement operator
+          // increment / decrement operator
 
-      void operator++();
-      void operator--();
+          void operator++();
+          void operator--();
 
-      // 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
 
-      float getEpsilon();
-      float getValue();
-      void setEpsilon(float _epsilon);
+          float getEpsilon();
+          float getValue();
+          void setEpsilon(float _epsilon);
 
-    private:
+        private:
 
-      float epsilon{};
-      float value{};
+          float epsilon{};
+          float value{};
 
-      void _assignEpsilon(float _epsilon);
-  };
+          void _assignEpsilon(float _epsilon);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/boxing/IBoxing.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -14,16 +14,22 @@
 
 namespace ls
 {
-  class IBoxing
+  namespace std
   {
-    public:
+    namespace boxing
+    {
+      class IBoxing
+      {
+        public:
 
-      IBoxing() = default;
-      ~IBoxing() = default;
+          IBoxing() = default;
+          ~IBoxing() = default;
 
-      virtual void parse(std::string _parseText) = 0;
-      virtual std::string toString() = 0;
-  };
+          virtual void parse(::std::string _parseText) = 0;
+          virtual ::std::string toString() = 0;
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/boxing/Integer.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -18,7 +18,7 @@
 
 namespace ls
 {
-  class Integer : public ls::Class, public ls::IBoxing
+  class Integer : public ls::Class, public ls::std::boxing::IBoxing
   {
     public:
 
@@ -95,8 +95,8 @@ namespace ls
 
       // implementation
 
-      void parse(std::string _parseText) override;
-      std::string toString() override;
+      void parse(::std::string _parseText) override;
+      ::std::string toString() override;
 
       // additional functionality
 

include/ls_std/boxing/Long.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -19,7 +19,7 @@
 
 namespace ls
 {
-  class Long : public ls::Class, public ls::IBoxing
+  class Long : public ls::Class, public ls::std::boxing::IBoxing
   {
     public:
 
@@ -96,8 +96,8 @@ namespace ls
 
       // implementation
 
-      void parse(std::string _parseText) override;
-      std::string toString() override;
+      void parse(::std::string _parseText) override;
+      ::std::string toString() override;
 
       // additional functionality
 

include/ls_std/boxing/String.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -19,69 +19,69 @@
 
 namespace ls
 {
-  class String : public ls::Class, public ls::IBoxing
+  class String : public ls::Class, public ls::std::boxing::IBoxing
   {
     public:
 
       String();
-      explicit String(std::string _value);
+      explicit String(::std::string _value);
       ~String() override = default;
 
       // conversion operator
 
       operator const char *() const; // do not make explicit!
-      operator std::string() const; // do not make explicit!
+      operator ::std::string() const; // do not make explicit!
 
       // assignment operators
 
-      ls::String &operator=(std::string _value);
+      ls::String &operator=(::std::string _value);
 
       // 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::String _string) const;
+      ::std::string operator+(const ::std::string &_string) const;
+      ::std::string operator+(const char *_string) const;
+      ::std::string operator-(int _number);
 
       // compound operators
 
       ls::String &operator+=(ls::String _string);
-      ls::String &operator+=(const std::string &_text);
+      ls::String &operator+=(const ::std::string &_text);
 
       // comparison operators
 
       bool operator==(ls::String _string);
-      bool operator==(const std::string &_value);
+      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 ::std::string &_value);
       bool operator!=(const char *_value);
 
       // implementation
 
-      void parse(std::string _parseText) override;
-      std::string toString() override;
+      void parse(::std::string _parseText) override;
+      ::std::string toString() override;
 
       // additional functionality
 
-      bool contains(const std::string &_text);
-      bool endsWith(const std::string &_text);
+      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 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:
 
-      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);
   };
 }
 

include/ls_std/core/Class.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -18,16 +18,16 @@ namespace ls
   {
     public:
 
-      explicit Class(const std::string &_name);
+      explicit Class(const ::std::string &_name);
       virtual ~Class() = default;
 
-      std::string getClassName();
+      ::std::string getClassName();
 
     private:
 
-      std::string name{};
+      ::std::string name{};
 
-      void _assignClassName(const std::string &_name);
+      void _assignClassName(const ::std::string &_name);
   };
 }
 

include/ls_std/core/LibraryVersion.hpp

@@ -14,7 +14,7 @@
 
 namespace ls
 {
-  static std::string getVersion()
+  static ::std::string getVersion()
   {
     return "2022.1.0";
   }

include/ls_std/core/Types.hpp

@@ -15,7 +15,7 @@
 namespace ls
 {
   using byte = char;
-  using byte_field = std::string;
+  using byte_field = ::std::string;
   using long_type = long long int;
   using version_type = uint16_t;
 }

include/ls_std/core/Version.hpp

@@ -33,7 +33,7 @@ namespace ls
       ls::version_type getMajorVersion() const;
       ls::version_type getMinorVersion() const;
       ls::version_type getPatchVersion() const;
-      static bool isValid(const std::string &_versionString);
+      static bool isValid(const ::std::string &_versionString);
       void setMajorVersion(ls::version_type _major);
       void setMinorVersion(ls::version_type _minor);
       void setPatchVersion(ls::version_type _patch);
@@ -44,7 +44,7 @@ namespace ls
       ls::version_type minorVersion{};
       ls::version_type patchVersion{};
 
-      static bool _isValid(const std::string &_versionString);
+      static bool _isValid(const ::std::string &_versionString);
   };
 }
 

include/ls_std/core/exception/EventNotHandledException.hpp

@@ -14,7 +14,7 @@
 
 namespace ls
 {
-  class EventNotHandledException : public std::exception
+  class EventNotHandledException : public ::std::exception
   {
     public:
 

include/ls_std/core/exception/EventNotSubscribedException.hpp

@@ -14,7 +14,7 @@
 
 namespace ls
 {
-  class EventNotSubscribedException : public std::exception
+  class EventNotSubscribedException : public ::std::exception
   {
     public:
 

include/ls_std/core/exception/FileNotFoundException.hpp

@@ -17,7 +17,7 @@
 // TODO: pass parameters, use class, show class name
 namespace ls
 {
-  class FileNotFoundException : public std::exception
+  class FileNotFoundException : public ::std::exception
   {
     public:
 

include/ls_std/core/exception/FileOperationException.hpp

@@ -15,7 +15,7 @@
 
 namespace ls
 {
-  class FileOperationException : public std::exception
+  class FileOperationException : public ::std::exception
   {
     public:
 

include/ls_std/core/exception/IllegalArgumentException.hpp

@@ -14,7 +14,7 @@
 
 namespace ls
 {
-  class IllegalArgumentException : public std::exception
+  class IllegalArgumentException : public ::std::exception
   {
     public:
 

include/ls_std/core/exception/IllegalArithmeticOperationException.hpp

@@ -14,7 +14,7 @@
 
 namespace ls
 {
-  class IllegalArithmeticOperationException : public std::exception
+  class IllegalArithmeticOperationException : public ::std::exception
   {
     public:
 

include/ls_std/core/exception/IncompleteJsonException.hpp

@@ -14,7 +14,7 @@
 
 namespace ls
 {
-  class IncompleteJsonException : public std::exception
+  class IncompleteJsonException : public ::std::exception
   {
     public:
 

include/ls_std/core/exception/NullPointerException.hpp

@@ -14,7 +14,7 @@
 
 namespace ls
 {
-  class NullPointerException : public std::exception
+  class NullPointerException : public ::std::exception
   {
     public:
 

include/ls_std/core/factory/IFactory.hpp

@@ -22,7 +22,7 @@ namespace ls
       IFactory() = default;
       ~IFactory() = default;
 
-      virtual std::shared_ptr<ls::Class> build() = 0;
+      virtual ::std::shared_ptr<ls::Class> build() = 0;
   };
 }
 

include/ls_std/core/utils/RegexUtils.hpp

@@ -22,10 +22,10 @@ namespace ls
       RegexUtils() = default;
       ~RegexUtils() = default;
 
-      static std::string escapeString(const std::string &_text)
+      static ::std::string escapeString(const ::std::string &_text)
       {
-        static std::regex regexMetaEscape(R"(([\^\$\\\.\*\+\?\(\)\[\]\{\}\|]))");
-        return std::regex_replace(_text, regexMetaEscape, R"(\$1)");
+        static ::std::regex regexMetaEscape(R"(([\^\$\\\.\*\+\?\(\)\[\]\{\}\|]))");
+        return ::std::regex_replace(_text, regexMetaEscape, R"(\$1)");
       }
   };
 }

include/ls_std/core/utils/STLUtils.hpp

@@ -25,11 +25,11 @@ namespace ls
       template<class container, class dataType>
       static bool contains(container _container, const dataType &_value)
       {
-        return std::find(_container.begin(), _container.end(), _value) != _container.end();
+        return ::std::find(_container.begin(), _container.end(), _value) != _container.end();
       }
 
       template<class dataType>
-      static dataType getListElementAt(const std::list<dataType> &_list, size_t _index)
+      static dataType getListElementAt(const ::std::list<dataType> &_list, size_t _index)
       {
         dataType value{};
         size_t counter{};

include/ls_std/core/utils/WindowsUtils.hpp

@@ -23,12 +23,12 @@ namespace ls
       WindowsUtils() = default;
       ~WindowsUtils() = default;
 
-      static std::string getMessageFromErrorCode(const int &_errorCode)
+      static ::std::string getMessageFromErrorCode(const int &_errorCode)
       {
         ls::byte messageBuffer[256 + 1];
         FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, _errorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), messageBuffer, sizeof(messageBuffer), nullptr);
 
-        return std::string{messageBuffer};
+        return ::std::string{messageBuffer};
       }
   };
 }

include/ls_std/event/EventManager.hpp

@@ -28,22 +28,22 @@ namespace ls
 
       // implementation
 
-      void subscribe(const ls::event_id &_id, const std::shared_ptr<ls::IListener> &_listener) override;
-      void unsubscribe(const ls::event_id &_id, const std::shared_ptr<ls::IListener> &_listener) override;
+      void subscribe(const ls::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener) override;
+      void unsubscribe(const ls::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener) override;
 
       // additional functionality
 
-      bool addEventHandler(const std::shared_ptr<ls::EventHandler> &_eventHandler);
+      bool addEventHandler(const ::std::shared_ptr<ls::EventHandler> &_eventHandler);
       void fire(ls::Event _event);
       bool hasEventHandler(const ls::event_id &_id);
-      bool removeEventHandler(const std::shared_ptr<ls::EventHandler> &_eventHandler);
+      bool removeEventHandler(const ::std::shared_ptr<ls::EventHandler> &_eventHandler);
 
     private:
 
-      std::map<ls::event_id, std::shared_ptr<ls::EventHandler>> eventHandlers{};
+      ::std::map<ls::event_id, ::std::shared_ptr<ls::EventHandler>> eventHandlers{};
 
       bool _hasEventHandler(const ls::event_id &_id);
-      bool _removeEventHandler(const std::shared_ptr<ls::EventHandler> &_eventHandler);
+      bool _removeEventHandler(const ::std::shared_ptr<ls::EventHandler> &_eventHandler);
   };
 }
 

include/ls_std/event/EventTypes.hpp

@@ -16,11 +16,11 @@
 
 namespace ls
 {
-  using event_id = std::string;
-  using event_parameter_id = std::string;
-  using event_parameter_value = std::string;
-  using event_parameter = std::pair<std::string, std::string>;
-  using event_parameter_list = std::map<ls::event_parameter_id, ls::event_parameter_value>;
+  using event_id = ::std::string;
+  using event_parameter_id = ::std::string;
+  using event_parameter_value = ::std::string;
+  using event_parameter = ::std::pair<::std::string, ::std::string>;
+  using event_parameter_list = ::std::map<ls::event_parameter_id, ls::event_parameter_value>;
 }
 
 #endif

include/ls_std/event/IEventSubscriber.hpp

@@ -23,8 +23,8 @@ namespace ls
       IEventSubscriber() = default;
       ~IEventSubscriber() = default;
 
-      virtual void subscribe(const ls::event_id &_id, const std::shared_ptr<ls::IListener> &_listener) = 0;
-      virtual void unsubscribe(const ls::event_id &_id, const std::shared_ptr<ls::IListener> &_listener) = 0;
+      virtual void subscribe(const ls::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener) = 0;
+      virtual void unsubscribe(const ls::event_id &_id, const ::std::shared_ptr<ls::IListener> &_listener) = 0;
   };
 }
 

include/ls_std/event/serialization/SerializableJsonEvent.hpp

@@ -22,7 +22,7 @@ namespace ls
   {
     public:
 
-      explicit SerializableJsonEvent(const std::shared_ptr<ls::Event> &_value);
+      explicit SerializableJsonEvent(const ::std::shared_ptr<ls::Event> &_value);
       ~SerializableJsonEvent() override = default;
 
       // implementation
@@ -32,15 +32,15 @@ namespace ls
 
       // additional functionality
 
-      std::shared_ptr<ls::Event> getValue();
-      void setValue(const std::shared_ptr<ls::Event> &_value);
+      ::std::shared_ptr<ls::Event> getValue();
+      void setValue(const ::std::shared_ptr<ls::Event> &_value);
 
     private:
 
       nlohmann::json jsonObject{};
-      std::shared_ptr<ls::Event> value{};
+      ::std::shared_ptr<ls::Event> value{};
 
-      void _assignValue(const std::shared_ptr<ls::Event> &_value);
+      void _assignValue(const ::std::shared_ptr<ls::Event> &_value);
       void _unmarshalParameterList();
       void _update();
       void _updateEventParameterList();

include/ls_std/io/File.hpp

@@ -35,7 +35,7 @@ namespace ls
   {
     public:
 
-      explicit File(std::string _absoluteFilePath);
+      explicit File(::std::string _absoluteFilePath);
       ~File() override = default;
 
       // comparison operators
@@ -50,73 +50,73 @@ namespace ls
       bool canWrite();
       void createNewFile();
       bool exists();
-      std::string getAbsoluteFilePath();
-      std::string getName();
-      std::string getParent();
-      static std::string getWorkingDirectory();
+      ::std::string getAbsoluteFilePath();
+      ::std::string getName();
+      ::std::string getParent();
+      static ::std::string getWorkingDirectory();
       long getSize();
       bool isDirectory();
       bool isFile();
       time_t lastModified();
-      std::list<std::string> list();
-      std::list<std::string> listFiles();
+      ::std::list<::std::string> list();
+      ::std::list<::std::string> listFiles();
       void makeDirectory();
       void makeDirectories();
       void remove();
-      bool renameTo(const std::string &_newName);
-      void reset(const std::string &_newPath);
+      bool renameTo(const ::std::string &_newName);
+      void reset(const ::std::string &_newPath);
 
     private:
 
-      std::string absoluteFilePath{};
+      ::std::string absoluteFilePath{};
 
       #if defined(unix) || defined(__APPLE__)
-      static void _addToFileListUnix(const std::string &_path, bool _withDirectories, dirent *directoryEntity, std::list<std::string> &_list);
+      static void _addToFileListUnix(const ::std::string &_path, bool _withDirectories, dirent *directoryEntity, ::std::list<::std::string> &_list);
       #endif
       #ifdef _WIN32
-      static void _addToFileListWindows(const std::string &_path, bool _withDirectories, WIN32_FIND_DATA _data, std::list<std::string> &_list);
+      static void _addToFileListWindows(const ::std::string &_path, bool _withDirectories, WIN32_FIND_DATA _data, ::std::list<::std::string> &_list);
       #endif
       static bool _equals(ls::File &_file, ls::File &_foreignFile);
-      static bool _exists(const std::string &_path);
-      static std::string _getParent(const std::string &_path);
+      static bool _exists(const ::std::string &_path);
+      static ::std::string _getParent(const ::std::string &_path);
       #if defined(unix) || defined(__APPLE__)
-      static std::string _getWorkingDirectoryUnix();
+      static ::std::string _getWorkingDirectoryUnix();
       #endif
       #ifdef _WIN32
-      static std::string _getWorkingDirectoryWindows();
+      static ::std::string _getWorkingDirectoryWindows();
       #endif
-      static bool _isDirectory(const std::string &_path);
-      static bool _isExecutable(const std::string &_path);
-      static bool _isFile(const std::string &_path);
+      static bool _isDirectory(const ::std::string &_path);
+      static bool _isExecutable(const ::std::string &_path);
+      static bool _isFile(const ::std::string &_path);
       #if defined(unix) || defined(__APPLE__)
-      static bool _isReadableUnix(const std::string &_path);
+      static bool _isReadableUnix(const ::std::string &_path);
       #endif
       #ifdef _WIN32
-      static bool _isReadableWindows(const std::string &_path);
+      static bool _isReadableWindows(const ::std::string &_path);
       #endif
-      static bool _isWritable(const std::string &_path);
-      static time_t _lastModified(const std::string &_path);
-      static std::list<std::string> _list(const std::string &_path);
-      static std::list<std::string> _listFiles(const std::string &_path);
+      static bool _isWritable(const ::std::string &_path);
+      static time_t _lastModified(const ::std::string &_path);
+      static ::std::list<::std::string> _list(const ::std::string &_path);
+      static ::std::list<::std::string> _listFiles(const ::std::string &_path);
       #if defined(unix) || defined(__APPLE__)
-      static std::list<std::string> _listUnix(const std::string &_path, bool withDirectories);
+      static ::std::list<::std::string> _listUnix(const ::std::string &_path, bool withDirectories);
       #endif
       #ifdef _WIN32
-      static std::list<std::string> _listWindows(const std::string &_path, bool withDirectories);
+      static ::std::list<::std::string> _listWindows(const ::std::string &_path, bool withDirectories);
       #endif
-      static int _mkdir(const std::string &_path);
-      static std::string _normalizePath(std::string _path);
-      static std::string _reduceSeparators(const std::string &_path);
-      static void _remove(const std::string &_path);
+      static int _mkdir(const ::std::string &_path);
+      static ::std::string _normalizePath(::std::string _path);
+      static ::std::string _reduceSeparators(const ::std::string &_path);
+      static void _remove(const ::std::string &_path);
       #if defined(unix) || defined(__APPLE__)
-      static void _removeUnix(const std::string &_path);
+      static void _removeUnix(const ::std::string &_path);
       #endif
       #ifdef _WIN32
-      static void _removeWindows(const std::string &_path);
+      static void _removeWindows(const ::std::string &_path);
       #endif
-      static bool _renameTo(const std::string &_oldName, const std::string &_newName);
-      static std::string _replaceWrongSeparator(std::string _path);
-      static std::vector<std::string> _splitIntoSubDirectoryNames(const std::string &_path);
+      static bool _renameTo(const ::std::string &_oldName, const ::std::string &_newName);
+      static ::std::string _replaceWrongSeparator(::std::string _path);
+      static ::std::vector<::std::string> _splitIntoSubDirectoryNames(const ::std::string &_path);
   };
 }
 

include/ls_std/io/FileOutputStream.hpp

@@ -32,7 +32,7 @@ namespace ls
 
       bool append{};
       ls::File file;
-      std::ofstream outputStream{};
+      ::std::ofstream outputStream{};
 
       void _close();
       void _init();

include/ls_std/io/NewLine.hpp

@@ -21,9 +21,9 @@ namespace ls
       NewLine() = default;
       ~NewLine() = default;
 
-      static std::string get()
+      static ::std::string get()
       {
-        std::string newLine{};
+        ::std::string newLine{};
 
         #if defined(unix) || defined(__APPLE__)
         newLine = ls::NewLine::getUnixNewLine();
@@ -35,12 +35,12 @@ namespace ls
         return newLine;
       }
 
-      static std::string getUnixNewLine()
+      static ::std::string getUnixNewLine()
       {
         return "\n";
       }
 
-      static std::string getWindowsNewLine()
+      static ::std::string getWindowsNewLine()
       {
         return "\r\n";
       }

include/ls_std/io/StorableFile.hpp

@@ -21,19 +21,19 @@ namespace ls
   {
     public:
 
-      explicit StorableFile(const std::string &_path);
+      explicit StorableFile(const ::std::string &_path);
       ~StorableFile() = default;
 
-      std::shared_ptr<ls::File> getFile();
+      ::std::shared_ptr<ls::File> getFile();
       ls::byte_field load() override;
-      void reset(const std::string &_path);
+      void reset(const ::std::string &_path);
       void save(const ls::byte_field &_data) override;
 
     private:
 
-      std::shared_ptr<ls::File> file{};
+      ::std::shared_ptr<ls::File> file{};
 
-      void _init(const std::string &_path);
+      void _init(const ::std::string &_path);
   };
 }
 

include/ls_std/io/kv/KvDocument.hpp

@@ -26,13 +26,13 @@ namespace ls
 
       bool addPair(ls::KvPair _pair);
       void clear();
-      std::map<ls::kv_key, ls::KvPair> getPairs();
+      ::std::map<ls::kv_key, ls::KvPair> getPairs();
       bool hasPair(const ls::kv_key &_key);
       bool removePair(const ls::kv_key &_key);
 
     private:
 
-      std::map<ls::kv_key, ls::KvPair> pairs{};
+      ::std::map<ls::kv_key, ls::KvPair> pairs{};
 
       bool _hasPair(const ls::kv_key &_key);
   };

include/ls_std/io/kv/KvFileReader.hpp

@@ -22,7 +22,7 @@ namespace ls
   {
     public:
 
-      explicit KvFileReader(const std::shared_ptr<ls::KvDocument> &_document, const std::string &_absolutePath);
+      explicit KvFileReader(const ::std::shared_ptr<ls::KvDocument> &_document, const ::std::string &_absolutePath);
       ~KvFileReader() override = default;
 
       // implementation
@@ -31,16 +31,16 @@ namespace ls
 
       // additional functionality
 
-      std::shared_ptr<ls::KvDocument> getDocument();
-      void setDocument(const std::shared_ptr<ls::KvDocument> &_document);
+      ::std::shared_ptr<ls::KvDocument> getDocument();
+      void setDocument(const ::std::shared_ptr<ls::KvDocument> &_document);
       void setFile(const ls::File &_kvFile);
 
     private:
 
-      std::shared_ptr<ls::KvDocument> document{};
+      ::std::shared_ptr<ls::KvDocument> document{};
       ls::File kvFile;
 
-      void _assignDocument(const std::shared_ptr<ls::KvDocument> &_document);
+      void _assignDocument(const ::std::shared_ptr<ls::KvDocument> &_document);
       void _assignFile(ls::File _kvFile);
   };
 }

include/ls_std/io/kv/KvParseParameter.hpp

@@ -17,7 +17,7 @@ namespace ls
 {
   struct KvParseParameter
   {
-    std::string::size_type index{};
+    ::std::string::size_type index{};
     ls::String line{};
   };
 }

include/ls_std/io/kv/KvParser.hpp

@@ -22,22 +22,22 @@ namespace ls
   {
     public:
 
-      explicit KvParser(const std::shared_ptr<ls::KvDocument> &_document);
+      explicit KvParser(const ::std::shared_ptr<ls::KvDocument> &_document);
       ~KvParser() override = default;
 
-      std::shared_ptr<ls::KvDocument> getDocument();
+      ::std::shared_ptr<ls::KvDocument> getDocument();
       void parse(const ls::byte_field &_data);
-      void setDocument(const std::shared_ptr<ls::KvDocument> &_document);
+      void setDocument(const ::std::shared_ptr<ls::KvDocument> &_document);
 
     private:
 
-      std::shared_ptr<ls::KvDocument> document{};
+      ::std::shared_ptr<ls::KvDocument> document{};
 
-      void _assignDocument(const std::shared_ptr<ls::KvDocument> &_document);
+      void _assignDocument(const ::std::shared_ptr<ls::KvDocument> &_document);
       static bool _lineHasPair(ls::KvParseParameter _parseParameter);
       void _parse(const ls::byte_field &_data);
       void _parsePair(ls::KvParseParameter _parseParameter);
-      static ls::KvParseParameter _readLine(const ls::byte_field &_data, std::string::size_type _index);
+      static ls::KvParseParameter _readLine(const ls::byte_field &_data, ::std::string::size_type _index);
       static void _readLineWithUnixLineBreak(ls::KvParseParameter &_parseParameter);
       static void _readLineWithWindowsLineBreak(ls::KvParseParameter &_parseParameter);
   };

include/ls_std/io/kv/KvTypes.hpp

@@ -14,8 +14,8 @@
 
 namespace ls
 {
-  using kv_key = std::string;
-  using kv_value = std::string;
+  using kv_key = ::std::string;
+  using kv_value = ::std::string;
 }
 
 #endif

include/ls_std/io/logging/LogLevel.hpp

@@ -33,17 +33,17 @@ namespace ls
       bool operator==(const ls::LogLevelValue &_value);
 
       void setLogLevel(const ls::LogLevelValue &_value);
-      void setLogLevel(const std::string &_value);
-      std::string toString() const;
+      void setLogLevel(const ::std::string &_value);
+      ::std::string toString() const;
 
     private:
 
-      std::unordered_map<uint8_t, std::string> level{};
+      ::std::unordered_map<uint8_t, ::std::string> level{};
       ls::LogLevelValue value{};
 
-      ls::LogLevelValue _getValueFromString(const std::string &_value);
+      ls::LogLevelValue _getValueFromString(const ::std::string &_value);
       void _init();
-      bool _isValidLogLevelString(const std::string &_value);
+      bool _isValidLogLevelString(const ::std::string &_value);
   };
 }
 

include/ls_std/io/logging/Logger.hpp

@@ -23,7 +23,7 @@ namespace ls
   {
     public:
 
-      explicit Logger(const std::shared_ptr<ls::IWriter> &_writer);
+      explicit Logger(const ::std::shared_ptr<ls::IWriter> &_writer);
       ~Logger() override = default;
 
       void debug(const ls::byte *_data);
@@ -38,9 +38,9 @@ namespace ls
     private:
 
       ls::LogLevel logLevel{};
-      std::shared_ptr<ls::IWriter> writer{};
+      ::std::shared_ptr<ls::IWriter> writer{};
 
-      void _assignWriter(const std::shared_ptr<ls::IWriter> &_writer);
+      void _assignWriter(const ::std::shared_ptr<ls::IWriter> &_writer);
       void _log(const ls::byte *_data, const ls::LogLevel &_logLevel);
   };
 }

include/ls_std/io/xml/XmlAttribute.hpp

@@ -19,22 +19,22 @@ namespace ls
   {
     public:
 
-      explicit XmlAttribute(const std::string& _name);
+      explicit XmlAttribute(const ::std::string& _name);
       ~XmlAttribute() override = default;
 
-      std::string getName();
-      std::string getValue();
-      void setName(const std::string& _name);
-      void setValue(const std::string& _value);
-      std::string toXml();
+      ::std::string getName();
+      ::std::string getValue();
+      void setName(const ::std::string& _name);
+      void setValue(const ::std::string& _value);
+      ::std::string toXml();
 
     private:
 
-      std::string name{};
-      std::string value{};
+      ::std::string name{};
+      ::std::string value{};
 
-      void _assignName(const std::string& _name);
-      void _assignValue(const std::string& _value);
+      void _assignName(const ::std::string& _name);
+      void _assignValue(const ::std::string& _value);
   };
 }
 

include/ls_std/io/xml/XmlDeclaration.hpp

@@ -19,16 +19,16 @@ namespace ls
   {
     public:
 
-      explicit XmlDeclaration(const std::string& _version);
+      explicit XmlDeclaration(const ::std::string& _version);
       ~XmlDeclaration() override = default;
 
-      std::string getEncoding();
-      std::string getStandalone();
-      std::string getVersion();
-      void setEncoding(const std::string& _encoding);
-      void setStandalone(const std::string& _standalone);
-      void setVersion(const std::string& _version);
-      std::string toXml();
+      ::std::string getEncoding();
+      ::std::string getStandalone();
+      ::std::string getVersion();
+      void setEncoding(const ::std::string& _encoding);
+      void setStandalone(const ::std::string& _standalone);
+      void setVersion(const ::std::string& _version);
+      ::std::string toXml();
 
     private:
 
@@ -36,7 +36,7 @@ namespace ls
       ls::XmlAttribute standalone{"standalone"};
       ls::XmlAttribute version{"version"};
 
-      static std::string _toXmlAttribute(ls::XmlAttribute _attribute);
+      static ::std::string _toXmlAttribute(ls::XmlAttribute _attribute);
   };
 }
 

include/ls_std/io/xml/XmlDocument.hpp

@@ -24,19 +24,19 @@ namespace ls
       XmlDocument();
       ~XmlDocument() override = default;
 
-      std::shared_ptr<ls::XmlDeclaration> getDeclaration();
-      std::shared_ptr<ls::XmlNode> getRootElement();
-      void setDeclaration(const std::shared_ptr<ls::XmlDeclaration> &_declaration);
-      void setRootElement(const std::shared_ptr<ls::XmlNode> &_rootElement);
-      std::string toXml();
+      ::std::shared_ptr<ls::XmlDeclaration> getDeclaration();
+      ::std::shared_ptr<ls::XmlNode> getRootElement();
+      void setDeclaration(const ::std::shared_ptr<ls::XmlDeclaration> &_declaration);
+      void setRootElement(const ::std::shared_ptr<ls::XmlNode> &_rootElement);
+      ::std::string toXml();
 
     private:
 
-      std::shared_ptr<ls::XmlDeclaration> declaration{};
-      std::shared_ptr<ls::XmlNode> rootElement{};
+      ::std::shared_ptr<ls::XmlDeclaration> declaration{};
+      ::std::shared_ptr<ls::XmlNode> rootElement{};
 
-      void _assignDeclaration(const std::shared_ptr<ls::XmlDeclaration> &_declaration);
-      void _assignRootElement(const std::shared_ptr<ls::XmlNode> &_rootElement);
+      void _assignDeclaration(const ::std::shared_ptr<ls::XmlDeclaration> &_declaration);
+      void _assignRootElement(const ::std::shared_ptr<ls::XmlNode> &_rootElement);
   };
 }
 

include/ls_std/io/xml/XmlNode.hpp

@@ -21,61 +21,61 @@ namespace ls
   {
     public:
 
-      explicit XmlNode(std::string _name);
+      explicit XmlNode(::std::string _name);
       ~XmlNode() override = default;
 
-      bool addAttributeAfter(const std::shared_ptr<ls::XmlAttribute> &_attribute, const std::string &_name);
-      bool addAttributeBefore(const std::shared_ptr<ls::XmlAttribute> &_attribute, const std::string &_name);
-      bool addAttributeToBeginning(const std::shared_ptr<ls::XmlAttribute> &_attribute);
-      bool addAttributeToEnd(const std::shared_ptr<ls::XmlAttribute> &_attribute);
-      bool addChildAfter(const std::shared_ptr<ls::XmlNode> &_child, const std::shared_ptr<ls::XmlNode> &_search);
-      bool addChildBefore(const std::shared_ptr<ls::XmlNode> &_child, const std::shared_ptr<ls::XmlNode> &_search);
-      bool addChildToBeginning(const std::shared_ptr<ls::XmlNode> &_child);
-      bool addChildToEnd(const std::shared_ptr<ls::XmlNode> &_child);
+      bool addAttributeAfter(const ::std::shared_ptr<ls::XmlAttribute> &_attribute, const ::std::string &_name);
+      bool addAttributeBefore(const ::std::shared_ptr<ls::XmlAttribute> &_attribute, const ::std::string &_name);
+      bool addAttributeToBeginning(const ::std::shared_ptr<ls::XmlAttribute> &_attribute);
+      bool addAttributeToEnd(const ::std::shared_ptr<ls::XmlAttribute> &_attribute);
+      bool addChildAfter(const ::std::shared_ptr<ls::XmlNode> &_child, const ::std::shared_ptr<ls::XmlNode> &_search);
+      bool addChildBefore(const ::std::shared_ptr<ls::XmlNode> &_child, const ::std::shared_ptr<ls::XmlNode> &_search);
+      bool addChildToBeginning(const ::std::shared_ptr<ls::XmlNode> &_child);
+      bool addChildToEnd(const ::std::shared_ptr<ls::XmlNode> &_child);
       void clearValue();
-      std::list<std::shared_ptr<ls::XmlAttribute>> getAttributes();
-      std::list<std::shared_ptr<ls::XmlNode>> getChildren();
-      std::list<std::shared_ptr<ls::XmlNode>> getChildren(const std::string &_name);
-      std::string getName();
-      std::string getValue();
-      bool hasAttribute(const std::string &_name);
-      bool hasChild(const std::string &_name);
-      bool hasChild(const std::shared_ptr<ls::XmlNode> &_child);
+      ::std::list<::std::shared_ptr<ls::XmlAttribute>> getAttributes();
+      ::std::list<::std::shared_ptr<ls::XmlNode>> getChildren();
+      ::std::list<::std::shared_ptr<ls::XmlNode>> getChildren(const ::std::string &_name);
+      ::std::string getName();
+      ::std::string getValue();
+      bool hasAttribute(const ::std::string &_name);
+      bool hasChild(const ::std::string &_name);
+      bool hasChild(const ::std::shared_ptr<ls::XmlNode> &_child);
       bool removeFirstAttribute();
       bool removeLastAttribute();
       bool removeFirstChild();
       bool removeLastChild();
-      void setName(const std::string &_name);
-      void setValue(const std::string &_value);
-      std::string toXml();
+      void setName(const ::std::string &_name);
+      void setValue(const ::std::string &_value);
+      ::std::string toXml();
 
     protected:
 
-      std::string _toXml_(uint8_t _tabSize);
+      ::std::string _toXml_(uint8_t _tabSize);
 
     private:
 
-      std::list<std::shared_ptr<ls::XmlAttribute>> attributes{};
-      std::list<std::shared_ptr<ls::XmlNode>> children{};
-      std::string name{};
+      ::std::list<::std::shared_ptr<ls::XmlAttribute>> attributes{};
+      ::std::list<::std::shared_ptr<ls::XmlNode>> children{};
+      ::std::string name{};
       const static uint8_t TAB_SIZE{4};
-      std::string value{};
+      ::std::string value{};
 
-      void _assignName(const std::string &_name);
-      void _assignValue(const std::string &_value);
-      static void _checkIfAttributeReferenceIsValid(const std::shared_ptr<ls::XmlAttribute> &_attribute);
-      static void _checkIfNameIsNotEmpty(const std::string &_name);
-      static void _checkIfNodeReferenceIsValid(const std::shared_ptr<ls::XmlNode> &_child);
-      static std::string _getTab(uint8_t _tabSize);
-      bool _hasAttribute(const std::string &_name);
-      bool _hasChild(const std::shared_ptr<ls::XmlNode> &_child);
-      bool _hasChild(const std::string &_name);
-      std::string _toXmlAttributes();
-      std::string _toXmlChildren(uint8_t _tabSize);
-      std::string _toXmlCloseTag();
-      std::string _toXmlOpenTag();
-      std::string _toXmlOpenTagClose();
-      std::string _toXmlValue();
+      void _assignName(const ::std::string &_name);
+      void _assignValue(const ::std::string &_value);
+      static void _checkIfAttributeReferenceIsValid(const ::std::shared_ptr<ls::XmlAttribute> &_attribute);
+      static void _checkIfNameIsNotEmpty(const ::std::string &_name);
+      static void _checkIfNodeReferenceIsValid(const ::std::shared_ptr<ls::XmlNode> &_child);
+      static ::std::string _getTab(uint8_t _tabSize);
+      bool _hasAttribute(const ::std::string &_name);
+      bool _hasChild(const ::std::shared_ptr<ls::XmlNode> &_child);
+      bool _hasChild(const ::std::string &_name);
+      ::std::string _toXmlAttributes();
+      ::std::string _toXmlChildren(uint8_t _tabSize);
+      ::std::string _toXmlCloseTag();
+      ::std::string _toXmlOpenTag();
+      ::std::string _toXmlOpenTagClose();
+      ::std::string _toXmlValue();
   };
 }
 

include/ls_std/io/xml/XmlParseParameter.hpp

@@ -19,7 +19,7 @@ namespace ls
   struct XmlParseParameter
   {
     uint8_t level{};
-    std::shared_ptr<ls::XmlNode> node{};
+    ::std::shared_ptr<ls::XmlNode> node{};
   };
 }
 

include/ls_std/io/xml/XmlParser.hpp

@@ -23,48 +23,48 @@ namespace ls
   {
     public:
 
-      explicit XmlParser(const std::shared_ptr<ls::XmlDocument> &_document);
+      explicit XmlParser(const ::std::shared_ptr<ls::XmlDocument> &_document);
       ~XmlParser() override = default;
 
-      std::shared_ptr<ls::XmlDocument> getDocument();
+      ::std::shared_ptr<ls::XmlDocument> getDocument();
       void parse(const ls::byte_field &_data);
-      void setDocument(const std::shared_ptr<ls::XmlDocument> &_document);
+      void setDocument(const ::std::shared_ptr<ls::XmlDocument> &_document);
 
     protected:
 
-      static std::pair<std::string, std::string> _readAttribute_(const ls::byte_field &_data);
-      static std::list<std::pair<std::string, std::string>> _readAttributes_(ls::byte_field _data);
+      static ::std::pair<::std::string, ::std::string> _readAttribute_(const ls::byte_field &_data);
+      static ::std::list<::std::pair<::std::string, ::std::string>> _readAttributes_(ls::byte_field _data);
 
     private:
 
       uint8_t currentLevel{};
-      std::shared_ptr<ls::XmlDocument> document{};
+      ::std::shared_ptr<ls::XmlDocument> document{};
       uint8_t maxLevel{};
       ls::XmlParseMode mode{};
-      std::list<ls::XmlParseParameter> parseParameters{};
+      ::std::list<ls::XmlParseParameter> parseParameters{};
 
-      void _analyze(const ls::byte_field &_data, std::string::size_type _index);
-      void _assignDocument(const std::shared_ptr<ls::XmlDocument> &_document);
-      static std::shared_ptr<ls::XmlDeclaration> _createDeclaration(const std::list<std::pair<std::string, std::string>> &_attributes);
-      static std::shared_ptr<ls::XmlNode> _createNode(const std::list<std::pair<std::string, std::string>> &_attributes, const std::string &_name);
-      static std::pair<std::string, std::string> _findAttribute(const std::list<std::pair<std::string, std::string>> &_attributes, const std::string &_name);
+      void _analyze(const ls::byte_field &_data, ::std::string::size_type _index);
+      void _assignDocument(const ::std::shared_ptr<ls::XmlDocument> &_document);
+      static ::std::shared_ptr<ls::XmlDeclaration> _createDeclaration(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes);
+      static ::std::shared_ptr<ls::XmlNode> _createNode(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name);
+      static ::std::pair<::std::string, ::std::string> _findAttribute(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name);
       static size_t _findAttributeEndPosition(const ls::byte_field &_data);
-      static ls::byte_field _getNextTagString(const ls::byte_field &_data, std::string::size_type _index);
-      void _isClosingTag(const ls::byte_field &_data, std::string::size_type _index);
-      void _isDeclaration(const ls::byte_field &_data, std::string::size_type _index);
-      void _isOpeningTag(const ls::byte_field &_data, std::string::size_type _index);
-      void _isValue(const ls::byte_field &_data, std::string::size_type _index);
+      static ls::byte_field _getNextTagString(const ls::byte_field &_data, ::std::string::size_type _index);
+      void _isClosingTag(const ls::byte_field &_data, ::std::string::size_type _index);
+      void _isDeclaration(const ls::byte_field &_data, ::std::string::size_type _index);
+      void _isOpeningTag(const ls::byte_field &_data, ::std::string::size_type _index);
+      void _isValue(const ls::byte_field &_data, ::std::string::size_type _index);
       void _mergeNodes();
-      void _mergeChildrenToParentNode(const std::shared_ptr<ls::XmlNode> &_parent, std::list<ls::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel);
+      void _mergeChildrenToParentNode(const ::std::shared_ptr<ls::XmlNode> &_parent, ::std::list<ls::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel);
       void _mergeNodesOnCurrentLevel();
       void _parse(const ls::byte_field &_data);
-      static std::pair<std::string, std::string> _parseAttribute(const ls::byte_field &_data);
-      static std::list<std::pair<std::string, std::string>> _parseAttributes(ls::byte_field _data);
-      size_t _parseClosingTag(const ls::byte_field &_data, std::string::size_type _index);
-      size_t _parseDeclaration(const ls::byte_field &_data, std::string::size_type _index);
-      size_t _parseOpeningTag(const ls::byte_field &_data, std::string::size_type _index);
+      static ::std::pair<::std::string, ::std::string> _parseAttribute(const ls::byte_field &_data);
+      static ::std::list<::std::pair<::std::string, ::std::string>> _parseAttributes(ls::byte_field _data);
+      size_t _parseClosingTag(const ls::byte_field &_data, ::std::string::size_type _index);
+      size_t _parseDeclaration(const ls::byte_field &_data, ::std::string::size_type _index);
+      size_t _parseOpeningTag(const ls::byte_field &_data, ::std::string::size_type _index);
       static ls::byte_field _parseTagName(const ls::byte_field &_data);
-      size_t _parseValue(const ls::byte_field &_data, std::string::size_type _index);
+      size_t _parseValue(const ls::byte_field &_data, ::std::string::size_type _index);
       void _reset();
       void _setMaxLevel();
   };

include/ls_std/io/xml/XmlReader.hpp

@@ -24,7 +24,7 @@ namespace ls
   {
     public:
 
-      explicit XmlReader(const std::shared_ptr<ls::XmlDocument> &_document, const std::string &_absolutePath);
+      explicit XmlReader(const ::std::shared_ptr<ls::XmlDocument> &_document, const ::std::string &_absolutePath);
       ~XmlReader() override = default;
 
       // implementation
@@ -33,16 +33,16 @@ namespace ls
 
       // additional functionality
 
-      std::shared_ptr<ls::XmlDocument> getDocument();
-      void setDocument(const std::shared_ptr<ls::XmlDocument> &_document);
+      ::std::shared_ptr<ls::XmlDocument> getDocument();
+      void setDocument(const ::std::shared_ptr<ls::XmlDocument> &_document);
       void setFile(const ls::File &_xmlFile);
 
     private:
 
-      std::shared_ptr<ls::XmlDocument> document{};
+      ::std::shared_ptr<ls::XmlDocument> document{};
       ls::File xmlFile;
 
-      void _assignDocument(const std::shared_ptr<ls::XmlDocument> &_document);
+      void _assignDocument(const ::std::shared_ptr<ls::XmlDocument> &_document);
       void _assignFile(ls::File _xmlFile);
   };
 }

include/ls_std/logic/Narrator.hpp

@@ -24,15 +24,15 @@ namespace ls
       Narrator();
       ~Narrator() override = default;
 
-      bool addListener(const std::shared_ptr<ls::IListener> &_listener);
+      bool addListener(const ::std::shared_ptr<ls::IListener> &_listener);
       void clear();
-      std::list<std::shared_ptr<ls::IListener>> getListeners();
-      bool removeListener(const std::shared_ptr<ls::IListener> &_listener);
+      ::std::list<::std::shared_ptr<ls::IListener>> getListeners();
+      bool removeListener(const ::std::shared_ptr<ls::IListener> &_listener);
       void tell(const ls::Class &_info);
 
     private:
 
-      std::list<std::shared_ptr<ls::IListener>> listeners{};
+      ::std::list<::std::shared_ptr<ls::IListener>> listeners{};
   };
 }
 

include/ls_std/logic/State.hpp

@@ -28,17 +28,17 @@ namespace ls
 
       // additional functionality
 
-      bool addStateConnection(const ls::StateConnectionId &_connectionId, const std::shared_ptr<ls::State> &_connectedState);
-      bool addStateConnection(const std::shared_ptr<ls::StateConnection> &_connection);
+      bool addStateConnection(const ls::StateConnectionId &_connectionId, const ::std::shared_ptr<ls::State> &_connectedState);
+      bool addStateConnection(const ::std::shared_ptr<ls::StateConnection> &_connection);
       void clearConnections();
-      std::unordered_map<ls::StateConnectionId, std::shared_ptr<ls::StateConnection>> getConnectedStates();
+      ::std::unordered_map<ls::StateConnectionId, ::std::shared_ptr<ls::StateConnection>> getConnectedStates();
       ls::StateId getId();
       bool hasConnection(const ls::StateConnectionId &_connectionId);
       void setId(const ls::StateId& _id);
 
     private:
 
-      std::unordered_map<ls::StateConnectionId, std::shared_ptr<ls::StateConnection>> connectedStates{};
+      ::std::unordered_map<ls::StateConnectionId, ::std::shared_ptr<ls::StateConnection>> connectedStates{};
       ls::StateId id{};
 
       void _assignStateId(const ls::StateId& _id);

include/ls_std/logic/StateMachine.hpp

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

include/ls_std/logic/StateMachineTypes.hpp

@@ -14,8 +14,8 @@
 
 namespace ls
 {
-  using StateConnectionId = std::string;
-  using StateId = std::string;
+  using StateConnectionId = ::std::string;
+  using StateId = ::std::string;
 }
 
 #endif

include/ls_std/logic/serialization/SerializableJsonState.hpp

@@ -22,7 +22,7 @@ namespace ls
   {
     public:
 
-      explicit SerializableJsonState(const std::shared_ptr<ls::State> &_value);
+      explicit SerializableJsonState(const ::std::shared_ptr<ls::State> &_value);
       ~SerializableJsonState() override = default;
 
       // implementation
@@ -32,15 +32,15 @@ namespace ls
 
       // additional functionality
 
-      std::shared_ptr<ls::State> getValue();
-      void setValue(const std::shared_ptr<ls::State> &_value);
+      ::std::shared_ptr<ls::State> getValue();
+      void setValue(const ::std::shared_ptr<ls::State> &_value);
 
     private:
 
       nlohmann::json jsonObject{};
-      std::shared_ptr<ls::State> value{};
+      ::std::shared_ptr<ls::State> value{};
 
-      void _assignValue(const std::shared_ptr<ls::State> &_value);
+      void _assignValue(const ::std::shared_ptr<ls::State> &_value);
       void _clear();
       void _unmarshalStateConnections();
       void _update();

include/ls_std/logic/serialization/SerializableJsonStateConnection.hpp

@@ -22,7 +22,7 @@ namespace ls
   {
     public:
 
-      explicit SerializableJsonStateConnection(const std::shared_ptr<ls::StateConnection> &_value);
+      explicit SerializableJsonStateConnection(const ::std::shared_ptr<ls::StateConnection> &_value);
       ~SerializableJsonStateConnection() override = default;
 
       // implementation
@@ -32,15 +32,15 @@ namespace ls
 
       // additional functionality
 
-      std::shared_ptr<ls::StateConnection> getValue();
-      void setValue(const std::shared_ptr<ls::StateConnection> &_value);
+      ::std::shared_ptr<ls::StateConnection> getValue();
+      void setValue(const ::std::shared_ptr<ls::StateConnection> &_value);
 
     private:
 
       nlohmann::json jsonObject{};
-      std::shared_ptr<ls::StateConnection> value{};
+      ::std::shared_ptr<ls::StateConnection> value{};
 
-      void _assignValue(const std::shared_ptr<ls::StateConnection> &_value);
+      void _assignValue(const ::std::shared_ptr<ls::StateConnection> &_value);
       void _clear();
       void _update();
   };

include/ls_std/logic/serialization/SerializableJsonStateMachine.hpp

@@ -22,7 +22,7 @@ namespace ls
   {
     public:
 
-      explicit SerializableJsonStateMachine(const std::shared_ptr<ls::StateMachine> &_value);
+      explicit SerializableJsonStateMachine(const ::std::shared_ptr<ls::StateMachine> &_value);
       ~SerializableJsonStateMachine() override = default;
 
       // implementation
@@ -32,15 +32,15 @@ namespace ls
 
       // additional functionality
 
-      std::shared_ptr<ls::StateMachine> getValue();
-      void setValue(const std::shared_ptr<ls::StateMachine> &_value);
+      ::std::shared_ptr<ls::StateMachine> getValue();
+      void setValue(const ::std::shared_ptr<ls::StateMachine> &_value);
 
     private:
 
       nlohmann::json jsonObject{};
-      std::shared_ptr<ls::StateMachine> value{};
+      ::std::shared_ptr<ls::StateMachine> value{};
 
-      void _assignValue(const std::shared_ptr<ls::StateMachine> &_value);
+      void _assignValue(const ::std::shared_ptr<ls::StateMachine> &_value);
       void _unmarshalCurrentState();
       void _unmarshalStates();
       void _update();

include/ls_std/time/Date.hpp

@@ -41,7 +41,7 @@ namespace ls
       time_t getTime() const;
       int getYear();
       void setTime(time_t _timestamp);
-      std::string toString();
+      ::std::string toString();
 
     private:
 

source/ls_std/boxing/Boolean.cpp

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

source/ls_std/boxing/Double.cpp

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

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

source/ls_std/boxing/Integer.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -252,14 +252,14 @@ void ls::Integer::operator--()
   this->value -= 1;
 }
 
-void ls::Integer::parse(std::string _parseText)
+void ls::Integer::parse(::std::string _parseText)
 {
-  this->value = std::stoi(_parseText);
+  this->value = ::std::stoi(_parseText);
 }
 
 std::string ls::Integer::toString()
 {
-  return std::to_string(this->value);
+  return ::std::to_string(this->value);
 }
 
 int ls::Integer::getValue() const

source/ls_std/boxing/Long.cpp

@@ -252,14 +252,14 @@ void ls::Long::operator--()
   this->value -= 1;
 }
 
-void ls::Long::parse(std::string _parseText)
+void ls::Long::parse(::std::string _parseText)
 {
-  this->value = std::stoll(_parseText);
+  this->value = ::std::stoll(_parseText);
 }
 
 std::string ls::Long::toString()
 {
-  return std::to_string(this->value);
+  return ::std::to_string(this->value);
 }
 
 ls::long_type ls::Long::getValue() const

source/ls_std/boxing/String.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-05-05
+ * Changed:         2022-05-06
  *
  * */
 
@@ -14,9 +14,9 @@
 ls::String::String() : ls::Class("String")
 {}
 
-ls::String::String(std::string _value)
+ls::String::String(::std::string _value)
     : ls::Class("String"),
-      value(std::move(_value))
+      value(::std::move(_value))
 {}
 
 ls::String::operator const char *() const
@@ -24,14 +24,14 @@ ls::String::operator const char *() const
   return this->value.c_str();
 }
 
-ls::String::operator std::string() const
+ls::String::operator ::std::string() const
 {
   return this->value;
 }
 
-ls::String &ls::String::operator=(std::string _value)
+ls::String &ls::String::operator=(::std::string _value)
 {
-  this->value = std::move(_value);
+  this->value = ::std::move(_value);
   return *this;
 }
 
@@ -40,7 +40,7 @@ std::string ls::String::operator+(ls::String _string) const
   return this->value + _string.toString();
 }
 
-std::string ls::String::operator+(const std::string &_string) const
+std::string ls::String::operator+(const ::std::string &_string) const
 {
   return this->value + _string;
 }
@@ -52,7 +52,7 @@ std::string ls::String::operator+(const char *_string) const
 
 std::string ls::String::operator-(int _number)
 {
-  std::string copy = this->value;
+  ::std::string copy = this->value;
   return copy.substr(0, copy.size() - _number);
 }
 
@@ -62,7 +62,7 @@ ls::String &ls::String::operator+=(ls::String _string)
   return *this;
 }
 
-ls::String &ls::String::operator+=(const std::string &_text)
+ls::String &ls::String::operator+=(const ::std::string &_text)
 {
   this->value = this->value + _text;
   return *this;
@@ -73,7 +73,7 @@ bool ls::String::operator==(ls::String _string)
   return this->value == _string.toString();
 }
 
-bool ls::String::operator==(const std::string &_value)
+bool ls::String::operator==(const ::std::string &_value)
 {
   return this->value == _value;
 }
@@ -88,7 +88,7 @@ bool ls::String::operator!=(ls::String _string)
   return this->value != _string.toString();
 }
 
-bool ls::String::operator!=(const std::string &_value)
+bool ls::String::operator!=(const ::std::string &_value)
 {
   return this->value != _value;
 }
@@ -98,9 +98,9 @@ bool ls::String::operator!=(const char *_value)
   return this->value != _value;
 }
 
-void ls::String::parse(std::string _parseText)
+void ls::String::parse(::std::string _parseText)
 {
-  this->value = std::move(_parseText);
+  this->value = ::std::move(_parseText);
 }
 
 std::string ls::String::toString()
@@ -108,12 +108,12 @@ std::string ls::String::toString()
   return this->value;
 }
 
-bool ls::String::contains(const std::string &_text)
+bool ls::String::contains(const ::std::string &_text)
 {
-  return this->value.find(_text) != std::string::npos;
+  return this->value.find(_text) != ::std::string::npos;
 }
 
-bool ls::String::endsWith(const std::string &_text)
+bool ls::String::endsWith(const ::std::string &_text)
 {
   return this->value.rfind(_text) == (this->value.size() - _text.size());
 }
@@ -123,14 +123,14 @@ bool ls::String::equalsIgnoreCase(ls::String _string)
   return this->toLowerCase() == _string.toLowerCase();
 }
 
-bool ls::String::equalsIgnoreCase(std::string _text)
+bool ls::String::equalsIgnoreCase(::std::string _text)
 {
-  return this->toLowerCase() == ls::String{std::move(_text)}.toLowerCase();
+  return this->toLowerCase() == ls::String{::std::move(_text)}.toLowerCase();
 }
 
 std::vector<ls::byte> ls::String::getByteData()
 {
-  std::vector<ls::byte> byteData(this->value.begin(), this->value.end());
+  ::std::vector<ls::byte> byteData(this->value.begin(), this->value.end());
   byteData.push_back('\0');
 
   return byteData;
@@ -148,36 +148,36 @@ std::string ls::String::padRight(size_t _width, const char _fillCharacter)
 
 std::string ls::String::reverse()
 {
-  std::string copy = this->value;
-  std::reverse(copy.begin(), copy.end());
+  ::std::string copy = this->value;
+  ::std::reverse(copy.begin(), copy.end());
 
   return copy;
 }
 
-bool ls::String::startsWith(const std::string &_text)
+bool ls::String::startsWith(const ::std::string &_text)
 {
   return this->value.rfind(_text, 0) == 0;
 }
 
 std::string ls::String::toLowerCase()
 {
-  std::string copy = this->value;
-  std::transform(copy.begin(), copy.end(), copy.begin(), ::tolower);
+  ::std::string copy = this->value;
+  ::std::transform(copy.begin(), copy.end(), copy.begin(), ::tolower);
 
   return copy;
 }
 
 std::string ls::String::toUpperCase()
 {
-  std::string copy = this->value;
-  std::transform(copy.begin(), copy.end(), copy.begin(), ::toupper);
+  ::std::string copy = this->value;
+  ::std::transform(copy.begin(), copy.end(), copy.begin(), ::toupper);
 
   return copy;
 }
 
 std::string ls::String::_buildCharacterChain(size_t _amount, const char _fillCharacter)
 {
-  std::string fillContent{};
+  ::std::string fillContent{};
 
   for (size_t iteration{}; iteration < _amount; iteration++)
   {
@@ -187,10 +187,10 @@ 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::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{};
+  ::std::string fillContent{};
 
   if (fillSize > 0)
   {

source/ls_std/io/kv/KvParser.cpp

@@ -11,7 +11,7 @@
 #include <ls_std/io/NewLine.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::KvParser::KvParser(const std::shared_ptr<ls::KvDocument> &_document) : ls::Class("KvParser")
+ls::KvParser::KvParser(const ::std::shared_ptr<ls::KvDocument> &_document) : ls::Class("KvParser")
 {
   this->_assignDocument(_document);
 }
@@ -26,12 +26,12 @@ void ls::KvParser::parse(const ls::byte_field &_data)
   this->_parse(_data);
 }
 
-void ls::KvParser::setDocument(const std::shared_ptr<ls::KvDocument> &_document)
+void ls::KvParser::setDocument(const ::std::shared_ptr<ls::KvDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-void ls::KvParser::_assignDocument(const std::shared_ptr<ls::KvDocument> &_document)
+void ls::KvParser::_assignDocument(const ::std::shared_ptr<ls::KvDocument> &_document)
 {
   if (_document == nullptr)
   {
@@ -48,7 +48,7 @@ bool ls::KvParser::_lineHasPair(ls::KvParseParameter _parseParameter)
 
 void ls::KvParser::_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++)
   {
     ls::KvParseParameter parseParameter = ls::KvParser::_readLine(_data, index);
     this->_parsePair(parseParameter);
@@ -69,7 +69,7 @@ void ls::KvParser::_parsePair(ls::KvParseParameter _parseParameter)
   }
 }
 
-ls::KvParseParameter ls::KvParser::_readLine(const ls::byte_field &_data, std::string::size_type _index)
+ls::KvParseParameter ls::KvParser::_readLine(const ls::byte_field &_data, ::std::string::size_type _index)
 {
   ls::KvParseParameter parseParameter{};
   parseParameter.line = _data.substr(_index);

test/cases/boxing/BooleanTest.cpp

@@ -9,7 +9,6 @@
 
 #include <gtest/gtest.h>
 #include <ls_std/ls_std.hpp>
-#include <TestHelper.hpp>
 
 namespace
 {
@@ -31,7 +30,7 @@ namespace
 
   TEST_F(BooleanTest, operator_assignment_boolean)
   {
-    ls::Boolean expression{};
+    ls::std::boxing::Boolean expression{};
     expression = true;
 
     ASSERT_TRUE(expression);
@@ -39,7 +38,7 @@ namespace
 
   TEST_F(BooleanTest, operator_assignment_integer)
   {
-    ls::Boolean expression{};
+    ls::std::boxing::Boolean expression{};
     expression = 1;
 
     ASSERT_TRUE(expression);
@@ -49,7 +48,7 @@ namespace
 
   TEST_F(BooleanTest, operator_output_stream)
   {
-    ls::Boolean expression{true};
+    ls::std::boxing::Boolean expression{true};
     std::ostringstream _stream{};
     _stream << expression;
 
@@ -60,20 +59,20 @@ namespace
 
   TEST_F(BooleanTest, operator_negation_negative_value)
   {
-    ls::Boolean expression{};
+    ls::std::boxing::Boolean expression{};
     ASSERT_TRUE(!expression);
   }
 
   TEST_F(BooleanTest, operator_negation_positive_value)
   {
-    ls::Boolean expression{true};
+    ls::std::boxing::Boolean expression{true};
     ASSERT_FALSE(!expression);
   }
 
   TEST_F(BooleanTest, operator_and)
   {
-    ls::Boolean expressionA{true};
-    ls::Boolean expressionB{3 == 3};
+    ls::std::boxing::Boolean expressionA{true};
+    ls::std::boxing::Boolean expressionB{3 == 3};
 
     ASSERT_TRUE(expressionA && expressionB);
     ASSERT_TRUE(expressionB && expressionA);
@@ -84,8 +83,8 @@ namespace
 
   TEST_F(BooleanTest, operator_and_with_false_result)
   {
-    ls::Boolean expressionA{true};
-    ls::Boolean expressionB{3 == 4};
+    ls::std::boxing::Boolean expressionA{true};
+    ls::std::boxing::Boolean expressionB{3 == 4};
 
     ASSERT_FALSE(expressionA && expressionB);
     ASSERT_FALSE(expressionB && expressionA);
@@ -96,8 +95,8 @@ namespace
 
   TEST_F(BooleanTest, operator_or)
   {
-    ls::Boolean expressionA{false};
-    ls::Boolean expressionB{3 == 3};
+    ls::std::boxing::Boolean expressionA{false};
+    ls::std::boxing::Boolean expressionB{3 == 3};
 
     ASSERT_TRUE(expressionA || expressionB);
     ASSERT_TRUE(expressionB || expressionA);
@@ -108,8 +107,8 @@ namespace
 
   TEST_F(BooleanTest, operator_or_with_false_result)
   {
-    ls::Boolean expressionA{false};
-    ls::Boolean expressionB{3 == 4};
+    ls::std::boxing::Boolean expressionA{false};
+    ls::std::boxing::Boolean expressionB{3 == 4};
 
     ASSERT_FALSE(expressionA || expressionB);
     ASSERT_FALSE(expressionB || expressionA);
@@ -122,7 +121,7 @@ namespace
 
   TEST_F(BooleanTest, parse_true_value)
   {
-    ls::Boolean expression{};
+    ls::std::boxing::Boolean expression{};
 
     expression.parse("true");
     ASSERT_TRUE(expression);
@@ -136,7 +135,7 @@ namespace
 
   TEST_F(BooleanTest, parse_false_value)
   {
-    ls::Boolean expression{};
+    ls::std::boxing::Boolean expression{};
 
     expression.parse("false");
     ASSERT_FALSE(expression);
@@ -153,7 +152,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::Boolean expression{};
+                     ls::std::boxing::Boolean expression{};
                      expression.parse("hello");
                    } catch (const ls::IllegalArgumentException &_exception)
                    {
@@ -164,13 +163,13 @@ namespace
 
   TEST_F(BooleanTest, toString_true)
   {
-    ls::Boolean expression{2 < 3};
+    ls::std::boxing::Boolean expression{2 < 3};
     ASSERT_STREQ("true", expression.toString().c_str());
   }
 
   TEST_F(BooleanTest, toString_false)
   {
-    ls::Boolean expression{4 < 3};
+    ls::std::boxing::Boolean expression{4 < 3};
     ASSERT_STREQ("false", expression.toString().c_str());
   }
 
@@ -178,35 +177,35 @@ namespace
 
   TEST_F(BooleanTest, getValue)
   {
-    ls::Boolean x{2 < 3};
+    ls::std::boxing::Boolean x{2 < 3};
     ASSERT_TRUE(x.getValue());
   }
 
   TEST_F(BooleanTest, XOR_with_positive_result)
   {
-    ls::Boolean x{2 < 3};
-    ls::Boolean y{4 < 3};
+    ls::std::boxing::Boolean x{2 < 3};
+    ls::std::boxing::Boolean y{4 < 3};
 
-    ASSERT_TRUE(ls::Boolean::XOR(x, y));
-    ASSERT_TRUE(ls::Boolean::XOR(y, x));
-    ASSERT_TRUE(ls::Boolean::XOR(y, true));
-    ASSERT_TRUE(ls::Boolean::XOR(true, y));
-    ASSERT_TRUE(ls::Boolean::XOR(true, false));
-    ASSERT_TRUE(ls::Boolean::XOR(false, true));
+    ASSERT_TRUE(ls::std::boxing::Boolean::XOR(x, y));
+    ASSERT_TRUE(ls::std::boxing::Boolean::XOR(y, x));
+    ASSERT_TRUE(ls::std::boxing::Boolean::XOR(y, true));
+    ASSERT_TRUE(ls::std::boxing::Boolean::XOR(true, y));
+    ASSERT_TRUE(ls::std::boxing::Boolean::XOR(true, false));
+    ASSERT_TRUE(ls::std::boxing::Boolean::XOR(false, true));
   }
 
   TEST_F(BooleanTest, XOR_with_negative_result)
   {
-    ls::Boolean w{};
-    ls::Boolean x{true};
-    ls::Boolean y{};
-    ls::Boolean z{true};
-
-    ASSERT_FALSE(ls::Boolean::XOR(x, z));
-    ASSERT_FALSE(ls::Boolean::XOR(w, y));
-    ASSERT_FALSE(ls::Boolean::XOR(true, true));
-    ASSERT_FALSE(ls::Boolean::XOR(false, false));
-    ASSERT_FALSE(ls::Boolean::XOR(w, false));
-    ASSERT_FALSE(ls::Boolean::XOR(false, w));
+    ls::std::boxing::Boolean w{};
+    ls::std::boxing::Boolean x{true};
+    ls::std::boxing::Boolean y{};
+    ls::std::boxing::Boolean z{true};
+
+    ASSERT_FALSE(ls::std::boxing::Boolean::XOR(x, z));
+    ASSERT_FALSE(ls::std::boxing::Boolean::XOR(w, y));
+    ASSERT_FALSE(ls::std::boxing::Boolean::XOR(true, true));
+    ASSERT_FALSE(ls::std::boxing::Boolean::XOR(false, false));
+    ASSERT_FALSE(ls::std::boxing::Boolean::XOR(w, false));
+    ASSERT_FALSE(ls::std::boxing::Boolean::XOR(false, w));
   }
 }

test/cases/boxing/DoubleTest.cpp

@@ -9,7 +9,6 @@
 
 #include <gtest/gtest.h>
 #include <ls_std/ls_std.hpp>
-#include <TestHelper.hpp>
 
 namespace
 {
@@ -32,7 +31,7 @@ namespace
 
   TEST_F(DoubleTest, operator_assignment)
   {
-    ls::Double x{};
+    ls::std::boxing::Double x{};
     x = 44.22;
 
     ASSERT_EQ(44.22, x);
@@ -42,67 +41,67 @@ namespace
 
   TEST_F(DoubleTest, operator_negative)
   {
-    ls::Double x{3.25};
+    ls::std::boxing::Double x{3.25};
     ASSERT_DOUBLE_EQ(-3.25, -x);
   }
 
   TEST_F(DoubleTest, operator_addition_with_reference)
   {
-    ls::Double x{3.1415};
-    ls::Double y{2.223};
-    ls::Double z{x + y};
+    ls::std::boxing::Double x{3.1415};
+    ls::std::boxing::Double y{2.223};
+    ls::std::boxing::Double z{x + y};
 
     ASSERT_DOUBLE_EQ(5.3645, z);
   }
 
   TEST_F(DoubleTest, operator_addition_with_value)
   {
-    ls::Double x{3.1415};
+    ls::std::boxing::Double x{3.1415};
     ASSERT_DOUBLE_EQ(5.3645, x + 2.223);
   }
 
   TEST_F(DoubleTest, operator_multiplication_with_reference)
   {
-    ls::Double x{3.14};
-    ls::Double y{2.22};
-    ls::Double z{x * y};
+    ls::std::boxing::Double x{3.14};
+    ls::std::boxing::Double y{2.22};
+    ls::std::boxing::Double z{x * y};
 
     ASSERT_DOUBLE_EQ(6.9708, z);
   }
 
   TEST_F(DoubleTest, operator_multiplication_with_value)
   {
-    ls::Double x{3.14};
+    ls::std::boxing::Double x{3.14};
     ASSERT_DOUBLE_EQ(6.9708, x * 2.22);
   }
 
   TEST_F(DoubleTest, operator_substraction_with_reference)
   {
-    ls::Double x{3.1415};
-    ls::Double y{2.225};
-    ls::Double z{x - y};
+    ls::std::boxing::Double x{3.1415};
+    ls::std::boxing::Double y{2.225};
+    ls::std::boxing::Double z{x - y};
 
     ASSERT_DOUBLE_EQ(0.9165, z);
   }
 
   TEST_F(DoubleTest, operator_substraction_with_value)
   {
-    ls::Double x{3.1415};
+    ls::std::boxing::Double x{3.1415};
     ASSERT_DOUBLE_EQ(0.9165, x - 2.225);
   }
 
   TEST_F(DoubleTest, operator_division_with_reference)
   {
-    ls::Double x{2.25};
-    ls::Double y{0.5};
-    ls::Double z{x / y};
+    ls::std::boxing::Double x{2.25};
+    ls::std::boxing::Double y{0.5};
+    ls::std::boxing::Double z{x / y};
 
     ASSERT_DOUBLE_EQ(4.5, z);
   }
 
   TEST_F(DoubleTest, operator_division_with_value)
   {
-    ls::Double x{2.25};
+    ls::std::boxing::Double x{2.25};
     ASSERT_DOUBLE_EQ(4.5, x / 0.5);
   }
 
@@ -110,8 +109,8 @@ namespace
 
   TEST_F(DoubleTest, operator_add_assign_with_reference)
   {
-    ls::Double x{2.25000000};
-    ls::Double y{3.14000000};
+    ls::std::boxing::Double x{2.25000000};
+    ls::std::boxing::Double y{3.14000000};
 
     x += y;
     ASSERT_DOUBLE_EQ(5.39000000, x);
@@ -119,7 +118,7 @@ namespace
 
   TEST_F(DoubleTest, operator_add_assign_with_value)
   {
-    ls::Double x{2.25000000};
+    ls::std::boxing::Double x{2.25000000};
 
     x += 3.14000000;
     ASSERT_DOUBLE_EQ(5.39000000, x);
@@ -127,8 +126,8 @@ namespace
 
   TEST_F(DoubleTest, operator_sub_assign_with_reference)
   {
-    ls::Double x{2.25};
-    ls::Double y{0.04};
+    ls::std::boxing::Double x{2.25};
+    ls::std::boxing::Double y{0.04};
 
     x -= y;
     ASSERT_DOUBLE_EQ(2.21, x);
@@ -136,7 +135,7 @@ namespace
 
   TEST_F(DoubleTest, operator_sub_assign_with_value)
   {
-    ls::Double x{2.25};
+    ls::std::boxing::Double x{2.25};
 
     x -= 0.04;
     ASSERT_DOUBLE_EQ(2.21, x);
@@ -144,8 +143,8 @@ namespace
 
   TEST_F(DoubleTest, operator_mul_assign_with_reference)
   {
-    ls::Double x{2.25000000};
-    ls::Double y{0.04000000};
+    ls::std::boxing::Double x{2.25000000};
+    ls::std::boxing::Double y{0.04000000};
 
     x *= y;
     ASSERT_DOUBLE_EQ(0.09000000, x);
@@ -153,7 +152,7 @@ namespace
 
   TEST_F(DoubleTest, operator_mul_assign_with_value)
   {
-    ls::Double x{2.25000000};
+    ls::std::boxing::Double x{2.25000000};
 
     x *= 0.04000000;
     ASSERT_DOUBLE_EQ(0.09000000, x);
@@ -161,8 +160,8 @@ namespace
 
   TEST_F(DoubleTest, operator_division_assign_with_reference)
   {
-    ls::Double x{2.25};
-    ls::Double y{0.05};
+    ls::std::boxing::Double x{2.25};
+    ls::std::boxing::Double y{0.05};
 
     x /= y;
     ASSERT_DOUBLE_EQ(45.0, x);
@@ -170,7 +169,7 @@ namespace
 
   TEST_F(DoubleTest, operator_division_assign_with_value)
   {
-    ls::Double x{2.25};
+    ls::std::boxing::Double x{2.25};
 
     x /= 0.05;
     ASSERT_DOUBLE_EQ(45.0, x);
@@ -180,8 +179,8 @@ namespace
 
   TEST_F(DoubleTest, operator_equals_with_reference)
   {
-    ls::Double x{3.14159};
-    ls::Double y{3.14159};
+    ls::std::boxing::Double x{3.14159};
+    ls::std::boxing::Double y{3.14159};
 
     ASSERT_TRUE(x == y);
     ASSERT_TRUE(y == x);
@@ -189,7 +188,7 @@ namespace
 
   TEST_F(DoubleTest, operator_equals_with_value)
   {
-    ls::Double x{3.14159};
+    ls::std::boxing::Double x{3.14159};
 
     ASSERT_TRUE(x == 3.14159);
     ASSERT_TRUE(3.14159 == x);
@@ -197,8 +196,8 @@ namespace
 
   TEST_F(DoubleTest, operator_not_equal_with_reference)
   {
-    ls::Double x{3.1415};
-    ls::Double y{3.1414};
+    ls::std::boxing::Double x{3.1415};
+    ls::std::boxing::Double y{3.1414};
 
     ASSERT_TRUE(x != y);
     ASSERT_TRUE(y != x);
@@ -206,7 +205,7 @@ namespace
 
   TEST_F(DoubleTest, operator_not_equal_with_value)
   {
-    ls::Double x{3.1415};
+    ls::std::boxing::Double x{3.1415};
 
     ASSERT_TRUE(x != 3.1414);
     ASSERT_TRUE(3.1414 != x);
@@ -214,25 +213,25 @@ namespace
 
   TEST_F(DoubleTest, operator_greater_than_with_reference)
   {
-    ls::Double x{3.1415};
-    ls::Double y{3.1414};
+    ls::std::boxing::Double x{3.1415};
+    ls::std::boxing::Double y{3.1414};
 
     ASSERT_TRUE(x > y);
   }
 
   TEST_F(DoubleTest, operator_greater_than_with_value)
   {
-    ls::Double x{3.1415};
-    ls::Double y{3.1414};
+    ls::std::boxing::Double x{3.1415};
+    ls::std::boxing::Double y{3.1414};
 
     ASSERT_TRUE(x > 3.1414);
   }
 
   TEST_F(DoubleTest, operator_greater_than_equals_with_reference)
   {
-    ls::Double x{3.1414};
-    ls::Double y{3.1414};
-    ls::Double z{3.1415};
+    ls::std::boxing::Double x{3.1414};
+    ls::std::boxing::Double y{3.1414};
+    ls::std::boxing::Double z{3.1415};
 
     ASSERT_TRUE(x >= y);
     ASSERT_TRUE(z >= y);
@@ -240,31 +239,31 @@ namespace
 
   TEST_F(DoubleTest, operator_greater_than_equals_with_value)
   {
-    ls::Double x{3.1414};
+    ls::std::boxing::Double x{3.1414};
     ASSERT_TRUE(x >= 3.1414);
   }
 
   TEST_F(DoubleTest, operator_less_than_with_reference)
   {
-    ls::Double x{3.1413};
-    ls::Double y{3.1414};
+    ls::std::boxing::Double x{3.1413};
+    ls::std::boxing::Double y{3.1414};
 
     ASSERT_TRUE(x < y);
   }
 
   TEST_F(DoubleTest, operator_less_than_with_value)
   {
-    ls::Double x{3.1413};
-    ls::Double y{3.1414};
+    ls::std::boxing::Double x{3.1413};
+    ls::std::boxing::Double y{3.1414};
 
     ASSERT_TRUE(x < 3.1414);
   }
 
   TEST_F(DoubleTest, operator_less_than_equals_with_reference)
   {
-    ls::Double x{3.1414};
-    ls::Double y{3.1414};
-    ls::Double z{3.1415};
+    ls::std::boxing::Double x{3.1414};
+    ls::std::boxing::Double y{3.1414};
+    ls::std::boxing::Double z{3.1415};
 
     ASSERT_TRUE(x <= y);
     ASSERT_TRUE(x <= z);
@@ -272,7 +271,7 @@ namespace
 
   TEST_F(DoubleTest, operator_less_than_equals_with_value)
   {
-    ls::Double x{3.1414};
+    ls::std::boxing::Double x{3.1414};
     ASSERT_TRUE(x <= 3.1414);
   }
 
@@ -280,7 +279,7 @@ namespace
 
   TEST_F(DoubleTest, operator_increment)
   {
-    ls::Double x{3.1415};
+    ls::std::boxing::Double x{3.1415};
 
     ++x;
     ASSERT_DOUBLE_EQ(4.1415, x);
@@ -288,7 +287,7 @@ namespace
 
   TEST_F(DoubleTest, operator_decrement)
   {
-    ls::Double x{3.1415};
+    ls::std::boxing::Double x{3.1415};
 
     --x;
     ASSERT_DOUBLE_EQ(2.1415, x);
@@ -298,7 +297,7 @@ namespace
 
   TEST_F(DoubleTest, parse_with_positive_value)
   {
-    ls::Double x{};
+    ls::std::boxing::Double x{};
 
     x.parse("3.1415");
     ASSERT_DOUBLE_EQ(3.1415, x);
@@ -306,7 +305,7 @@ namespace
 
   TEST_F(DoubleTest, parse_with_negative_value)
   {
-    ls::Double x{};
+    ls::std::boxing::Double x{};
 
     x.parse("-2.1415");
     ASSERT_DOUBLE_EQ(-2.1415, x);
@@ -314,7 +313,7 @@ namespace
 
   TEST_F(DoubleTest, toString)
   {
-    ls::Double x{13.1543};
+    ls::std::boxing::Double x{13.1543};
     ASSERT_TRUE(x.toString().find("13.1543") != std::string::npos);
   }
 
@@ -322,19 +321,19 @@ namespace
 
   TEST_F(DoubleTest, getEpsilon)
   {
-    ls::Double x{};
+    ls::std::boxing::Double x{};
     ASSERT_DOUBLE_EQ(0.00000001, x.getEpsilon());
   }
 
   TEST_F(DoubleTest, getValue)
   {
-    ls::Double x{3.1415};
+    ls::std::boxing::Double x{3.1415};
     ASSERT_DOUBLE_EQ(3.1415, x.getValue());
   }
 
   TEST_F(DoubleTest, setEpsilon)
   {
-    ls::Double x{};
+    ls::std::boxing::Double x{};
     x.setEpsilon(0.01);
 
     ASSERT_DOUBLE_EQ(0.01, x.getEpsilon());
@@ -342,7 +341,7 @@ namespace
 
   TEST_F(DoubleTest, setEpsilon_invalid_value)
   {
-    ls::Double x{};
+    ls::std::boxing::Double x{};
 
     EXPECT_THROW({
                    try

test/cases/boxing/FloatTest.cpp

@@ -9,7 +9,6 @@
 
 #include <gtest/gtest.h>
 #include <ls_std/ls_std.hpp>
-#include <TestHelper.hpp>
 
 namespace
 {
@@ -31,7 +30,7 @@ namespace
 
   TEST_F(FloatTest, operator_assignment)
   {
-    ls::Float x{13.023f};
+    ls::std::boxing::Float x{13.023f};
 
     x = 44.22f;
     ASSERT_EQ(44.22f, x);
@@ -41,67 +40,67 @@ namespace
 
   TEST_F(FloatTest, operator_negative)
   {
-    ls::Float x{3.25f};
+    ls::std::boxing::Float x{3.25f};
     ASSERT_FLOAT_EQ(-3.25f, -x);
   }
 
   TEST_F(FloatTest, operator_addition_with_reference)
   {
-    ls::Float x{3.1415f};
-    ls::Float y{2.223f};
-    ls::Float z{x + y};
+    ls::std::boxing::Float x{3.1415f};
+    ls::std::boxing::Float y{2.223f};
+    ls::std::boxing::Float z{x + y};
 
     ASSERT_FLOAT_EQ(5.3645f, z);
   }
 
   TEST_F(FloatTest, operator_addition_with_value)
   {
-    ls::Float x{3.1415f};
+    ls::std::boxing::Float x{3.1415f};
     ASSERT_FLOAT_EQ(5.3645f, x + 2.223f);
   }
 
   TEST_F(FloatTest, operator_multiplication_with_reference)
   {
-    ls::Float x{3.14f};
-    ls::Float y{2.22f};
-    ls::Float z{x * y};
+    ls::std::boxing::Float x{3.14f};
+    ls::std::boxing::Float y{2.22f};
+    ls::std::boxing::Float z{x * y};
 
     ASSERT_FLOAT_EQ(6.9708f, z);
   }
 
   TEST_F(FloatTest, operator_multiplication_with_value)
   {
-    ls::Float x{3.14f};
+    ls::std::boxing::Float x{3.14f};
     ASSERT_FLOAT_EQ(6.9708f, x * 2.22f);
   }
 
   TEST_F(FloatTest, operator_substraction_with_reference)
   {
-    ls::Float x{3.1415f};
-    ls::Float y{2.225f};
-    ls::Float z{x - y};
+    ls::std::boxing::Float x{3.1415f};
+    ls::std::boxing::Float y{2.225f};
+    ls::std::boxing::Float z{x - y};
 
     ASSERT_FLOAT_EQ(0.9165f, z);
   }
 
   TEST_F(FloatTest, operator_substraction_with_value)
   {
-    ls::Float x{3.1415f};
+    ls::std::boxing::Float x{3.1415f};
     ASSERT_FLOAT_EQ(0.9165f, x - 2.225f);
   }
 
   TEST_F(FloatTest, operator_division_with_reference)
   {
-    ls::Float x{2.25f};
-    ls::Float y{0.5f};
-    ls::Float z{x / y};
+    ls::std::boxing::Float x{2.25f};
+    ls::std::boxing::Float y{0.5f};
+    ls::std::boxing::Float z{x / y};
 
     ASSERT_FLOAT_EQ(4.5f, z);
   }
 
   TEST_F(FloatTest, operator_division_with_value)
   {
-    ls::Float x{2.25f};
+    ls::std::boxing::Float x{2.25f};
     ASSERT_FLOAT_EQ(4.5f, x / 0.5f);
   }
 
@@ -109,8 +108,8 @@ namespace
 
   TEST_F(FloatTest, operator_add_assign_with_reference)
   {
-    ls::Float x{2.25f};
-    ls::Float y{3.14f};
+    ls::std::boxing::Float x{2.25f};
+    ls::std::boxing::Float y{3.14f};
     x += y;
 
     ASSERT_FLOAT_EQ(5.39f, x);
@@ -118,7 +117,7 @@ namespace
 
   TEST_F(FloatTest, operator_add_assign_with_value)
   {
-    ls::Float x{2.25f};
+    ls::std::boxing::Float x{2.25f};
     x += 3.14f;
 
     ASSERT_FLOAT_EQ(5.39f, x);
@@ -126,8 +125,8 @@ namespace
 
   TEST_F(FloatTest, operator_sub_assign_with_reference)
   {
-    ls::Float x{2.25f};
-    ls::Float y{1.14f};
+    ls::std::boxing::Float x{2.25f};
+    ls::std::boxing::Float y{1.14f};
     x -= y;
 
     ASSERT_FLOAT_EQ(1.11f, x);
@@ -135,7 +134,7 @@ namespace
 
   TEST_F(FloatTest, operator_sub_assign_with_value)
   {
-    ls::Float x{2.25f};
+    ls::std::boxing::Float x{2.25f};
     x -= 1.14f;
 
     ASSERT_FLOAT_EQ(1.11f, x);
@@ -143,8 +142,8 @@ namespace
 
   TEST_F(FloatTest, operator_mul_assign_with_reference)
   {
-    ls::Float x{2.25f};
-    ls::Float y{0.04f};
+    ls::std::boxing::Float x{2.25f};
+    ls::std::boxing::Float y{0.04f};
     x *= y;
 
     ASSERT_FLOAT_EQ(0.09f, x);
@@ -152,7 +151,7 @@ namespace
 
   TEST_F(FloatTest, operator_mul_assign_with_value)
   {
-    ls::Float x{2.25f};
+    ls::std::boxing::Float x{2.25f};
     x *= 1.14f;
 
     ASSERT_FLOAT_EQ(2.565f, x);
@@ -160,8 +159,8 @@ namespace
 
   TEST_F(FloatTest, operator_division_assign_with_reference)
   {
-    ls::Float x{2.25f};
-    ls::Float y{1.5f};
+    ls::std::boxing::Float x{2.25f};
+    ls::std::boxing::Float y{1.5f};
     x /= y;
 
     ASSERT_FLOAT_EQ(1.5f, x);
@@ -169,7 +168,7 @@ namespace
 
   TEST_F(FloatTest, operator_division_assign_with_value)
   {
-    ls::Float x{2.25f};
+    ls::std::boxing::Float x{2.25f};
     x /= 0.05f;
 
     ASSERT_FLOAT_EQ(45.0f, x);
@@ -179,8 +178,8 @@ namespace
 
   TEST_F(FloatTest, operator_equals_with_reference)
   {
-    ls::Float x{3.14159f};
-    ls::Float y{3.14159f};
+    ls::std::boxing::Float x{3.14159f};
+    ls::std::boxing::Float y{3.14159f};
 
     ASSERT_TRUE(x == y);
     ASSERT_TRUE(y == x);
@@ -188,14 +187,14 @@ namespace
 
   TEST_F(FloatTest, operator_equals_with_value)
   {
-    ls::Float x{3.14159f};
+    ls::std::boxing::Float x{3.14159f};
     ASSERT_TRUE(x == 3.14159f);
   }
 
   TEST_F(FloatTest, operator_not_equals_with_reference)
   {
-    ls::Float x{3.1415f};
-    ls::Float y{3.1414f};
+    ls::std::boxing::Float x{3.1415f};
+    ls::std::boxing::Float y{3.1414f};
 
     ASSERT_TRUE(x != y);
     ASSERT_TRUE(y != x);
@@ -203,14 +202,14 @@ namespace
 
   TEST_F(FloatTest, operator_not_equals_with_value)
   {
-    ls::Float x{3.1415f};
+    ls::std::boxing::Float x{3.1415f};
     ASSERT_TRUE(x != 3.1414f);
   }
 
   TEST_F(FloatTest, operator_greater_than_with_reference)
   {
-    ls::Float x{3.1415f};
-    ls::Float y{3.1414f};
+    ls::std::boxing::Float x{3.1415f};
+    ls::std::boxing::Float y{3.1414f};
 
     ASSERT_TRUE(x > y);
     ASSERT_TRUE(x > 3.1414f);
@@ -218,15 +217,15 @@ namespace
 
   TEST_F(FloatTest, operator_greater_than_with_value)
   {
-    ls::Float x{3.1415f};
+    ls::std::boxing::Float x{3.1415f};
     ASSERT_TRUE(x > 3.1414f);
   }
 
   TEST_F(FloatTest, operator_greater_than_equals_with_reference)
   {
-    ls::Float x{3.1414f};
-    ls::Float y{3.1414f};
-    ls::Float z{3.1415f};
+    ls::std::boxing::Float x{3.1414f};
+    ls::std::boxing::Float y{3.1414f};
+    ls::std::boxing::Float z{3.1415f};
 
     ASSERT_TRUE(x >= y);
     ASSERT_TRUE(z >= y);
@@ -234,8 +233,8 @@ namespace
 
   TEST_F(FloatTest, operator_greater_than_equals_with_value)
   {
-    ls::Float x{3.1414f};
-    ls::Float z{3.1415f};
+    ls::std::boxing::Float x{3.1414f};
+    ls::std::boxing::Float z{3.1415f};
 
     ASSERT_TRUE(x >= 3.1414f);
     ASSERT_TRUE(z >= 3.1414f);
@@ -243,23 +242,23 @@ namespace
 
   TEST_F(FloatTest, operator_less_than_with_reference)
   {
-    ls::Float x{3.1413f};
-    ls::Float y{3.1414f};
+    ls::std::boxing::Float x{3.1413f};
+    ls::std::boxing::Float y{3.1414f};
 
     ASSERT_TRUE(x < y);
   }
 
   TEST_F(FloatTest, operator_less_than_with_value)
   {
-    ls::Float x{3.1413f};
+    ls::std::boxing::Float x{3.1413f};
     ASSERT_TRUE(x < 3.1414f);
   }
 
   TEST_F(FloatTest, operator_less_than_equals_with_reference)
   {
-    ls::Float x{3.1414f};
-    ls::Float y{3.1414f};
-    ls::Float z{3.1415f};
+    ls::std::boxing::Float x{3.1414f};
+    ls::std::boxing::Float y{3.1414f};
+    ls::std::boxing::Float z{3.1415f};
 
     ASSERT_TRUE(x <= y);
     ASSERT_TRUE(x <= z);
@@ -267,7 +266,7 @@ namespace
 
   TEST_F(FloatTest, operator_less_than_equals_with_value)
   {
-    ls::Float x{3.1414f};
+    ls::std::boxing::Float x{3.1414f};
 
     ASSERT_TRUE(x <= 3.1414f);
     ASSERT_TRUE(x <= 3.1415f);
@@ -277,7 +276,7 @@ namespace
 
   TEST_F(FloatTest, operator_increment)
   {
-    ls::Float x{3.1415f};
+    ls::std::boxing::Float x{3.1415f};
     ++x;
 
     ASSERT_FLOAT_EQ(4.1415f, x);
@@ -285,7 +284,7 @@ namespace
 
   TEST_F(FloatTest, operator_decrement)
   {
-    ls::Float x{3.1415f};
+    ls::std::boxing::Float x{3.1415f};
     --x;
 
     ASSERT_FLOAT_EQ(2.1415f, x);
@@ -295,7 +294,7 @@ namespace
 
   TEST_F(FloatTest, parse)
   {
-    ls::Float number{};
+    ls::std::boxing::Float number{};
 
     number.parse("3.1415f");
     ASSERT_FLOAT_EQ(3.1415f, number);
@@ -303,7 +302,7 @@ namespace
 
   TEST_F(FloatTest, toString)
   {
-    ls::Float x{13.1543f};
+    ls::std::boxing::Float x{13.1543f};
     ASSERT_TRUE(x.toString().find("13.1543") != std::string::npos);
   }
 
@@ -311,19 +310,19 @@ namespace
 
   TEST_F(FloatTest, getEpsilon)
   {
-    ls::Float x{};
+    ls::std::boxing::Float x{};
     ASSERT_FLOAT_EQ(0.00001f, x.getEpsilon());
   }
 
   TEST_F(FloatTest, getValue)
   {
-    ls::Float x{3.1415f};
+    ls::std::boxing::Float x{3.1415f};
     ASSERT_FLOAT_EQ(3.1415f, x.getValue());
   }
 
   TEST_F(FloatTest, setEpsilon)
   {
-    ls::Float x{};
+    ls::std::boxing::Float x{};
     x.setEpsilon(0.01f);
 
     ASSERT_FLOAT_EQ(0.01f, x.getEpsilon());
@@ -331,7 +330,7 @@ namespace
 
   TEST_F(FloatTest, setEpsilon_invalid_value)
   {
-    ls::Float x{};
+    ls::std::boxing::Float x{};
 
     EXPECT_THROW({
                    try

test/cases/boxing/IntegerTest.cpp

@@ -18,7 +18,6 @@ namespace
     protected:
 
       IntegerTest() = default;
-
       ~IntegerTest() override = default;
 
       void SetUp() override

test/cases/boxing/StringTest.cpp

@@ -9,7 +9,6 @@
 
 #include <gtest/gtest.h>
 #include <ls_std/ls_std.hpp>
-#include <TestHelper.hpp>
 
 namespace
 {