Improve namespace layout for "boxing" module

include/ls_std/boxing/Boolean.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2022-06-29
+ * Changed:         2022-07-02
  *
  * */
 
@@ -16,76 +16,70 @@
 #include <ls_std/core/interface/IBoxing.hpp>
 #include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::boxing
 {
-  namespace std
+  class DYNAMIC_GOAL Boolean : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
   {
-    namespace boxing
-    {
-      class DYNAMIC_GOAL Boolean : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
-      {
-        public:
+    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::std::boxing::Boolean &operator=(int _value);
-          ls::std::boxing::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::std::boxing::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::std::boxing::Boolean &_boolean)
-          {
-            return !_boolean.value;
-          }
+      friend bool operator!(const ls::std::boxing::Boolean &_boolean)
+      {
+        return !_boolean.value;
+      }
 
-          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
+      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::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);
+      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-06-29
+ * Changed:         2022-07-02
  *
  * */
 
@@ -15,91 +15,85 @@
 #include <ls_std/core/interface/IBoxing.hpp>
 #include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::boxing
 {
-  namespace std
+  class DYNAMIC_GOAL Double : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
   {
-    namespace boxing
-    {
-      class DYNAMIC_GOAL Double : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
-      {
-        public:
+    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::std::boxing::Double &operator=(double _value);
+      ls::std::boxing::Double &operator=(double _value);
 
-          // arithmetic operators
+      // arithmetic operators
 
-          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;
+      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::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);
+      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::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;
+      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-06-29
+ * Changed:         2022-07-02
  *
  * */
 
@@ -15,91 +15,85 @@
 #include <ls_std/core/interface/IBoxing.hpp>
 #include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::boxing
 {
-  namespace std
+  class DYNAMIC_GOAL Float : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
   {
-    namespace boxing
-    {
-      class DYNAMIC_GOAL Float : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
-      {
-        public:
+    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::std::boxing::Float &operator=(float _value);
+      ls::std::boxing::Float &operator=(float _value);
 
-          // arithmetic operators
+      // arithmetic operators
 
-          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;
+      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::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);
+      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::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;
+      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/Integer.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2022-06-29
+ * Changed:         2022-07-02
  *
  * */
 
@@ -15,102 +15,96 @@
 #include <ls_std/core/interface/IBoxing.hpp>
 #include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::boxing
 {
-  namespace std
+  class DYNAMIC_GOAL Integer : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
   {
-    namespace boxing
-    {
-      class DYNAMIC_GOAL Integer : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
+    public:
+
+      explicit Integer(int _value);
+      Integer();
+      ~Integer() override = default;
+
+      // conversion operator
+
+      operator int() const;
+
+      // assignment operators
+
+      ls::std::boxing::Integer &operator=(int _value);
+
+      // arithmetic operators
+
+      int operator-() const;
+      int operator+(const ls::std::boxing::Integer &_integer) const;
+      int operator+(int _value) const;
+      int operator*(const ls::std::boxing::Integer &_integer) const;
+      int operator*(int _value) const;
+      int operator-(const ls::std::boxing::Integer &_integer) const;
+      int operator-(int _value) const;
+      int operator/(const ls::std::boxing::Integer &_integer) const;
+      int operator/(int _value) const;
+      int operator%(const ls::std::boxing::Integer &_integer) const;
+      int operator%(int _value) const;
+
+      // compound operators
+
+      ls::std::boxing::Integer &operator+=(const ls::std::boxing::Integer &_integer);
+      ls::std::boxing::Integer &operator+=(int _value);
+      ls::std::boxing::Integer &operator-=(const ls::std::boxing::Integer &_integer);
+      ls::std::boxing::Integer &operator-=(int _value);
+      ls::std::boxing::Integer &operator*=(const ls::std::boxing::Integer &_integer);
+      ls::std::boxing::Integer &operator*=(int _value);
+      ls::std::boxing::Integer &operator/=(const ls::std::boxing::Integer &_integer);
+      ls::std::boxing::Integer &operator/=(int _value);
+
+      // comparison operators
+
+      bool operator==(const ls::std::boxing::Integer &_integer) const;
+      bool operator==(int _value) const;
+      bool operator!=(const ls::std::boxing::Integer &_integer) const;
+      bool operator!=(int _value) const;
+      bool operator>(const ls::std::boxing::Integer &_integer) const;
+      bool operator>(int _value) const;
+      bool operator>=(const ls::std::boxing::Integer &_integer) const;
+      bool operator>=(int _value) const;
+      bool operator<(const ls::std::boxing::Integer &_integer) const;
+      bool operator<(int _value) const;
+      bool operator<=(const ls::std::boxing::Integer &_integer) const;
+      bool operator<=(int _value) const;
+
+      // logical operators
+
+      friend bool operator!(const ls::std::boxing::Integer &_integer)
       {
-        public:
+        return !_integer.value;
+      }
 
-          explicit Integer(int _value);
-          Integer();
-          ~Integer() override = default;
+      bool operator&&(const ls::std::boxing::Integer &_integer) const;
+      bool operator&&(int _value) const;
+      bool operator&&(bool _expression) const;
+      bool operator||(const ls::std::boxing::Integer &_integer) const;
+      bool operator||(int _value) const;
+      bool operator||(bool _expression) const;
 
-          // conversion operator
+      // increment / decrement operator
 
-          operator int() const;
+      void operator++();
+      void operator--();
 
-          // assignment operators
+      // implementation
 
-          ls::std::boxing::Integer &operator=(int _value);
+      void parse(::std::string _parseText) override;
+      ::std::string toString() override;
 
-          // arithmetic operators
+      // additional functionality
 
-          int operator-() const;
-          int operator+(const ls::std::boxing::Integer &_integer) const;
-          int operator+(int _value) const;
-          int operator*(const ls::std::boxing::Integer &_integer) const;
-          int operator*(int _value) const;
-          int operator-(const ls::std::boxing::Integer &_integer) const;
-          int operator-(int _value) const;
-          int operator/(const ls::std::boxing::Integer &_integer) const;
-          int operator/(int _value) const;
-          int operator%(const ls::std::boxing::Integer &_integer) const;
-          int operator%(int _value) const;
+      int getValue() const;
 
-          // compound operators
+    private:
 
-          ls::std::boxing::Integer &operator+=(const ls::std::boxing::Integer &_integer);
-          ls::std::boxing::Integer &operator+=(int _value);
-          ls::std::boxing::Integer &operator-=(const ls::std::boxing::Integer &_integer);
-          ls::std::boxing::Integer &operator-=(int _value);
-          ls::std::boxing::Integer &operator*=(const ls::std::boxing::Integer &_integer);
-          ls::std::boxing::Integer &operator*=(int _value);
-          ls::std::boxing::Integer &operator/=(const ls::std::boxing::Integer &_integer);
-          ls::std::boxing::Integer &operator/=(int _value);
-
-          // comparison operators
-
-          bool operator==(const ls::std::boxing::Integer &_integer) const;
-          bool operator==(int _value) const;
-          bool operator!=(const ls::std::boxing::Integer &_integer) const;
-          bool operator!=(int _value) const;
-          bool operator>(const ls::std::boxing::Integer &_integer) const;
-          bool operator>(int _value) const;
-          bool operator>=(const ls::std::boxing::Integer &_integer) const;
-          bool operator>=(int _value) const;
-          bool operator<(const ls::std::boxing::Integer &_integer) const;
-          bool operator<(int _value) const;
-          bool operator<=(const ls::std::boxing::Integer &_integer) const;
-          bool operator<=(int _value) const;
-
-          // logical operators
-
-          friend bool operator!(const ls::std::boxing::Integer &_integer)
-          {
-            return !_integer.value;
-          }
-
-          bool operator&&(const ls::std::boxing::Integer &_integer) const;
-          bool operator&&(int _value) const;
-          bool operator&&(bool _expression) const;
-          bool operator||(const ls::std::boxing::Integer &_integer) const;
-          bool operator||(int _value) const;
-          bool operator||(bool _expression) const;
-
-          // increment / decrement operator
-
-          void operator++();
-          void operator--();
-
-          // implementation
-
-          void parse(::std::string _parseText) override;
-          ::std::string toString() override;
-
-          // additional functionality
-
-          int getValue() const;
-
-        private:
-
-          int value{};
-      };
-    }
-  }
+      int value{};
+  };
 }
 
 #endif

include/ls_std/boxing/Long.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-06-29
+ * Changed:         2022-07-02
  *
  * */
 
@@ -16,102 +16,96 @@
 #include <ls_std/core/types/Types.hpp>
 #include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::boxing
 {
-  namespace std
+  class DYNAMIC_GOAL Long : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
   {
-    namespace boxing
-    {
-      class DYNAMIC_GOAL Long : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
+    public:
+
+      explicit Long(ls::std::core::type::long_type _value);
+      Long();
+      ~Long() override = default;
+
+      // conversion operator
+
+      operator ls::std::core::type::long_type() const;
+
+      // assignment operators
+
+      ls::std::boxing::Long &operator=(ls::std::core::type::long_type _value);
+
+      // arithmetic operators
+
+      ls::std::core::type::long_type operator-() const;
+      ls::std::core::type::long_type operator+(const ls::std::boxing::Long &_long) const;
+      ls::std::core::type::long_type operator+(ls::std::core::type::long_type _value) const;
+      ls::std::core::type::long_type operator*(const ls::std::boxing::Long &_long) const;
+      ls::std::core::type::long_type operator*(ls::std::core::type::long_type _value) const;
+      ls::std::core::type::long_type operator-(const ls::std::boxing::Long &_long) const;
+      ls::std::core::type::long_type operator-(ls::std::core::type::long_type _value) const;
+      ls::std::core::type::long_type operator/(const ls::std::boxing::Long &_long) const;
+      ls::std::core::type::long_type operator/(ls::std::core::type::long_type _value) const;
+      ls::std::core::type::long_type operator%(const ls::std::boxing::Long &_long) const;
+      ls::std::core::type::long_type operator%(ls::std::core::type::long_type _value) const;
+
+      // compound operators
+
+      ls::std::boxing::Long &operator+=(const ls::std::boxing::Long &_long);
+      ls::std::boxing::Long &operator+=(ls::std::core::type::long_type _value);
+      ls::std::boxing::Long &operator-=(const ls::std::boxing::Long &_long);
+      ls::std::boxing::Long &operator-=(ls::std::core::type::long_type _value);
+      ls::std::boxing::Long &operator*=(const ls::std::boxing::Long &_long);
+      ls::std::boxing::Long &operator*=(ls::std::core::type::long_type _value);
+      ls::std::boxing::Long &operator/=(const ls::std::boxing::Long &_long);
+      ls::std::boxing::Long &operator/=(ls::std::core::type::long_type _value);
+
+      // comparison operators
+
+      bool operator==(const ls::std::boxing::Long &_long) const;
+      bool operator==(ls::std::core::type::long_type _value) const;
+      bool operator!=(const ls::std::boxing::Long &_long) const;
+      bool operator!=(ls::std::core::type::long_type _value) const;
+      bool operator>(const ls::std::boxing::Long &_long) const;
+      bool operator>(ls::std::core::type::long_type _value) const;
+      bool operator>=(const ls::std::boxing::Long &_long) const;
+      bool operator>=(ls::std::core::type::long_type _value) const;
+      bool operator<(const ls::std::boxing::Long &_long) const;
+      bool operator<(ls::std::core::type::long_type _value) const;
+      bool operator<=(const ls::std::boxing::Long &_long) const;
+      bool operator<=(ls::std::core::type::long_type _value) const;
+
+      // logical operators
+
+      friend bool operator!(const ls::std::boxing::Long &_long)
       {
-        public:
+        return !_long.value;
+      }
 
-          explicit Long(ls::std::core::type::long_type _value);
-          Long();
-          ~Long() override = default;
+      bool operator&&(const ls::std::boxing::Long &_long) const;
+      bool operator&&(ls::std::core::type::long_type _value) const;
+      bool operator&&(bool _expression) const;
+      bool operator||(const ls::std::boxing::Long &_long) const;
+      bool operator||(ls::std::core::type::long_type _value) const;
+      bool operator||(bool _expression) const;
 
-          // conversion operator
+      // increment / decrement operator
 
-          operator ls::std::core::type::long_type() const;
+      void operator++();
+      void operator--();
 
-          // assignment operators
+      // implementation
 
-          ls::std::boxing::Long &operator=(ls::std::core::type::long_type _value);
+      void parse(::std::string _parseText) override;
+      ::std::string toString() override;
 
-          // arithmetic operators
+      // additional functionality
 
-          ls::std::core::type::long_type operator-() const;
-          ls::std::core::type::long_type operator+(const ls::std::boxing::Long &_long) const;
-          ls::std::core::type::long_type operator+(ls::std::core::type::long_type _value) const;
-          ls::std::core::type::long_type operator*(const ls::std::boxing::Long &_long) const;
-          ls::std::core::type::long_type operator*(ls::std::core::type::long_type _value) const;
-          ls::std::core::type::long_type operator-(const ls::std::boxing::Long &_long) const;
-          ls::std::core::type::long_type operator-(ls::std::core::type::long_type _value) const;
-          ls::std::core::type::long_type operator/(const ls::std::boxing::Long &_long) const;
-          ls::std::core::type::long_type operator/(ls::std::core::type::long_type _value) const;
-          ls::std::core::type::long_type operator%(const ls::std::boxing::Long &_long) const;
-          ls::std::core::type::long_type operator%(ls::std::core::type::long_type _value) const;
+      ls::std::core::type::long_type getValue() const;
 
-          // compound operators
+    private:
 
-          ls::std::boxing::Long &operator+=(const ls::std::boxing::Long &_long);
-          ls::std::boxing::Long &operator+=(ls::std::core::type::long_type _value);
-          ls::std::boxing::Long &operator-=(const ls::std::boxing::Long &_long);
-          ls::std::boxing::Long &operator-=(ls::std::core::type::long_type _value);
-          ls::std::boxing::Long &operator*=(const ls::std::boxing::Long &_long);
-          ls::std::boxing::Long &operator*=(ls::std::core::type::long_type _value);
-          ls::std::boxing::Long &operator/=(const ls::std::boxing::Long &_long);
-          ls::std::boxing::Long &operator/=(ls::std::core::type::long_type _value);
-
-          // comparison operators
-
-          bool operator==(const ls::std::boxing::Long &_long) const;
-          bool operator==(ls::std::core::type::long_type _value) const;
-          bool operator!=(const ls::std::boxing::Long &_long) const;
-          bool operator!=(ls::std::core::type::long_type _value) const;
-          bool operator>(const ls::std::boxing::Long &_long) const;
-          bool operator>(ls::std::core::type::long_type _value) const;
-          bool operator>=(const ls::std::boxing::Long &_long) const;
-          bool operator>=(ls::std::core::type::long_type _value) const;
-          bool operator<(const ls::std::boxing::Long &_long) const;
-          bool operator<(ls::std::core::type::long_type _value) const;
-          bool operator<=(const ls::std::boxing::Long &_long) const;
-          bool operator<=(ls::std::core::type::long_type _value) const;
-
-          // logical operators
-
-          friend bool operator!(const ls::std::boxing::Long &_long)
-          {
-            return !_long.value;
-          }
-
-          bool operator&&(const ls::std::boxing::Long &_long) const;
-          bool operator&&(ls::std::core::type::long_type _value) const;
-          bool operator&&(bool _expression) const;
-          bool operator||(const ls::std::boxing::Long &_long) const;
-          bool operator||(ls::std::core::type::long_type _value) const;
-          bool operator||(bool _expression) const;
-
-          // increment / decrement operator
-
-          void operator++();
-          void operator--();
-
-          // implementation
-
-          void parse(::std::string _parseText) override;
-          ::std::string toString() override;
-
-          // additional functionality
-
-          ls::std::core::type::long_type getValue() const;
-
-        private:
-
-          ls::std::core::type::long_type value{};
-      };
-    }
-  }
+      ls::std::core::type::long_type value{};
+  };
 }
 
 #endif

include/ls_std/boxing/String.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2022-06-29
+ * Changed:         2022-07-02
  *
  * */
 
@@ -18,78 +18,72 @@
 #include <vector>
 #include <ls_std/os/dynamic_goal.hpp>
 
-namespace ls
+namespace ls::std::boxing
 {
-  namespace std
+  class DYNAMIC_GOAL String : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
   {
-    namespace boxing
-    {
-      class DYNAMIC_GOAL String : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
-      {
-        public:
+    public:
 
-          String();
-          explicit String(::std::string _value);
-          ~String() override = default;
+      String();
+      explicit String(::std::string _value);
+      ~String() override = default;
 
-          // conversion operator
+      // conversion operator
 
-          operator const char *() const; // do not make explicit!
-          operator ::std::string() const; // do not make explicit!
+      operator const char *() const; // do not make explicit!
+      operator ::std::string() const; // do not make explicit!
 
-          // assignment operators
+      // assignment operators
 
-          ls::std::boxing::String &operator=(::std::string _value);
+      ls::std::boxing::String &operator=(::std::string _value);
 
-          // arithmetic operators
+      // arithmetic operators
 
-          ::std::string operator+(ls::std::boxing::String _string) const;
-          ::std::string operator+(const ::std::string &_string) const;
-          ::std::string operator+(const char *_string) const;
-          ::std::string operator-(int _number);
+      ::std::string operator+(ls::std::boxing::String _string) const;
+      ::std::string operator+(const ::std::string &_string) const;
+      ::std::string operator+(const char *_string) const;
+      ::std::string operator-(int _number);
 
-          // compound operators
+      // compound operators
 
-          ls::std::boxing::String &operator+=(ls::std::boxing::String _string);
-          ls::std::boxing::String &operator+=(const ::std::string &_text);
+      ls::std::boxing::String &operator+=(ls::std::boxing::String _string);
+      ls::std::boxing::String &operator+=(const ::std::string &_text);
 
-          // comparison operators
+      // comparison operators
 
-          bool operator==(ls::std::boxing::String _string);
-          bool operator==(const ::std::string &_value);
-          bool operator==(const char *_value);
-          bool operator!=(ls::std::boxing::String _string);
-          bool operator!=(const ::std::string &_value);
-          bool operator!=(const char *_value);
+      bool operator==(ls::std::boxing::String _string);
+      bool operator==(const ::std::string &_value);
+      bool operator==(const char *_value);
+      bool operator!=(ls::std::boxing::String _string);
+      bool operator!=(const ::std::string &_value);
+      bool operator!=(const char *_value);
 
-          // implementation
+      // implementation
 
-          void parse(::std::string _parseText) override;
-          ::std::string toString() override;
+      void parse(::std::string _parseText) override;
+      ::std::string toString() override;
 
-          // additional functionality
+      // additional functionality
 
-          bool contains(const ::std::string &_text);
-          bool endsWith(const ::std::string &_text);
-          bool equalsIgnoreCase(ls::std::boxing::String _string);
-          bool equalsIgnoreCase(::std::string _text);
-          ::std::vector<ls::std::core::type::byte> getByteData();
-          ::std::string padLeft(size_t _width, char _fillCharacter);
-          ::std::string padRight(size_t _width, char _fillCharacter);
-          ::std::string reverse();
-          bool startsWith(const ::std::string &_text);
-          ::std::string toLowerCase();
-          ::std::string toUpperCase();
+      bool contains(const ::std::string &_text);
+      bool endsWith(const ::std::string &_text);
+      bool equalsIgnoreCase(ls::std::boxing::String _string);
+      bool equalsIgnoreCase(::std::string _text);
+      ::std::vector<ls::std::core::type::byte> getByteData();
+      ::std::string padLeft(size_t _width, char _fillCharacter);
+      ::std::string padRight(size_t _width, char _fillCharacter);
+      ::std::string reverse();
+      bool startsWith(const ::std::string &_text);
+      ::std::string toLowerCase();
+      ::std::string toUpperCase();
 
-        private:
+    private:
 
-          ::std::string value{};
+      ::std::string value{};
 
-          static ::std::string _buildCharacterChain(size_t _amount, char _fillCharacter);
-          static ::std::string _createFillContent(const ::std::string &_text, size_t _width, char _fillCharacter);
-      };
-    }
-  }
+      static ::std::string _buildCharacterChain(size_t _amount, char _fillCharacter);
+      static ::std::string _createFillContent(const ::std::string &_text, size_t _width, char _fillCharacter);
+  };
 }
 
 #endif