Change std namespace

.gitignore

@@ -1,3 +1,4 @@
 .idea
 cmake-build-*
 test/TestHelper.hpp
+ai-assistent.txt

README.md

@@ -35,6 +35,7 @@ A __Date__ class comes with this submodule, which you can use to represent a dat
 #### Features ####
 
 - GNU-like compilers are not supported anymore to focus more in depth on MSVC, Clang, Apple Clang - thus, still supporting the major platforms Linux, macOS and Windows
+- ls::std:: namespace was renamed to ls::standard to avoid clashes with C++-STL.
 
 #### Improvements ####
 

include/ls-std/boxing/Boolean.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2024-09-09
+ * Changed:         2026-06-23
  *
  * */
 
@@ -21,9 +22,9 @@
  * @doc: boxing.Boolean.description('This class represents the primitive datatype bool and provides functionalities for boolean expressions and string representation.')
  * */
 
-namespace ls::std::boxing
+namespace ls::standard::boxing
 {
-  class LS_STD_DYNAMIC_GOAL Boolean : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
+  class LS_STD_DYNAMIC_GOAL Boolean : public ls::standard::core::Class, public ls::standard::core::interface_type::IBoxing
   {
     public:
 
@@ -33,12 +34,12 @@ namespace ls::std::boxing
 
       // assignment operators
 
-      ls::std::boxing::Boolean &operator=(int _value);
-      ls::std::boxing::Boolean &operator=(bool _value);
+      ls::standard::boxing::Boolean &operator=(int _value);
+      ls::standard::boxing::Boolean &operator=(bool _value);
 
       // stream operators
 
-      friend ::std::ostream &operator<<(::std::ostream &_outputStream, const ls::std::boxing::Boolean &_boolean)
+      friend ::std::ostream &operator<<(::std::ostream &_outputStream, const ls::standard::boxing::Boolean &_boolean)
       {
         _outputStream << _boolean._toString();
         return _outputStream;
@@ -46,15 +47,15 @@ namespace ls::std::boxing
 
       // logical operators
 
-      friend bool operator!(const ls::std::boxing::Boolean &_boolean)
+      friend bool operator!(const ls::standard::boxing::Boolean &_boolean)
       {
         return !_boolean.value;
       }
 
-      bool operator&&(const ls::std::boxing::Boolean &_boolean) const;
+      bool operator&&(const ls::standard::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||(const ls::standard::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
@@ -67,9 +68,9 @@ namespace ls::std::boxing
       // additional functionality
 
       [[nodiscard]] bool getValue() const;
-      [[nodiscard]] static bool XOR(const ls::std::boxing::Boolean &_leftExpression, const ls::std::boxing::Boolean &_rightExpression);
-      [[nodiscard]] static bool XOR(const ls::std::boxing::Boolean &_leftExpression, bool _rightExpression);
-      [[nodiscard]] static bool XOR(bool _leftExpression, const ls::std::boxing::Boolean &_rightExpression);
+      [[nodiscard]] static bool XOR(const ls::standard::boxing::Boolean &_leftExpression, const ls::standard::boxing::Boolean &_rightExpression);
+      [[nodiscard]] static bool XOR(const ls::standard::boxing::Boolean &_leftExpression, bool _rightExpression);
+      [[nodiscard]] static bool XOR(bool _leftExpression, const ls::standard::boxing::Boolean &_rightExpression);
       [[nodiscard]] static bool XOR(bool _leftExpression, bool _rightExpression);
 
     private:

include/ls-std/boxing/Double.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2024-09-09
+ * Changed:         2026-06-23
  *
  * */
 
@@ -20,9 +21,9 @@
  * @doc: boxing.Double.description('This class represents the primitive datatype double and provides functionalities for arithmetic operations, accuracy and string representation.')
  * */
 
-namespace ls::std::boxing
+namespace ls::standard::boxing
 {
-  class LS_STD_DYNAMIC_GOAL Double : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
+  class LS_STD_DYNAMIC_GOAL Double : public ls::standard::core::Class, public ls::standard::core::interface_type::IBoxing
   {
     public:
 
@@ -32,44 +33,44 @@ namespace ls::std::boxing
 
       // assignment operators
 
-      ls::std::boxing::Double &operator=(double _value);
+      ls::standard::boxing::Double &operator=(double _value);
 
       // arithmetic operators
 
       double operator-() const;
-      double operator+(const ls::std::boxing::Double &_double) const;
+      double operator+(const ls::standard::boxing::Double &_double) const;
       double operator+(double _value) const;
-      double operator*(const ls::std::boxing::Double &_double) const;
+      double operator*(const ls::standard::boxing::Double &_double) const;
       double operator*(double _value) const;
-      double operator-(const ls::std::boxing::Double &_double) const;
+      double operator-(const ls::standard::boxing::Double &_double) const;
       double operator-(double _value) const;
-      double operator/(const ls::std::boxing::Double &_double) const;
+      double operator/(const ls::standard::boxing::Double &_double) const;
       double operator/(double _value) const;
 
       // 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::standard::boxing::Double &operator+=(const ls::standard::boxing::Double &_double);
+      ls::standard::boxing::Double &operator+=(double _value);
+      ls::standard::boxing::Double &operator-=(const ls::standard::boxing::Double &_double);
+      ls::standard::boxing::Double &operator-=(double _value);
+      ls::standard::boxing::Double &operator*=(const ls::standard::boxing::Double &_double);
+      ls::standard::boxing::Double &operator*=(double _value);
+      ls::standard::boxing::Double &operator/=(const ls::standard::boxing::Double &_double);
+      ls::standard::boxing::Double &operator/=(double _value);
 
       // comparison operators
 
-      bool operator==(const ls::std::boxing::Double &_double) const;
+      bool operator==(const ls::standard::boxing::Double &_double) const;
       bool operator==(double _value) const;
-      bool operator!=(const ls::std::boxing::Double &_double) const;
+      bool operator!=(const ls::standard::boxing::Double &_double) const;
       bool operator!=(double _value) const;
-      bool operator>(const ls::std::boxing::Double &_double) const;
+      bool operator>(const ls::standard::boxing::Double &_double) const;
       bool operator>(double _value) const;
-      bool operator>=(const ls::std::boxing::Double &_double) const;
+      bool operator>=(const ls::standard::boxing::Double &_double) const;
       bool operator>=(double _value) const;
-      bool operator<(const ls::std::boxing::Double &_double) const;
+      bool operator<(const ls::standard::boxing::Double &_double) const;
       bool operator<(double _value) const;
-      bool operator<=(const ls::std::boxing::Double &_double) const;
+      bool operator<=(const ls::standard::boxing::Double &_double) const;
       bool operator<=(double _value) const;
 
       // increment / decrement operator

include/ls-std/boxing/Float.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -21,9 +22,9 @@
  * @doc: boxing.Float.description('This class represents the primitive datatype float and provides functionalities for arithmetic operations, accuracy and string representation.')
  * */
 
-namespace ls::std::boxing
+namespace ls::standard::boxing
 {
-  class LS_STD_DYNAMIC_GOAL Float : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
+  class LS_STD_DYNAMIC_GOAL Float : public ls::standard::core::Class, public ls::standard::core::interface_type::IBoxing
   {
     public:
 
@@ -33,44 +34,44 @@ namespace ls::std::boxing
 
       // assignment operators
 
-      ls::std::boxing::Float &operator=(float _value);
+      ls::standard::boxing::Float &operator=(float _value);
 
       // arithmetic operators
 
       float operator-() const;
-      float operator+(const ls::std::boxing::Float &_float) const;
+      float operator+(const ls::standard::boxing::Float &_float) const;
       float operator+(float _value) const;
-      float operator*(const ls::std::boxing::Float &_float) const;
+      float operator*(const ls::standard::boxing::Float &_float) const;
       float operator*(float _value) const;
-      float operator-(const ls::std::boxing::Float &_float) const;
+      float operator-(const ls::standard::boxing::Float &_float) const;
       float operator-(float _value) const;
-      float operator/(const ls::std::boxing::Float &_float) const;
+      float operator/(const ls::standard::boxing::Float &_float) const;
       float operator/(float _value) const;
 
       // 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::standard::boxing::Float &operator+=(const ls::standard::boxing::Float &_float);
+      ls::standard::boxing::Float &operator+=(float _value);
+      ls::standard::boxing::Float &operator-=(const ls::standard::boxing::Float &_float);
+      ls::standard::boxing::Float &operator-=(float _value);
+      ls::standard::boxing::Float &operator*=(const ls::standard::boxing::Float &_float);
+      ls::standard::boxing::Float &operator*=(float _value);
+      ls::standard::boxing::Float &operator/=(const ls::standard::boxing::Float &_float);
+      ls::standard::boxing::Float &operator/=(float _value);
 
       // comparison operators
 
-      bool operator==(const ls::std::boxing::Float &_float) const;
+      bool operator==(const ls::standard::boxing::Float &_float) const;
       bool operator==(float _value) const;
-      bool operator!=(const ls::std::boxing::Float &_float) const;
+      bool operator!=(const ls::standard::boxing::Float &_float) const;
       bool operator!=(float _value) const;
-      bool operator>(const ls::std::boxing::Float &_float) const;
+      bool operator>(const ls::standard::boxing::Float &_float) const;
       bool operator>(float _value) const;
-      bool operator>=(const ls::std::boxing::Float &_float) const;
+      bool operator>=(const ls::standard::boxing::Float &_float) const;
       bool operator>=(float _value) const;
-      bool operator<(const ls::std::boxing::Float &_float) const;
+      bool operator<(const ls::standard::boxing::Float &_float) const;
       bool operator<(float _value) const;
-      bool operator<=(const ls::std::boxing::Float &_float) const;
+      bool operator<=(const ls::standard::boxing::Float &_float) const;
       bool operator<=(float _value) const;
 
       // increment / decrement operator

include/ls-std/boxing/Integer.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -20,9 +21,9 @@
  * @doc: boxing.Integer.description('This class represents the primitive datatype int and provides functionalities for arithmetic operations and string representation.')
  * */
 
-namespace ls::std::boxing
+namespace ls::standard::boxing
 {
-  class LS_STD_DYNAMIC_GOAL Integer : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
+  class LS_STD_DYNAMIC_GOAL Integer : public ls::standard::core::Class, public ls::standard::core::interface_type::IBoxing
   {
     public:
 
@@ -32,51 +33,51 @@ namespace ls::std::boxing
 
       // assignment operators
 
-      ls::std::boxing::Integer &operator=(int _value);
+      ls::standard::boxing::Integer &operator=(int _value);
 
       // arithmetic operators
 
       int operator-() const;
-      int operator+(const ls::std::boxing::Integer &_integer) const;
+      int operator+(const ls::standard::boxing::Integer &_integer) const;
       int operator+(int _value) const;
-      int operator*(const ls::std::boxing::Integer &_integer) const;
+      int operator*(const ls::standard::boxing::Integer &_integer) const;
       int operator*(int _value) const;
-      int operator-(const ls::std::boxing::Integer &_integer) const;
+      int operator-(const ls::standard::boxing::Integer &_integer) const;
       int operator-(int _value) const;
-      int operator/(const ls::std::boxing::Integer &_integer) const;
+      int operator/(const ls::standard::boxing::Integer &_integer) const;
       int operator/(int _value) const;
-      int operator%(const ls::std::boxing::Integer &_integer) const;
+      int operator%(const ls::standard::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);
+      ls::standard::boxing::Integer &operator+=(const ls::standard::boxing::Integer &_integer);
+      ls::standard::boxing::Integer &operator+=(int _value);
+      ls::standard::boxing::Integer &operator-=(const ls::standard::boxing::Integer &_integer);
+      ls::standard::boxing::Integer &operator-=(int _value);
+      ls::standard::boxing::Integer &operator*=(const ls::standard::boxing::Integer &_integer);
+      ls::standard::boxing::Integer &operator*=(int _value);
+      ls::standard::boxing::Integer &operator/=(const ls::standard::boxing::Integer &_integer);
+      ls::standard::boxing::Integer &operator/=(int _value);
 
       // comparison operators
 
-      bool operator==(const ls::std::boxing::Integer &_integer) const;
+      bool operator==(const ls::standard::boxing::Integer &_integer) const;
       bool operator==(int _value) const;
-      bool operator!=(const ls::std::boxing::Integer &_integer) const;
+      bool operator!=(const ls::standard::boxing::Integer &_integer) const;
       bool operator!=(int _value) const;
-      bool operator>(const ls::std::boxing::Integer &_integer) const;
+      bool operator>(const ls::standard::boxing::Integer &_integer) const;
       bool operator>(int _value) const;
-      bool operator>=(const ls::std::boxing::Integer &_integer) const;
+      bool operator>=(const ls::standard::boxing::Integer &_integer) const;
       bool operator>=(int _value) const;
-      bool operator<(const ls::std::boxing::Integer &_integer) const;
+      bool operator<(const ls::standard::boxing::Integer &_integer) const;
       bool operator<(int _value) const;
-      bool operator<=(const ls::std::boxing::Integer &_integer) const;
+      bool operator<=(const ls::standard::boxing::Integer &_integer) const;
       bool operator<=(int _value) const;
 
       // logical operators
 
-      friend bool operator!(const ls::std::boxing::Integer &_integer)
+      friend bool operator!(const ls::standard::boxing::Integer &_integer)
       {
         return !_integer.value;
       }

include/ls-std/boxing/Long.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -21,63 +22,63 @@
  * @doc: boxing.Long.description('This class represents the primitive datatype long and provides functionalities for arithmetic operations and string representation.')
  * */
 
-namespace ls::std::boxing
+namespace ls::standard::boxing
 {
-  class LS_STD_DYNAMIC_GOAL Long : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
+  class LS_STD_DYNAMIC_GOAL Long : public ls::standard::core::Class, public ls::standard::core::interface_type::IBoxing
   {
     public:
 
-      explicit Long(ls::std::core::type::long_type _value);
+      explicit Long(ls::standard::core::type::long_type _value);
       Long();
       ~Long() noexcept override;
 
       // assignment operators
 
-      ls::std::boxing::Long &operator=(ls::std::core::type::long_type _value);
+      ls::standard::boxing::Long &operator=(ls::standard::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;
+      ls::standard::core::type::long_type operator-() const;
+      ls::standard::core::type::long_type operator+(const ls::standard::boxing::Long &_long) const;
+      ls::standard::core::type::long_type operator+(ls::standard::core::type::long_type _value) const;
+      ls::standard::core::type::long_type operator*(const ls::standard::boxing::Long &_long) const;
+      ls::standard::core::type::long_type operator*(ls::standard::core::type::long_type _value) const;
+      ls::standard::core::type::long_type operator-(const ls::standard::boxing::Long &_long) const;
+      ls::standard::core::type::long_type operator-(ls::standard::core::type::long_type _value) const;
+      ls::standard::core::type::long_type operator/(const ls::standard::boxing::Long &_long) const;
+      ls::standard::core::type::long_type operator/(ls::standard::core::type::long_type _value) const;
+      ls::standard::core::type::long_type operator%(const ls::standard::boxing::Long &_long) const;
+      ls::standard::core::type::long_type operator%(ls::standard::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);
+      ls::standard::boxing::Long &operator+=(const ls::standard::boxing::Long &_long);
+      ls::standard::boxing::Long &operator+=(ls::standard::core::type::long_type _value);
+      ls::standard::boxing::Long &operator-=(const ls::standard::boxing::Long &_long);
+      ls::standard::boxing::Long &operator-=(ls::standard::core::type::long_type _value);
+      ls::standard::boxing::Long &operator*=(const ls::standard::boxing::Long &_long);
+      ls::standard::boxing::Long &operator*=(ls::standard::core::type::long_type _value);
+      ls::standard::boxing::Long &operator/=(const ls::standard::boxing::Long &_long);
+      ls::standard::boxing::Long &operator/=(ls::standard::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;
+      bool operator==(const ls::standard::boxing::Long &_long) const;
+      bool operator==(ls::standard::core::type::long_type _value) const;
+      bool operator!=(const ls::standard::boxing::Long &_long) const;
+      bool operator!=(ls::standard::core::type::long_type _value) const;
+      bool operator>(const ls::standard::boxing::Long &_long) const;
+      bool operator>(ls::standard::core::type::long_type _value) const;
+      bool operator>=(const ls::standard::boxing::Long &_long) const;
+      bool operator>=(ls::standard::core::type::long_type _value) const;
+      bool operator<(const ls::standard::boxing::Long &_long) const;
+      bool operator<(ls::standard::core::type::long_type _value) const;
+      bool operator<=(const ls::standard::boxing::Long &_long) const;
+      bool operator<=(ls::standard::core::type::long_type _value) const;
 
       // logical operators
 
-      friend bool operator!(const ls::std::boxing::Long &_long)
+      friend bool operator!(const ls::standard::boxing::Long &_long)
       {
         return !_long.value;
       }
@@ -94,11 +95,11 @@ namespace ls::std::boxing
 
       // additional functionality
 
-      [[nodiscard]] ls::std::core::type::long_type getValue() const;
+      [[nodiscard]] ls::standard::core::type::long_type getValue() const;
 
     private:
 
-      ls::std::core::type::long_type value{};
+      ls::standard::core::type::long_type value{};
 
       [[nodiscard]] static ::std::string _fetchClassName();
   };

include/ls-std/boxing/String.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2025-12-21
+ * Changed:         2026-06-23
  *
  * */
 
@@ -24,9 +25,9 @@
  * @doc: boxing.String.description('This class represents a string and provides operations, like filling and searching.')
  * */
 
-namespace ls::std::boxing
+namespace ls::standard::boxing
 {
-  class LS_STD_DYNAMIC_GOAL String : public ls::std::core::Class, public ls::std::core::interface_type::IBoxing
+  class LS_STD_DYNAMIC_GOAL String : public ls::standard::core::Class, public ls::standard::core::interface_type::IBoxing
   {
     public:
 
@@ -36,26 +37,26 @@ namespace ls::std::boxing
 
       // assignment operators
 
-      ls::std::boxing::String &operator=(::std::string _value);
+      ls::standard::boxing::String &operator=(::std::string _value);
 
       // arithmetic operators
 
-      ::std::string operator+(ls::std::boxing::String _string) const;
+      ::std::string operator+(ls::standard::boxing::String _string) const;
       ::std::string operator+(const ::std::string &_string) const;
       ::std::string operator+(const char *_string) const;
       ::std::string operator-(::std::string::size_type _number) const;
 
       // compound operators
 
-      ls::std::boxing::String &operator+=(ls::std::boxing::String _string);
-      ls::std::boxing::String &operator+=(const ::std::string &_text);
+      ls::standard::boxing::String &operator+=(ls::standard::boxing::String _string);
+      ls::standard::boxing::String &operator+=(const ::std::string &_text);
 
       // comparison operators
 
-      bool operator==(ls::std::boxing::String _string) const;
+      bool operator==(ls::standard::boxing::String _string) const;
       bool operator==(::std::string_view _value) const;
       bool operator==(const char *_value) const;
-      bool operator!=(ls::std::boxing::String _string) const;
+      bool operator!=(ls::standard::boxing::String _string) const;
       bool operator!=(::std::string_view _value) const;
       bool operator!=(const char *_value) const;
 
@@ -68,9 +69,9 @@ namespace ls::std::boxing
 
       [[nodiscard]] bool contains(::std::string_view _text) const;
       [[nodiscard]] bool endsWith(::std::string_view _text) const;
-      [[nodiscard]] bool equalsIgnoreCase(const ls::std::boxing::String &_string) const;
+      [[nodiscard]] bool equalsIgnoreCase(const ls::standard::boxing::String &_string) const;
       [[nodiscard]] bool equalsIgnoreCase(::std::string _text) const;
-      [[nodiscard]] ::std::vector<ls::std::core::type::byte_type> getByteData();
+      [[nodiscard]] ::std::vector<ls::standard::core::type::byte_type> getByteData();
       [[nodiscard]] ::std::string padLeft(size_t _width, char _fillCharacter) const;
       [[nodiscard]] ::std::string padRight(size_t _width, char _fillCharacter) const;
       [[nodiscard]] ::std::string reverse() const;

include/ls-std/core/Class.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -18,7 +19,7 @@
  * @doc: core.Class.description('This class represents a base class offering minimal reflection on the class name.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
   class LS_STD_DYNAMIC_GOAL Class
   {

include/ls-std/core/ConditionalFunctionExecutor.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-13
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -18,7 +19,7 @@
  * @doc: core.ConditionalFunctionExecutor.description('This class can execute any method matching a specific signature based on a specific condition.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
   class LS_STD_DYNAMIC_GOAL ConditionalFunctionExecutor
   {

include/ls-std/core/LibraryVersion.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-02
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -18,7 +19,7 @@
  * @doc: core.LibraryVersion.description('This class provides the version information of this library.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
   class LS_STD_DYNAMIC_GOAL LibraryVersion
   {

include/ls-std/core/Version.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -21,35 +22,35 @@
  * @doc: core.Version.description('This class represents a semantic versioning scheme.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL Version : public ls::std::core::interface_type::ISerializable
+  class LS_STD_DYNAMIC_GOAL Version : public ls::standard::core::interface_type::ISerializable
   {
     public:
 
-      explicit Version(ls::std::core::type::version_type _majorVersion, ls::std::core::type::version_type _minorVersion, ls::std::core::type::version_type _patchVersion);
+      explicit Version(ls::standard::core::type::version_type _majorVersion, ls::standard::core::type::version_type _minorVersion, ls::standard::core::type::version_type _patchVersion);
       ~Version() noexcept override;
 
       // implementation
 
-      [[nodiscard]] ls::std::core::type::byte_field marshal() override;
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      [[nodiscard]] ls::standard::core::type::byte_field marshal() override;
+      void unmarshal(const ls::standard::core::type::byte_field &_data) override;
 
       // other functionality
 
-      [[nodiscard]] ls::std::core::type::version_type getMajorVersion() const;
-      [[nodiscard]] ls::std::core::type::version_type getMinorVersion() const;
-      [[nodiscard]] ls::std::core::type::version_type getPatchVersion() const;
+      [[nodiscard]] ls::standard::core::type::version_type getMajorVersion() const;
+      [[nodiscard]] ls::standard::core::type::version_type getMinorVersion() const;
+      [[nodiscard]] ls::standard::core::type::version_type getPatchVersion() const;
       [[nodiscard]] static bool isValid(const ::std::string &_versionString);
-      void setMajorVersion(ls::std::core::type::version_type _major);
-      void setMinorVersion(ls::std::core::type::version_type _minor);
-      void setPatchVersion(ls::std::core::type::version_type _patch);
+      void setMajorVersion(ls::standard::core::type::version_type _major);
+      void setMinorVersion(ls::standard::core::type::version_type _minor);
+      void setPatchVersion(ls::standard::core::type::version_type _patch);
 
     private:
 
-      ls::std::core::type::version_type majorVersion{};
-      ls::std::core::type::version_type minorVersion{};
-      ls::std::core::type::version_type patchVersion{};
+      ls::standard::core::type::version_type majorVersion{};
+      ls::standard::core::type::version_type minorVersion{};
+      ls::standard::core::type::version_type patchVersion{};
 
       [[nodiscard]] static bool _isValid(::std::string_view _versionString);
   };

include/ls-std/core/evaluator/EmptyStringArgumentEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -19,9 +20,9 @@
  * @doc: core.EmptyStringArgumentEvaluator.description('This class evaluates whether a passed string is empty.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL EmptyStringArgumentEvaluator : public ls::std::core::interface_type::IEvaluator
+  class LS_STD_DYNAMIC_GOAL EmptyStringArgumentEvaluator : public ls::standard::core::interface_type::IEvaluator
   {
     public:
 

include/ls-std/core/evaluator/IndexOutOfBoundsEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -19,9 +20,9 @@
  * @doc: core.IndexOutOfBoundsEvaluator.description('This class evaluates whether a passed index is out of bounds.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL IndexOutOfBoundsEvaluator : public ls::std::core::interface_type::IEvaluator
+  class LS_STD_DYNAMIC_GOAL IndexOutOfBoundsEvaluator : public ls::standard::core::interface_type::IEvaluator
   {
     public:
 

include/ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -21,9 +22,9 @@
  * @doc: core.NullPointerArgumentEvaluator.description('This class evaluates whether a passed shared pointer argument is null.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL NullPointerArgumentEvaluator : public ls::std::core::interface_type::IEvaluator
+  class LS_STD_DYNAMIC_GOAL NullPointerArgumentEvaluator : public ls::standard::core::interface_type::IEvaluator
   {
     public:
 

include/ls-std/core/evaluator/NullPointerEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,9 +21,9 @@
  * @doc: core.NullPointerEvaluator.description('This class evaluates whether a passed shared pointer reference is null.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL NullPointerEvaluator : public ls::std::core::interface_type::IEvaluator
+  class LS_STD_DYNAMIC_GOAL NullPointerEvaluator : public ls::standard::core::interface_type::IEvaluator
   {
     public:
 

include/ls-std/core/evaluator/RawNullPointerArgumentEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-05-23
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,16 +21,16 @@
  * @doc: core.RawNullPointerArgumentEvaluator.description('This class evaluates whether a passed raw pointer argument is null.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
   template<typename T>
-  class RawNullPointerArgumentEvaluator : public ls::std::core::interface_type::IEvaluator
+  class RawNullPointerArgumentEvaluator : public ls::standard::core::interface_type::IEvaluator
   {
     public:
 
-      explicit RawNullPointerArgumentEvaluator(const ls::std::core::type::RawPointer<T> &_argument) : argument(_argument)
+      explicit RawNullPointerArgumentEvaluator(const ls::standard::core::type::RawPointer<T> &_argument) : argument(_argument)
       {}
-      explicit RawNullPointerArgumentEvaluator(const ls::std::core::type::RawPointer<T> &_argument, const ::std::string &_message) : argument(_argument), message(_message)
+      explicit RawNullPointerArgumentEvaluator(const ls::standard::core::type::RawPointer<T> &_argument, const ::std::string &_message) : argument(_argument), message(_message)
       {}
       ~RawNullPointerArgumentEvaluator() noexcept override = default;
 
@@ -39,18 +40,18 @@ namespace ls::std::core
         {
           if (this->message.empty())
           {
-            throw ls::std::core::IllegalArgumentException{"passed argument is null!"};
+            throw ls::standard::core::IllegalArgumentException{"passed argument is null!"};
           }
           else
           {
-            throw ls::std::core::IllegalArgumentException{this->message};
+            throw ls::standard::core::IllegalArgumentException{this->message};
           }
         }
       }
 
     private:
 
-      ls::std::core::type::RawPointer<T> argument{};
+      ls::standard::core::type::RawPointer<T> argument{};
       ::std::string message{};
   };
 }

include/ls-std/core/evaluator/RawNullPointerEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-05-24
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,16 +21,16 @@
  * @doc: core.RawNullPointerEvaluator.description('This class evaluates whether a passed raw pointer reference is null.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
   template<typename T>
-  class RawNullPointerEvaluator : public ls::std::core::interface_type::IEvaluator
+  class RawNullPointerEvaluator : public ls::standard::core::interface_type::IEvaluator
   {
     public:
 
-      explicit RawNullPointerEvaluator(const ls::std::core::type::RawPointer<T> &_argument) : argument(_argument)
+      explicit RawNullPointerEvaluator(const ls::standard::core::type::RawPointer<T> &_argument) : argument(_argument)
       {}
-      RawNullPointerEvaluator(const ls::std::core::type::RawPointer<T> &_argument, const ::std::string &_message) : argument(_argument), message(_message)
+      RawNullPointerEvaluator(const ls::standard::core::type::RawPointer<T> &_argument, const ::std::string &_message) : argument(_argument), message(_message)
       {}
       ~RawNullPointerEvaluator() noexcept override = default;
 
@@ -39,18 +40,18 @@ namespace ls::std::core
         {
           if (this->message.empty())
           {
-            throw ls::std::core::NullPointerException{"reference in use is null!"};
+            throw ls::standard::core::NullPointerException{"reference in use is null!"};
           }
           else
           {
-            throw ls::std::core::NullPointerException{this->message};
+            throw ls::standard::core::NullPointerException{this->message};
           }
         }
       }
 
     private:
 
-      ls::std::core::type::RawPointer<T> argument{};
+      ls::standard::core::type::RawPointer<T> argument{};
       ::std::string message{};
   };
 }

include/ls-std/core/exception/EventNotHandledException.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-27
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -19,9 +20,9 @@
  * @doc: core.EventNotHandledException.description('This exception can be thrown in case an event is not handled.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL EventNotHandledException : public ls::std::core::Exception
+  class LS_STD_DYNAMIC_GOAL EventNotHandledException : public ls::standard::core::Exception
   {
     public:
 

include/ls-std/core/exception/Exception.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-22
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,7 +21,7 @@
  * @doc: core.Exception.description('This a base exception that can be thrown in any scenario.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
   class LS_STD_DYNAMIC_GOAL Exception : public ::std::exception
   {

include/ls-std/core/exception/ExceptionMessage.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-07
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -18,7 +19,7 @@
  * @doc: core.ExceptionMessage.description('This is the message container being used by these libraries provided exceptions.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
   class LS_STD_DYNAMIC_GOAL ExceptionMessage
   {

include/ls-std/core/exception/FileNotFoundException.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -19,9 +20,9 @@
  * @doc: core.FileNotFoundException.description('This exception can be thrown in case a file could not be found.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL FileNotFoundException : public ls::std::core::Exception
+  class LS_STD_DYNAMIC_GOAL FileNotFoundException : public ls::standard::core::Exception
   {
     public:
 

include/ls-std/core/exception/FileOperationException.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -19,9 +20,9 @@
  * @doc: core.FileOperationException.description('This exception can be thrown in case a file could not be processed, like opened or being read.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL FileOperationException : public ls::std::core::Exception
+  class LS_STD_DYNAMIC_GOAL FileOperationException : public ls::standard::core::Exception
   {
     public:
 

include/ls-std/core/exception/IllegalArgumentException.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -19,9 +20,9 @@
  * @doc: core.IllegalArgumentException.description('This exception can be thrown in case a passed argument is illegal, which can be individually interpreted.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL IllegalArgumentException : public ls::std::core::Exception
+  class LS_STD_DYNAMIC_GOAL IllegalArgumentException : public ls::standard::core::Exception
   {
     public:
 

include/ls-std/core/exception/IllegalArithmeticOperationException.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -19,9 +20,9 @@
  * @doc: core.IllegalArithmeticOperationException.description('This exception can be thrown in case an arithmetic operation is illegal. One example would be the division by zero.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL IllegalArithmeticOperationException : public ls::std::core::Exception
+  class LS_STD_DYNAMIC_GOAL IllegalArithmeticOperationException : public ls::standard::core::Exception
   {
     public:
 

include/ls-std/core/exception/IncompleteJsonException.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-30
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -19,9 +20,9 @@
  * @doc: core.IncompleteJsonException.description('This exception can be thrown when a passed JSON is incomplete - e.g. if a key is missing.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL IncompleteJsonException : public ls::std::core::Exception
+  class LS_STD_DYNAMIC_GOAL IncompleteJsonException : public ls::standard::core::Exception
   {
     public:
 

include/ls-std/core/exception/IndexOutOfBoundsException.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -19,9 +20,9 @@
  * @doc: core.IndexOutOfBoundsException.description('This exception can be thrown in case an index of an array like structure is out of bounds.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL IndexOutOfBoundsException : public ls::std::core::Exception
+  class LS_STD_DYNAMIC_GOAL IndexOutOfBoundsException : public ls::standard::core::Exception
   {
     public:
 

include/ls-std/core/exception/NotImplementedException.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-03-27
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -19,9 +20,9 @@
  * @doc: core.NotImplementedException.description('This exception can be thrown in case a called method is not implemented.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL NotImplementedException : public ls::std::core::Exception
+  class LS_STD_DYNAMIC_GOAL NotImplementedException : public ls::standard::core::Exception
   {
     public:
 

include/ls-std/core/exception/NullPointerException.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-06
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -19,9 +20,9 @@
  * @doc: core.NullPointerException.description('This exception can be thrown in case a called reference is null.')
  * */
 
-namespace ls::std::core
+namespace ls::standard::core
 {
-  class LS_STD_DYNAMIC_GOAL NullPointerException : public ls::std::core::Exception
+  class LS_STD_DYNAMIC_GOAL NullPointerException : public ls::standard::core::Exception
   {
     public:
 

include/ls-std/core/interface/IBoxing.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2023-05-17
+ * Changed:         2026-06-23
  *
  * */
 
@@ -13,7 +14,7 @@
 #include <ls-std/os/dynamic-goal.hpp>
 #include <string>
 
-namespace ls::std::core::interface_type
+namespace ls::standard::core::interface_type
 {
   class LS_STD_DYNAMIC_GOAL IBoxing
   {

include/ls-std/core/interface/IEncoding.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-01-03
- * Changed:         2023-02-05
+ * Changed:         2026-06-23
  *
  * */
 
@@ -13,7 +14,7 @@
 #include <ls-std/os/dynamic-goal.hpp>
 #include <string>
 
-namespace ls::std::core::interface_type
+namespace ls::standard::core::interface_type
 {
   class LS_STD_DYNAMIC_GOAL IEncoding
   {

include/ls-std/core/interface/IEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-02-08
+* Changed:         2026-06-23
 *
 * */
 
@@ -12,7 +13,7 @@
 
 #include <ls-std/os/dynamic-goal.hpp>
 
-namespace ls::std::core::interface_type
+namespace ls::standard::core::interface_type
 {
   class LS_STD_DYNAMIC_GOAL IEvaluator
   {

include/ls-std/core/interface/IJniApi.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-04-07
-* Changed:         2023-04-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -14,7 +15,7 @@
 #include <ls-std/os/dynamic-goal.hpp>
 #include <string>
 
-namespace ls::std::core::experimental::interface_type
+namespace ls::standard::core::experimental::interface_type
 {
   class LS_STD_DYNAMIC_GOAL IJniApi
   {

include/ls-std/core/interface/IListener.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2023-02-05
+ * Changed:         2026-06-23
  *
  * */
 
@@ -13,7 +14,7 @@
 #include <ls-std/core/Class.hpp>
 #include <ls-std/os/dynamic-goal.hpp>
 
-namespace ls::std::core::interface_type
+namespace ls::standard::core::interface_type
 {
   class LS_STD_DYNAMIC_GOAL IListener
   {
@@ -22,7 +23,7 @@ namespace ls::std::core::interface_type
       IListener();
       virtual ~IListener();
 
-      virtual void listen(const ls::std::core::Class &_info) = 0;
+      virtual void listen(const ls::standard::core::Class &_info) = 0;
   };
 }
 

include/ls-std/core/interface/IReader.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2023-02-08
+ * Changed:         2026-06-23
  *
  * */
 
@@ -13,7 +14,7 @@
 #include <ls-std/core/type/Types.hpp>
 #include <ls-std/os/dynamic-goal.hpp>
 
-namespace ls::std::core::interface_type
+namespace ls::standard::core::interface_type
 {
   class LS_STD_DYNAMIC_GOAL IReader
   {
@@ -22,7 +23,7 @@ namespace ls::std::core::interface_type
       IReader();
       virtual ~IReader();
 
-      virtual ls::std::core::type::byte_field read() = 0;
+      virtual ls::standard::core::type::byte_field read() = 0;
   };
 }
 

include/ls-std/core/interface/ISerializable.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-21
- * Changed:         2023-02-08
+ * Changed:         2026-06-23
  *
  * */
 
@@ -13,7 +14,7 @@
 #include <ls-std/core/type/Types.hpp>
 #include <ls-std/os/dynamic-goal.hpp>
 
-namespace ls::std::core::interface_type
+namespace ls::standard::core::interface_type
 {
   class LS_STD_DYNAMIC_GOAL ISerializable
   {
@@ -22,8 +23,8 @@ namespace ls::std::core::interface_type
       ISerializable();
       virtual ~ISerializable();
 
-      virtual ls::std::core::type::byte_field marshal() = 0;
-      virtual void unmarshal(const ls::std::core::type::byte_field &_data) = 0;
+      virtual ls::standard::core::type::byte_field marshal() = 0;
+      virtual void unmarshal(const ls::standard::core::type::byte_field &_data) = 0;
   };
 }
 

include/ls-std/core/interface/IStorable.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2023-02-08
+ * Changed:         2026-06-23
  *
  * */
 
@@ -13,7 +14,7 @@
 #include <ls-std/core/type/Types.hpp>
 #include <ls-std/os/dynamic-goal.hpp>
 
-namespace ls::std::core::interface_type
+namespace ls::standard::core::interface_type
 {
   class LS_STD_DYNAMIC_GOAL IStorable
   {
@@ -22,8 +23,8 @@ namespace ls::std::core::interface_type
       IStorable();
       virtual ~IStorable();
 
-      virtual ls::std::core::type::byte_field load() = 0;
-      virtual void save(const ls::std::core::type::byte_field &_data) = 0;
+      virtual ls::standard::core::type::byte_field load() = 0;
+      virtual void save(const ls::standard::core::type::byte_field &_data) = 0;
   };
 }
 

include/ls-std/core/interface/IValidator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-02-08
+* Changed:         2026-06-23
 *
 * */
 
@@ -12,7 +13,7 @@
 
 #include <ls-std/os/dynamic-goal.hpp>
 
-namespace ls::std::core::interface_type
+namespace ls::standard::core::interface_type
 {
   class LS_STD_DYNAMIC_GOAL IValidator
   {

include/ls-std/core/interface/IWriter.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2023-02-08
+ * Changed:         2026-06-23
  *
  * */
 
@@ -14,7 +15,7 @@
 #include <ls-std/os/dynamic-goal.hpp>
 #include <vector>
 
-namespace ls::std::core::interface_type
+namespace ls::standard::core::interface_type
 {
   class LS_STD_DYNAMIC_GOAL IWriter
   {
@@ -23,7 +24,7 @@ namespace ls::std::core::interface_type
       IWriter();
       virtual ~IWriter();
 
-      virtual bool write(const ls::std::core::type::byte_field &_data) = 0;
+      virtual bool write(const ls::standard::core::type::byte_field &_data) = 0;
   };
 }
 

include/ls-std/core/jni/JniApi.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-04-07
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -18,9 +19,9 @@
  * @doc: core.JniApi.description('This class represents an API for the Java Native Interface (JNI) wrapping basic JNI end points.')
  * */
 
-namespace ls::std::core::experimental
+namespace ls::standard::core::experimental
 {
-  class LS_STD_DYNAMIC_GOAL JniApi : public ls::std::core::experimental::interface_type::IJniApi
+  class LS_STD_DYNAMIC_GOAL JniApi : public ls::standard::core::experimental::interface_type::IJniApi
   {
     public:
 

include/ls-std/core/jni/JniClass.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-04-07
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -25,16 +26,16 @@
  * @doc: core.JniClass.description('This class represents a Java class within the Java Native Interface (JNI).')
  * */
 
-namespace ls::std::core::experimental
+namespace ls::standard::core::experimental
 {
   class LS_STD_DYNAMIC_GOAL JniClass
   {
     public:
 
-      explicit JniClass(const ::std::shared_ptr<ls::std::core::experimental::JniClassParameter> &_parameter, const ::std::string &_path);
+      explicit JniClass(const ::std::shared_ptr<ls::standard::core::experimental::JniClassParameter> &_parameter, const ::std::string &_path);
       virtual ~JniClass();
 
-      [[nodiscard]] ls::std::core::experimental::JniReturnValue callMethod(const ::std::string &_methodIdentifier);
+      [[nodiscard]] ls::standard::core::experimental::JniReturnValue callMethod(const ::std::string &_methodIdentifier);
       [[nodiscard]] bool hasMethod(const ::std::string &_methodIdentifier);
       bool load();                                                                                    // nodiscard is optional here
       bool loadMethod(const ::std::string &_methodIdentifier, const ::std::string &_methodSignature); // nodiscard is optional here
@@ -42,18 +43,18 @@ namespace ls::std::core::experimental
     private:
 
       jclass javaClass{};
-      ::std::unordered_map<::std::string, ls::std::core::experimental::JniMethod> methods{};
-      ::std::shared_ptr<ls::std::core::experimental::JniClassParameter> parameter{};
+      ::std::unordered_map<::std::string, ls::standard::core::experimental::JniMethod> methods{};
+      ::std::shared_ptr<ls::standard::core::experimental::JniClassParameter> parameter{};
       ::std::string path{};
 
-      void _callBooleanMethod(const ::std::string &_methodIdentifier, ls::std::core::experimental::JniReturnValue &_returnValue);
-      void _callByteMethod(const ::std::string &_methodIdentifier, ls::std::core::experimental::JniReturnValue &_returnValue);
-      void _callCharMethod(const ::std::string &_methodIdentifier, ls::std::core::experimental::JniReturnValue &_returnValue);
-      void _callDoubleMethod(const ::std::string &_methodIdentifier, ls::std::core::experimental::JniReturnValue &_returnValue);
-      void _callFloatMethod(const ::std::string &_methodIdentifier, ls::std::core::experimental::JniReturnValue &_returnValue);
-      void _callIntMethod(const ::std::string &_methodIdentifier, ls::std::core::experimental::JniReturnValue &_returnValue);
-      void _callLongMethod(const ::std::string &_methodIdentifier, ls::std::core::experimental::JniReturnValue &_returnValue);
-      void _callShortMethod(const ::std::string &_methodIdentifier, ls::std::core::experimental::JniReturnValue &_returnValue);
+      void _callBooleanMethod(const ::std::string &_methodIdentifier, ls::standard::core::experimental::JniReturnValue &_returnValue);
+      void _callByteMethod(const ::std::string &_methodIdentifier, ls::standard::core::experimental::JniReturnValue &_returnValue);
+      void _callCharMethod(const ::std::string &_methodIdentifier, ls::standard::core::experimental::JniReturnValue &_returnValue);
+      void _callDoubleMethod(const ::std::string &_methodIdentifier, ls::standard::core::experimental::JniReturnValue &_returnValue);
+      void _callFloatMethod(const ::std::string &_methodIdentifier, ls::standard::core::experimental::JniReturnValue &_returnValue);
+      void _callIntMethod(const ::std::string &_methodIdentifier, ls::standard::core::experimental::JniReturnValue &_returnValue);
+      void _callLongMethod(const ::std::string &_methodIdentifier, ls::standard::core::experimental::JniReturnValue &_returnValue);
+      void _callShortMethod(const ::std::string &_methodIdentifier, ls::standard::core::experimental::JniReturnValue &_returnValue);
       void _createJniApi() const;
       [[nodiscard]] bool _hasMethod(const ::std::string &_methodIdentifier);
   };

include/ls-std/core/jni/JniClassParameter.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-04-07
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -21,7 +22,7 @@
  * @doc: core.JniClassParameter.description('This class holds important information for the usage of the Java Native Interface (JNI), like Java environment or a specific Java object.')
  * */
 
-namespace ls::std::core::experimental
+namespace ls::standard::core::experimental
 {
   class LS_STD_DYNAMIC_GOAL JniClassParameter
   {
@@ -32,16 +33,16 @@ namespace ls::std::core::experimental
 
       [[nodiscard]] JNIEnv *getJavaEnvironment();
       [[nodiscard]] jobject getJavaObject();
-      [[nodiscard]] ::std::shared_ptr<ls::std::core::experimental::interface_type::IJniApi> getJniApi() const;
+      [[nodiscard]] ::std::shared_ptr<ls::standard::core::experimental::interface_type::IJniApi> getJniApi() const;
       void setJavaEnvironment(JNIEnv *_environment);
       void setJavaObject(jobject _javaObject);
-      void setJniApi(const ::std::shared_ptr<ls::std::core::experimental::interface_type::IJniApi> &_jniApi);
+      void setJniApi(const ::std::shared_ptr<ls::standard::core::experimental::interface_type::IJniApi> &_jniApi);
 
     private:
 
       JNIEnv *environment{};
       jobject javaObject{};
-      ::std::shared_ptr<ls::std::core::experimental::interface_type::IJniApi> jniApi{};
+      ::std::shared_ptr<ls::standard::core::experimental::interface_type::IJniApi> jniApi{};
   };
 }
 

include/ls-std/core/jni/JniMethod.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-04-08
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,7 +21,7 @@
  * @doc: core.JniMethod.description('This class represents a class method within Java Native Interface (JNI) context.')
  * */
 
-namespace ls::std::core::experimental
+namespace ls::standard::core::experimental
 {
   class LS_STD_DYNAMIC_GOAL JniMethod
   {

include/ls-std/core/jni/JniReturnValue.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-04-08
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -18,7 +19,7 @@
  * @doc: core.JniReturnValue.description('This class represents a method return value of a Java class within Java Native Interface (JNI) context.')
  * */
 
-namespace ls::std::core::experimental
+namespace ls::standard::core::experimental
 {
   class LS_STD_DYNAMIC_GOAL JniReturnValue
   {

include/ls-std/core/type/RawPointer.hpp

@@ -1,16 +1,17 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-05-23
-* Changed:         2023-05-23
+* Changed:         2026-06-23
 *
 * */
 
 #ifndef LS_STD_RAW_POINTER_HPP
 #define LS_STD_RAW_POINTER_HPP
 
-namespace ls::std::core::type
+namespace ls::standard::core::type
 {
   template<typename T>
   class RawPointer

include/ls-std/core/type/Types.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2023-05-16
+ * Changed:         2026-06-23
  *
  * */
 
@@ -13,7 +14,7 @@
 #include <ls-std/lib/nlohmann_json/include/nlohmann/json.hpp>
 #include <string>
 
-namespace ls::std::core::type
+namespace ls::standard::core::type
 {
   using byte_type = char;
   using byte_field = ::std::string;

include/ls-std/encoding/Base64.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-01-03
- * Changed:         2024-09-11
+ * Changed:         2026-06-23
  *
  * */
 
@@ -23,9 +24,9 @@
  * @doc: encoding.Base64.description('This class can encode and decode the Base64 format.')
  * */
 
-namespace ls::std::encoding
+namespace ls::standard::encoding
 {
-  class LS_STD_DYNAMIC_GOAL Base64 : public ls::std::core::interface_type::IEncoding
+  class LS_STD_DYNAMIC_GOAL Base64 : public ls::standard::core::interface_type::IEncoding
   {
     public:
 

include/ls-std/event/Event.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2024-05-16
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,22 +21,22 @@
  * @doc: event.Event.description('This class represents an event that can be invoked.')
  * */
 
-namespace ls::std::event
+namespace ls::standard::event
 {
-  class LS_STD_DYNAMIC_GOAL Event : public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL Event : public ls::standard::core::Class
   {
     public:
 
       explicit Event(const ::std::string &_name);
       ~Event() noexcept override;
 
-      [[nodiscard]] ::std::shared_ptr<ls::std::core::Class> getManager() const;
-      void setManager(const ::std::shared_ptr<ls::std::core::Class> &_manager);
-      [[nodiscard]] ls::std::event::Event supervisedBy(const ::std::shared_ptr<ls::std::core::Class> &_manager) const;
+      [[nodiscard]] ::std::shared_ptr<ls::standard::core::Class> getManager() const;
+      void setManager(const ::std::shared_ptr<ls::standard::core::Class> &_manager);
+      [[nodiscard]] ls::standard::event::Event supervisedBy(const ::std::shared_ptr<ls::standard::core::Class> &_manager) const;
 
     private:
 
-      ::std::shared_ptr<ls::std::core::Class> manager{};
+      ::std::shared_ptr<ls::standard::core::Class> manager{};
   };
 }
 

include/ls-std/event/EventListener.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2024-05-16
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -21,32 +22,32 @@
  * @doc: event.EventListener.description('An instance of this class can listen to any event. Usually, this class is used as base class of any class that must listen to an event.')
  * */
 
-namespace ls::std::event
+namespace ls::standard::event
 {
-  class LS_STD_DYNAMIC_GOAL EventListener : public ::std::enable_shared_from_this<EventListener>, public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL EventListener : public ::std::enable_shared_from_this<EventListener>, public ls::standard::core::Class
   {
     public:
 
       explicit EventListener();
       ~EventListener() noexcept override;
 
-      [[nodiscard]] ls::std::event::type::listener_id getId() const;
-      void setId(ls::std::event::type::listener_id _id);
-      void setParameter(const ls::std::event::EventParameter &_parameter);
-      [[maybe_unused]] bool subscribe(const ls::std::event::Event &_event, const ls::std::event::type::event_action &_action);
-      [[maybe_unused]] bool unsubscribe(const ls::std::event::Event &_event);
+      [[nodiscard]] ls::standard::event::type::listener_id getId() const;
+      void setId(ls::standard::event::type::listener_id _id);
+      void setParameter(const ls::standard::event::EventParameter &_parameter);
+      [[maybe_unused]] bool subscribe(const ls::standard::event::Event &_event, const ls::standard::event::type::event_action &_action);
+      [[maybe_unused]] bool unsubscribe(const ls::standard::event::Event &_event);
 
     protected:
 
-      ls::std::event::EventParameter parameter{};
+      ls::standard::event::EventParameter parameter{};
 
     private:
 
-      ls::std::event::type::listener_id id{};
+      ls::standard::event::type::listener_id id{};
 
-      void _requestListenerId(const ::std::shared_ptr<ls::std::core::Class> &_manager);
-      [[nodiscard]] bool _subscribe(const ls::std::event::Event &_event, const ls::std::event::type::event_action &_action);
-      [[nodiscard]] bool _unsubscribe(const ls::std::event::Event &_event);
+      void _requestListenerId(const ::std::shared_ptr<ls::standard::core::Class> &_manager);
+      [[nodiscard]] bool _subscribe(const ls::standard::event::Event &_event, const ls::standard::event::type::event_action &_action);
+      [[nodiscard]] bool _unsubscribe(const ls::standard::event::Event &_event);
   };
 }
 

include/ls-std/event/EventManager.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2024-05-16
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -21,10 +22,10 @@
 #include <memory>
 #include <unordered_map>
 
-namespace ls::std::event::type
+namespace ls::standard::event::type
 {
-  using event_listeners = ::std::list<::std::pair<::std::shared_ptr<ls::std::event::EventListener>, ls::std::event::type::event_action>>;
-  using event_observability_inventory = ::std::unordered_map<::std::string, ls::std::event::type::event_listeners>;
+  using event_listeners = ::std::list<::std::pair<::std::shared_ptr<ls::standard::event::EventListener>, ls::standard::event::type::event_action>>;
+  using event_observability_inventory = ::std::unordered_map<::std::string, ls::standard::event::type::event_listeners>;
 }
 
 /*
@@ -32,31 +33,31 @@ namespace ls::std::event::type
  * @doc: event.EventManager.description('This class can invoke all events known by subscribed listeners.')
  * */
 
-namespace ls::std::event
+namespace ls::standard::event
 {
-  class LS_STD_DYNAMIC_GOAL EventManager : public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL EventManager : public ls::standard::core::Class
   {
     public:
 
       explicit EventManager();
       ~EventManager() noexcept override;
 
-      [[nodiscard]] ls::std::event::type::listener_id getNextProvisionId() const;
-      [[nodiscard]] bool holdsListenerForEvent(ls::std::event::type::listener_id _id, const ls::std::event::Event &_event);
-      void invoke(const ls::std::event::Event &_event);
-      void invoke(const ls::std::event::Event &_event, const ls::std::event::EventParameter &_parameter);
-      [[nodiscard]] ls::std::event::type::listener_id requestListenerId();
-      void subscribeListenerForEvent(::std::shared_ptr<ls::std::event::EventListener> _listener, const ls::std::event::Event &_event, ls::std::event::type::event_action _action);
-      void unsubscribeListenerForEvent(const ::std::shared_ptr<ls::std::event::EventListener> &_listener, const ls::std::event::Event &_event);
+      [[nodiscard]] ls::standard::event::type::listener_id getNextProvisionId() const;
+      [[nodiscard]] bool holdsListenerForEvent(ls::standard::event::type::listener_id _id, const ls::standard::event::Event &_event);
+      void invoke(const ls::standard::event::Event &_event);
+      void invoke(const ls::standard::event::Event &_event, const ls::standard::event::EventParameter &_parameter);
+      [[nodiscard]] ls::standard::event::type::listener_id requestListenerId();
+      void subscribeListenerForEvent(::std::shared_ptr<ls::standard::event::EventListener> _listener, const ls::standard::event::Event &_event, ls::standard::event::type::event_action _action);
+      void unsubscribeListenerForEvent(const ::std::shared_ptr<ls::standard::event::EventListener> &_listener, const ls::standard::event::Event &_event);
 
     private:
 
-      ls::std::event::type::event_observability_inventory inventory{};
-      ls::std::event::type::listener_id provisionId = 1;
+      ls::standard::event::type::event_observability_inventory inventory{};
+      ls::standard::event::type::listener_id provisionId = 1;
 
-      static void _giveListenersParameter(const ls::std::event::type::event_listeners &_listeners, const ls::std::event::EventParameter &_parameter);
-      static void _notifyListeners(const ls::std::event::type::event_listeners &_listeners);
-      bool _observesEvent(const ls::std::event::Event &_event) const;
+      static void _giveListenersParameter(const ls::standard::event::type::event_listeners &_listeners, const ls::standard::event::EventParameter &_parameter);
+      static void _notifyListeners(const ls::standard::event::type::event_listeners &_listeners);
+      bool _observesEvent(const ls::standard::event::Event &_event) const;
   };
 }
 

include/ls-std/event/EventParameter.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2024-05-30
-* Changed:         2024-09-11
+* Changed:         2026-06-23
 *
 * */
 
@@ -19,7 +20,7 @@
  * @doc: event.EventParameter.description('This class holds parameters which can be sent during event invocation.')
  * */
 
-namespace ls::std::event
+namespace ls::standard::event
 {
   class LS_STD_DYNAMIC_GOAL EventParameter
   {

include/ls-std/event/type/EventTypes.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2024-05-16
-* Changed:         2024-05-17
+* Changed:         2026-06-23
 *
 * */
 
@@ -13,7 +14,7 @@
 #include <cstdint>
 #include <functional>
 
-namespace ls::std::event::type
+namespace ls::standard::event::type
 {
   using event_action = ::std::function<void()>;
   using listener_id = uint32_t;

include/ls-std/io/File.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2025-12-23
+ * Changed:         2026-06-23
  *
  * */
 
@@ -29,9 +30,9 @@
  * @doc: io.File.description('This class represents a file in the file system and provides functionalities for location, operations and fetching property information.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL File : public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL File : public ls::standard::core::Class
   {
     public:
 
@@ -40,8 +41,8 @@ namespace ls::std::io
 
       // comparison operators
 
-      bool operator==(const ls::std::io::File &_file) const;
-      bool operator!=(const ls::std::io::File &_file) const;
+      bool operator==(const ls::standard::io::File &_file) const;
+      bool operator!=(const ls::standard::io::File &_file) const;
 
       // additional functionality
 
@@ -76,7 +77,7 @@ namespace ls::std::io
 #ifdef _WIN32
       static void _addToFileListWindows(const ::std::string &_path, bool _withDirectories, WIN32_FIND_DATA _data, ::std::list<::std::string> &_list);
 #endif
-      [[nodiscard]] static bool _equals(const ls::std::io::File &_file, const ls::std::io::File &_foreignFile);
+      [[nodiscard]] static bool _equals(const ls::standard::io::File &_file, const ls::standard::io::File &_foreignFile);
       [[nodiscard]] static bool _exists(const ::std::string &_path);
       [[nodiscard]] static ::std::string _getParent(const ::std::string &_path);
 #if defined(unix) || defined(__APPLE__)

include/ls-std/io/FileOutputStream.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2024-09-13
+ * Changed:         2026-06-23
  *
  * */
 
@@ -21,23 +22,23 @@
  * @doc: io.FileOutputStream.description('This class can be used for writing to a file stream.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL FileOutputStream : public ls::std::core::Class, public ls::std::core::interface_type::IWriter
+  class LS_STD_DYNAMIC_GOAL FileOutputStream : public ls::standard::core::Class, public ls::standard::core::interface_type::IWriter
   {
     public:
 
-      explicit FileOutputStream(const ls::std::io::File &_file);
-      explicit FileOutputStream(const ls::std::io::File &_file, bool _append);
+      explicit FileOutputStream(const ls::standard::io::File &_file);
+      explicit FileOutputStream(const ls::standard::io::File &_file, bool _append);
       ~FileOutputStream() noexcept override;
 
       void close();
-      bool write(const ls::std::core::type::byte_field &_data) override; // nodiscard is optional here
+      bool write(const ls::standard::core::type::byte_field &_data) override; // nodiscard is optional here
 
     private:
 
       bool append{};
-      ls::std::io::File file;
+      ls::standard::io::File file;
       ::std::ofstream outputStream{};
 
       void _close();

include/ls-std/io/FilePathSeparator.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2024-09-13
+ * Changed:         2026-06-23
  *
  * */
 
@@ -18,7 +19,7 @@
  * @doc: io.FilePathSeparator.description('This class represents the OS specific separator withing file paths on either Windows- or Unix-like operating systems.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
   class LS_STD_DYNAMIC_GOAL FilePathSeparator
   {

include/ls-std/io/FilePathSeparatorMatch.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2024-09-13
+ * Changed:         2026-06-23
  *
  * */
 
@@ -17,7 +18,7 @@
  * @doc: io.FilePathSeparatorMatch.description('This class can filter file path separators.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
   class LS_STD_DYNAMIC_GOAL FilePathSeparatorMatch
   {

include/ls-std/io/FileReader.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2024-09-13
+ * Changed:         2026-06-23
  *
  * */
 
@@ -20,21 +21,21 @@
  * @doc: io.FileReader.description('This class can read the content of a file and return it as byte field.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL FileReader : public ls::std::core::Class, public ls::std::core::interface_type::IReader
+  class LS_STD_DYNAMIC_GOAL FileReader : public ls::standard::core::Class, public ls::standard::core::interface_type::IReader
   {
     public:
 
-      explicit FileReader(const ls::std::io::File &_file);
+      explicit FileReader(const ls::standard::io::File &_file);
       ~FileReader() noexcept override;
 
-      [[nodiscard]] ls::std::core::type::byte_field read() override;
-      void reset(const ls::std::io::File &_file);
+      [[nodiscard]] ls::standard::core::type::byte_field read() override;
+      void reset(const ls::standard::io::File &_file);
 
     private:
 
-      ls::std::io::File file;
+      ls::standard::io::File file;
   };
 }
 

include/ls-std/io/FileWriter.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2024-09-13
+ * Changed:         2026-06-23
  *
  * */
 
@@ -20,21 +21,21 @@
  * @doc: io.FileWriter.description('This class can write to a file.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL FileWriter : public ls::std::core::Class, public ls::std::core::interface_type::IWriter
+  class LS_STD_DYNAMIC_GOAL FileWriter : public ls::standard::core::Class, public ls::standard::core::interface_type::IWriter
   {
     public:
 
-      explicit FileWriter(const ls::std::io::File &_file);
+      explicit FileWriter(const ls::standard::io::File &_file);
       ~FileWriter() noexcept override;
 
-      void reset(const ls::std::io::File &_file);
-      bool write(const ls::std::core::type::byte_field &_data) override; // nodiscard is optional here
+      void reset(const ls::standard::io::File &_file);
+      bool write(const ls::standard::core::type::byte_field &_data) override; // nodiscard is optional here
 
     private:
 
-      ls::std::io::File file;
+      ls::standard::io::File file;
   };
 }
 

include/ls-std/io/NewLine.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-18
- * Changed:         2024-09-13
+ * Changed:         2026-06-23
  *
  * */
 
@@ -18,7 +19,7 @@
  * @doc: io.NewLine.description('This class can be used as new line based on the preferred operating system. Currently, Windows and Unix-like operating systems are supported.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
   class LS_STD_DYNAMIC_GOAL NewLine
   {

include/ls-std/io/StandardOutputWriter.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-06
- * Changed:         2024-09-13
+ * Changed:         2026-06-23
  *
  * */
 
@@ -18,16 +19,16 @@
  * @doc: io.StandardOutputWriter.description('This class can be used to write a string to stdout.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL StandardOutputWriter : public ls::std::core::interface_type::IWriter
+  class LS_STD_DYNAMIC_GOAL StandardOutputWriter : public ls::standard::core::interface_type::IWriter
   {
     public:
 
       StandardOutputWriter();
       ~StandardOutputWriter() noexcept override;
 
-      bool write(const ls::std::core::type::byte_field &_data) override; // nodiscard is optional here
+      bool write(const ls::standard::core::type::byte_field &_data) override; // nodiscard is optional here
   };
 }
 

include/ls-std/io/StorableFile.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2024-09-13
+ * Changed:         2026-06-23
  *
  * */
 
@@ -21,23 +22,23 @@
  * @doc: io.StorableFile.description('This class can be used to store any serialized information to a file.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL StorableFile : public ls::std::core::interface_type::IStorable
+  class LS_STD_DYNAMIC_GOAL StorableFile : public ls::standard::core::interface_type::IStorable
   {
     public:
 
       explicit StorableFile(const ::std::string &_path);
       ~StorableFile() noexcept override;
 
-      [[nodiscard]] ::std::shared_ptr<ls::std::io::File> getFile() const;
-      [[nodiscard]] ls::std::core::type::byte_field load() override;
+      [[nodiscard]] ::std::shared_ptr<ls::standard::io::File> getFile() const;
+      [[nodiscard]] ls::standard::core::type::byte_field load() override;
       void reset(const ::std::string &_path);
-      void save(const ls::std::core::type::byte_field &_data) override;
+      void save(const ls::standard::core::type::byte_field &_data) override;
 
     private:
 
-      ::std::shared_ptr<ls::std::io::File> file{};
+      ::std::shared_ptr<ls::standard::io::File> file{};
 
       void _init(const ::std::string &_path);
   };

include/ls-std/io/evaluator/FileExistenceEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,9 +21,9 @@
  * @doc: io.FileExistenceEvaluator.description('This class evaluates whether a file exists and throws an exception in case it does not.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL FileExistenceEvaluator : public ls::std::core::Class, public ls::std::core::interface_type::IEvaluator
+  class LS_STD_DYNAMIC_GOAL FileExistenceEvaluator : public ls::standard::core::Class, public ls::standard::core::interface_type::IEvaluator
   {
     public:
 

include/ls-std/io/logging/LogLevel.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2024-09-13
+ * Changed:         2026-06-23
  *
  * */
 
@@ -21,34 +22,34 @@
  * @doc: io.LogLevel.description('This class represents the log level controlling how noisy a log should be.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL LogLevel : public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL LogLevel : public ls::standard::core::Class
   {
     public:
 
-      explicit LogLevel(const ls::std::io::LogLevelValue &_value);
+      explicit LogLevel(const ls::standard::io::LogLevelValue &_value);
       LogLevel();
       ~LogLevel() noexcept override;
 
-      ls::std::io::LogLevel &operator=(const ls::std::io::LogLevelValue &_value);
-      bool operator<(const ls::std::io::LogLevelValue &_value) const;
-      bool operator<=(const ls::std::io::LogLevelValue &_value) const;
-      bool operator>(const ls::std::io::LogLevelValue &_value) const;
-      bool operator>=(const ls::std::io::LogLevelValue &_value) const;
-      bool operator==(const ls::std::io::LogLevelValue &_value) const;
+      ls::standard::io::LogLevel &operator=(const ls::standard::io::LogLevelValue &_value);
+      bool operator<(const ls::standard::io::LogLevelValue &_value) const;
+      bool operator<=(const ls::standard::io::LogLevelValue &_value) const;
+      bool operator>(const ls::standard::io::LogLevelValue &_value) const;
+      bool operator>=(const ls::standard::io::LogLevelValue &_value) const;
+      bool operator==(const ls::standard::io::LogLevelValue &_value) const;
 
-      [[nodiscard]] ls::std::io::LogLevelValue getValue() const;
-      void setLogLevel(const ls::std::io::LogLevelValue &_value);
+      [[nodiscard]] ls::standard::io::LogLevelValue getValue() const;
+      void setLogLevel(const ls::standard::io::LogLevelValue &_value);
       void setLogLevel(const ::std::string &_value);
       [[nodiscard]] ::std::string toString() const;
 
     private:
 
-      ::std::unordered_map<ls::std::io::LogLevelValue, ::std::string> level{};
-      ls::std::io::LogLevelValue value{};
+      ::std::unordered_map<ls::standard::io::LogLevelValue, ::std::string> level{};
+      ls::standard::io::LogLevelValue value{};
 
-      [[nodiscard]] ls::std::io::LogLevelValue _getValueFromString(const ::std::string &_value);
+      [[nodiscard]] ls::standard::io::LogLevelValue _getValueFromString(const ::std::string &_value);
       void _init();
       [[nodiscard]] bool _isValidLogLevelString(::std::string_view _value) const;
   };

include/ls-std/io/logging/LogLevelValue.hpp

@@ -1,16 +1,17 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2023-05-19
+ * Changed:         2026-06-23
  *
  * */
 
 #ifndef LS_STD_LOG_LEVEL_VALUE_HPP
 #define LS_STD_LOG_LEVEL_VALUE_HPP
 
-namespace ls::std::io
+namespace ls::standard::io
 {
   enum class LogLevelValue
   {

include/ls-std/io/logging/Logger.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2024-09-13
+ * Changed:         2026-06-23
  *
  * */
 
@@ -24,42 +25,42 @@
  * @doc: io.Logger.description('This is a logger which can log to any implemented target.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL Logger : public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL Logger : public ls::standard::core::Class
   {
     public:
 
-      explicit Logger(const ::std::shared_ptr<ls::std::core::interface_type::IWriter> &_writer);
+      explicit Logger(const ::std::shared_ptr<ls::standard::core::interface_type::IWriter> &_writer);
       ~Logger() noexcept override;
 
-      void debug(const ls::std::core::type::byte_type *_data) const;
-      void error(const ls::std::core::type::byte_type *_data) const;
-      void fatal(const ls::std::core::type::byte_type *_data) const;
-      [[nodiscard]] ls::std::io::LogLevel getLogLevel() const;
+      void debug(const ls::standard::core::type::byte_type *_data) const;
+      void error(const ls::standard::core::type::byte_type *_data) const;
+      void fatal(const ls::standard::core::type::byte_type *_data) const;
+      [[nodiscard]] ls::standard::io::LogLevel getLogLevel() const;
       void hideLogLevel();
       void hideTimestamp();
-      void info(const ls::std::core::type::byte_type *_data) const;
-      void setLogLevel(const ls::std::io::LogLevelValue &_logLevelValue);
+      void info(const ls::standard::core::type::byte_type *_data) const;
+      void setLogLevel(const ls::standard::io::LogLevelValue &_logLevelValue);
       void showLogLevel();
       void showTimestamp();
-      void trace(const ls::std::core::type::byte_type *_data) const;
-      void warn(const ls::std::core::type::byte_type *_data) const;
+      void trace(const ls::standard::core::type::byte_type *_data) const;
+      void warn(const ls::standard::core::type::byte_type *_data) const;
 
     private:
 
       bool displayLogLevel{};
       bool displayTimestamp{};
-      ls::std::io::LogLevel logLevel{};
-      ::std::shared_ptr<ls::std::core::interface_type::IWriter> writer{};
+      ls::standard::io::LogLevel logLevel{};
+      ::std::shared_ptr<ls::standard::core::interface_type::IWriter> writer{};
 
-      void _assignWriter(const ::std::shared_ptr<ls::std::core::interface_type::IWriter> &_writer);
+      void _assignWriter(const ::std::shared_ptr<ls::standard::core::interface_type::IWriter> &_writer);
       [[nodiscard]] static ::std::string _buildCharacterChain(size_t _amount);
       [[nodiscard]] static ::std::string _createFillContent(::std::string_view _text);
       [[nodiscard]] static ::std::string _generateTimeString(const tm *_localTime);
-      [[nodiscard]] ::std::string _getLogLevelString(const ls::std::io::LogLevel &_logLevel) const;
+      [[nodiscard]] ::std::string _getLogLevelString(const ls::standard::io::LogLevel &_logLevel) const;
       [[nodiscard]] ::std::string _getTimestampString() const;
-      void _log(const ls::std::core::type::byte_type *_data, const ls::std::io::LogLevel &_logLevel) const;
+      void _log(const ls::standard::core::type::byte_type *_data, const ls::standard::io::LogLevel &_logLevel) const;
       [[nodiscard]] static ::std::string _padRight(const ::std::string &_text);
   };
 }

include/ls-std/io/section-pair/SectionPairMessageFormatter.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-22
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -18,7 +19,7 @@
  * @doc: io.SectionPairMessageFormatter.description('This message formatter replaces new line sequences, which are OS specific, to a readable tag for error message formatting.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
   class LS_STD_DYNAMIC_GOAL SectionPairMessageFormatter
   {

include/ls-std/io/section-pair/SectionPairRowEnumType.hpp

@@ -1,16 +1,17 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-05-18
+* Changed:         2026-06-23
 *
 * */
 
 #ifndef LS_STD_SECTION_PAIR_ROW_ENUM_TYPE_HPP
 #define LS_STD_SECTION_PAIR_ROW_ENUM_TYPE_HPP
 
-namespace ls::std::io
+namespace ls::standard::io
 {
   enum class SectionPairRowEnumType
   {

include/ls-std/io/section-pair/SectionPairTypes.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2023-02-10
+* Changed:         2026-06-23
 *
 * */
 
@@ -12,7 +13,7 @@
 
 #include <string>
 
-namespace ls::std::io
+namespace ls::standard::io
 {
   using section_pair_identifier = ::std::string;
   using section_pair_row_value = ::std::string;

include/ls-std/io/section-pair/evaluator/SectionPairIdentifierArgumentEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-09
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,20 +21,20 @@
  * @doc: io.SectionPairIdentifierArgumentEvaluator.description('This class checks whether an identifier argument is valid and throws an exception if that is not the case.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairIdentifierArgumentEvaluator : public ls::std::core::interface_type::IEvaluator, public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL SectionPairIdentifierArgumentEvaluator : public ls::standard::core::interface_type::IEvaluator, public ls::standard::core::Class
   {
     public:
 
-      explicit SectionPairIdentifierArgumentEvaluator(ls::std::io::section_pair_identifier _identifier);
+      explicit SectionPairIdentifierArgumentEvaluator(ls::standard::io::section_pair_identifier _identifier);
       ~SectionPairIdentifierArgumentEvaluator() noexcept override;
 
       void evaluate() override;
 
     private:
 
-      ls::std::io::section_pair_identifier identifier{};
+      ls::standard::io::section_pair_identifier identifier{};
   };
 }
 

include/ls-std/io/section-pair/evaluator/SectionPairRowArgumentEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,9 +21,9 @@
  * @doc: io.SectionPairRowArgumentEvaluator.description('This class checks whether a row argument is valid and throws an exception if that is not the case.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairRowArgumentEvaluator : public ls::std::core::Class, public ls::std::core::interface_type::IEvaluator
+  class LS_STD_DYNAMIC_GOAL SectionPairRowArgumentEvaluator : public ls::standard::core::Class, public ls::standard::core::interface_type::IEvaluator
   {
     public:
 

include/ls-std/io/section-pair/evaluator/SectionPairRowListValueArgumentEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,9 +21,9 @@
  * @doc: io.SectionPairRowListValueArgumentEvaluator.description('This class checks whether a row list value argument is valid and throws an exception if that is not the case.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairRowListValueArgumentEvaluator : public ls::std::core::Class, public ls::std::core::interface_type::IEvaluator
+  class LS_STD_DYNAMIC_GOAL SectionPairRowListValueArgumentEvaluator : public ls::standard::core::Class, public ls::standard::core::interface_type::IEvaluator
   {
     public:
 

include/ls-std/io/section-pair/evaluator/SectionPairRowSingleValueArgumentEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-19
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,9 +21,9 @@
  * @doc: io.SectionPairRowSingleValueArgumentEvaluator.description('This class checks whether a single row value argument is valid and throws an exception if that is not the case.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairRowSingleValueArgumentEvaluator : public ls::std::core::Class, public ls::std::core::interface_type::IEvaluator
+  class LS_STD_DYNAMIC_GOAL SectionPairRowSingleValueArgumentEvaluator : public ls::standard::core::Class, public ls::standard::core::interface_type::IEvaluator
   {
     public:
 

include/ls-std/io/section-pair/evaluator/SectionPairSectionArgumentEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,9 +21,9 @@
  * @doc: io.SectionPairSectionArgumentEvaluator.description('This class checks whether a whole section argument is valid and throws an exception if that is not the case.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairSectionArgumentEvaluator : public ls::std::core::Class, public ls::std::core::interface_type::IEvaluator
+  class LS_STD_DYNAMIC_GOAL SectionPairSectionArgumentEvaluator : public ls::standard::core::Class, public ls::standard::core::interface_type::IEvaluator
   {
     public:
 

include/ls-std/io/section-pair/evaluator/SectionPairValueArgumentEvaluator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -21,20 +22,20 @@
  * @doc: io.SectionPairValueArgumentEvaluator.description('This class checks whether a value argument is valid and throws an exception if that is not the case.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairValueArgumentEvaluator : public ls::std::core::interface_type::IEvaluator, public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL SectionPairValueArgumentEvaluator : public ls::standard::core::interface_type::IEvaluator, public ls::standard::core::Class
   {
     public:
 
-      explicit SectionPairValueArgumentEvaluator(ls::std::io::section_pair_row_value _value);
+      explicit SectionPairValueArgumentEvaluator(ls::standard::io::section_pair_row_value _value);
       ~SectionPairValueArgumentEvaluator() noexcept override;
 
       void evaluate() override;
 
     private:
 
-      ls::std::io::section_pair_row_value value{};
+      ls::standard::io::section_pair_row_value value{};
   };
 }
 

include/ls-std/io/section-pair/model/SectionPairDocument.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-15
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -23,38 +24,38 @@
  * @doc: io.SectionPairDocument.description('This class represents a whole Section Pair document.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairDocument : public ::std::enable_shared_from_this<SectionPairDocument>, public ls::std::core::Class, public ls::std::core::interface_type::ISerializable
+  class LS_STD_DYNAMIC_GOAL SectionPairDocument : public ::std::enable_shared_from_this<SectionPairDocument>, public ls::standard::core::Class, public ls::standard::core::interface_type::ISerializable
   {
     public:
 
       SectionPairDocument();
       ~SectionPairDocument() noexcept override;
 
-      void add(const ls::std::io::section_pair_document_section_list_element &_section);
+      void add(const ls::standard::io::section_pair_document_section_list_element &_section);
       void clear();
-      [[nodiscard]] ls::std::io::section_pair_document_section_list_element get(size_t _index) const;
-      [[nodiscard]] ls::std::io::section_pair_document_section_list_element get(const ls::std::io::section_pair_identifier &_sectionId) const;
+      [[nodiscard]] ls::standard::io::section_pair_document_section_list_element get(size_t _index) const;
+      [[nodiscard]] ls::standard::io::section_pair_document_section_list_element get(const ls::standard::io::section_pair_identifier &_sectionId) const;
       [[nodiscard]] size_t getAmountOfSections() const;
       [[nodiscard]] ::std::string getHeader() const;
-      [[nodiscard]] ls::std::io::section_pair_document_section_list getSectionList() const;
-      [[nodiscard]] bool hasSection(const ls::std::io::section_pair_identifier &_sectionId);
-      [[nodiscard]] ls::std::core::type::byte_field marshal() override;
+      [[nodiscard]] ls::standard::io::section_pair_document_section_list getSectionList() const;
+      [[nodiscard]] bool hasSection(const ls::standard::io::section_pair_identifier &_sectionId);
+      [[nodiscard]] ls::standard::core::type::byte_field marshal() override;
       void reserveNewLine(::std::string_view _reservedNewLine);
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      void unmarshal(const ls::standard::core::type::byte_field &_data) override;
 
     private:
 
       const ::std::string header = "# section-pair document";
       ::std::string reservedNewLine{};
-      ls::std::io::section_pair_document_section_list sections{};
-      ::std::shared_ptr<ls::std::core::interface_type::ISerializable> serializable{};
+      ls::standard::io::section_pair_document_section_list sections{};
+      ::std::shared_ptr<ls::standard::core::interface_type::ISerializable> serializable{};
 
-      void _checkSectionExistence(const ls::std::io::section_pair_identifier &_sectionId);
+      void _checkSectionExistence(const ls::standard::io::section_pair_identifier &_sectionId);
       void _createSerializable();
-      [[nodiscard]] ls::std::io::section_pair_document_section_list_element _get(const ls::std::io::section_pair_identifier &_sectionId) const;
-      [[nodiscard]] bool _hasSection(const ls::std::io::section_pair_identifier &_identifier);
+      [[nodiscard]] ls::standard::io::section_pair_document_section_list_element _get(const ls::standard::io::section_pair_identifier &_sectionId) const;
+      [[nodiscard]] bool _hasSection(const ls::standard::io::section_pair_identifier &_identifier);
   };
 }
 

include/ls-std/io/section-pair/model/SectionPairRow.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -25,34 +26,34 @@
  * @doc: io.SectionPairRow.description('This class represents a Section Pair row.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairRow : public ::std::enable_shared_from_this<SectionPairRow>, public ls::std::core::Class, public ls::std::core::interface_type::ISerializable
+  class LS_STD_DYNAMIC_GOAL SectionPairRow : public ::std::enable_shared_from_this<SectionPairRow>, public ls::standard::core::Class, public ls::standard::core::interface_type::ISerializable
   {
     public:
 
-      explicit SectionPairRow(const ls::std::io::section_pair_identifier &_key, const ls::std::io::SectionPairRowEnumType &_type);
+      explicit SectionPairRow(const ls::standard::io::section_pair_identifier &_key, const ls::standard::io::SectionPairRowEnumType &_type);
       ~SectionPairRow() noexcept override;
 
-      [[nodiscard]] ls::std::io::section_pair_identifier getKey() const;
-      [[nodiscard]] ::std::shared_ptr<ls::std::io::SectionPairRowValue> getValue() const;
+      [[nodiscard]] ls::standard::io::section_pair_identifier getKey() const;
+      [[nodiscard]] ::std::shared_ptr<ls::standard::io::SectionPairRowValue> getValue() const;
       [[nodiscard]] bool isList() const;
       [[nodiscard]] bool isSingleValue() const;
-      [[nodiscard]] ls::std::core::type::byte_field marshal() override;
+      [[nodiscard]] ls::standard::core::type::byte_field marshal() override;
       void reserveNewLine(::std::string_view _reservedNewLine);
-      void setKey(const ls::std::io::section_pair_identifier &_key);
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      void setKey(const ls::standard::io::section_pair_identifier &_key);
+      void unmarshal(const ls::standard::core::type::byte_field &_data) override;
 
     private:
 
-      ls::std::io::section_pair_identifier key{};
+      ls::standard::io::section_pair_identifier key{};
       ::std::string reservedNewLine{};
-      ::std::shared_ptr<ls::std::core::interface_type::ISerializable> serializable{};
-      ::std::shared_ptr<ls::std::io::SectionPairRowValue> value{};
+      ::std::shared_ptr<ls::standard::core::interface_type::ISerializable> serializable{};
+      ::std::shared_ptr<ls::standard::io::SectionPairRowValue> value{};
 
       void _createSerializable();
-      void _initValue(const ls::std::io::SectionPairRowEnumType &_type);
-      void _setKey(const ls::std::io::section_pair_identifier &_key);
+      void _initValue(const ls::standard::io::SectionPairRowEnumType &_type);
+      void _setKey(const ls::standard::io::section_pair_identifier &_key);
   };
 }
 

include/ls-std/io/section-pair/model/SectionPairRowListValue.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -21,28 +22,28 @@
  * @doc: io.SectionPairRowListValue.description('This class represents a Section Pair row list value.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairRowListValue : public ::std::enable_shared_from_this<SectionPairRowListValue>, public ls::std::core::Class, public ls::std::io::SectionPairRowValue
+  class LS_STD_DYNAMIC_GOAL SectionPairRowListValue : public ::std::enable_shared_from_this<SectionPairRowListValue>, public ls::standard::core::Class, public ls::standard::io::SectionPairRowValue
   {
     public:
 
       SectionPairRowListValue();
       ~SectionPairRowListValue() noexcept override;
 
-      void add(const ls::std::io::section_pair_row_value &_value);
+      void add(const ls::standard::io::section_pair_row_value &_value);
       void clear();
-      [[nodiscard]] ls::std::io::section_pair_row_value get(size_t _index) const;
-      [[nodiscard]] ::std::list<ls::std::io::section_pair_row_value> getList() const;
+      [[nodiscard]] ls::standard::io::section_pair_row_value get(size_t _index) const;
+      [[nodiscard]] ::std::list<ls::standard::io::section_pair_row_value> getList() const;
       [[nodiscard]] size_t getSize() const;
-      [[nodiscard]] ls::std::io::SectionPairRowEnumType getType() override;
-      [[nodiscard]] ls::std::core::type::byte_field marshal() override;
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      [[nodiscard]] ls::standard::io::SectionPairRowEnumType getType() override;
+      [[nodiscard]] ls::standard::core::type::byte_field marshal() override;
+      void unmarshal(const ls::standard::core::type::byte_field &_data) override;
 
     private:
 
-      ::std::shared_ptr<ls::std::core::interface_type::ISerializable> serializable{};
-      ::std::list<ls::std::io::section_pair_row_value> values{};
+      ::std::shared_ptr<ls::standard::core::interface_type::ISerializable> serializable{};
+      ::std::list<ls::standard::io::section_pair_row_value> values{};
 
       void _createSerializable();
   };

include/ls-std/io/section-pair/model/SectionPairRowSingleValue.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -22,28 +23,28 @@
  * @doc: io.SectionPairRowSingleValue.description('This class represents a Section Pair row single value.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairRowSingleValue : public ::std::enable_shared_from_this<SectionPairRowSingleValue>, public ls::std::core::Class, public ls::std::io::SectionPairRowValue
+  class LS_STD_DYNAMIC_GOAL SectionPairRowSingleValue : public ::std::enable_shared_from_this<SectionPairRowSingleValue>, public ls::standard::core::Class, public ls::standard::io::SectionPairRowValue
   {
     public:
 
-      explicit SectionPairRowSingleValue(const ls::std::io::section_pair_row_value &_value);
+      explicit SectionPairRowSingleValue(const ls::standard::io::section_pair_row_value &_value);
       ~SectionPairRowSingleValue() noexcept override;
 
-      [[nodiscard]] ls::std::io::section_pair_row_value get() const;
-      [[nodiscard]] ls::std::io::SectionPairRowEnumType getType() override;
-      [[nodiscard]] ls::std::core::type::byte_field marshal() override;
-      void set(const ls::std::io::section_pair_row_value &_value);
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      [[nodiscard]] ls::standard::io::section_pair_row_value get() const;
+      [[nodiscard]] ls::standard::io::SectionPairRowEnumType getType() override;
+      [[nodiscard]] ls::standard::core::type::byte_field marshal() override;
+      void set(const ls::standard::io::section_pair_row_value &_value);
+      void unmarshal(const ls::standard::core::type::byte_field &_data) override;
 
     private:
 
-      ::std::shared_ptr<ls::std::core::interface_type::ISerializable> serializable{};
-      ls::std::io::section_pair_row_value value{};
+      ::std::shared_ptr<ls::standard::core::interface_type::ISerializable> serializable{};
+      ls::standard::io::section_pair_row_value value{};
 
       void _createSerializable();
-      void _set(const ls::std::io::section_pair_row_value &_value);
+      void _set(const ls::standard::io::section_pair_row_value &_value);
   };
 }
 

include/ls-std/io/section-pair/model/SectionPairRowValue.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,29 +21,29 @@
  * @doc: io.SectionPairRowValue.description('This class represents a Section Pair row value.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairRowValue : public ls::std::core::interface_type::ISerializable
+  class LS_STD_DYNAMIC_GOAL SectionPairRowValue : public ls::standard::core::interface_type::ISerializable
   {
     public:
 
-      explicit SectionPairRowValue(const ls::std::io::SectionPairRowEnumType &_type);
+      explicit SectionPairRowValue(const ls::standard::io::SectionPairRowEnumType &_type);
       ~SectionPairRowValue() noexcept override;
 
-      virtual ls::std::io::SectionPairRowEnumType getType() = 0;
-      [[nodiscard]] ls::std::core::type::byte_field marshal() override;
+      virtual ls::standard::io::SectionPairRowEnumType getType() = 0;
+      [[nodiscard]] ls::standard::core::type::byte_field marshal() override;
       void reserveNewLine(::std::string_view _reservedNewLine);
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      void unmarshal(const ls::standard::core::type::byte_field &_data) override;
 
     protected:
 
       [[nodiscard]] ::std::string _getReservedNewLine() const;
-      [[nodiscard]] ls::std::io::SectionPairRowEnumType _getType() const;
+      [[nodiscard]] ls::standard::io::SectionPairRowEnumType _getType() const;
 
     private:
 
       ::std::string reservedNewLine{};
-      ls::std::io::SectionPairRowEnumType type{};
+      ls::standard::io::SectionPairRowEnumType type{};
   };
 }
 

include/ls-std/io/section-pair/model/SectionPairSection.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-13
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -25,40 +26,40 @@
  * @doc: io.SectionPairSection.description('This class represents a Section Pair section.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairSection : public ::std::enable_shared_from_this<SectionPairSection>, public ls::std::core::Class, public ls::std::core::interface_type::ISerializable
+  class LS_STD_DYNAMIC_GOAL SectionPairSection : public ::std::enable_shared_from_this<SectionPairSection>, public ls::standard::core::Class, public ls::standard::core::interface_type::ISerializable
   {
     public:
 
-      explicit SectionPairSection(const ls::std::io::section_pair_identifier &_sectionId);
+      explicit SectionPairSection(const ls::standard::io::section_pair_identifier &_sectionId);
       ~SectionPairSection() noexcept override;
 
-      void add(const ls::std::io::section_pair_row_list_element &_row);
+      void add(const ls::standard::io::section_pair_row_list_element &_row);
       void clear();
-      [[nodiscard]] ls::std::io::section_pair_row_list_element get(size_t _index) const;
-      [[nodiscard]] ls::std::io::section_pair_row_list_element get(const ls::std::io::section_pair_identifier &_key) const;
-      [[nodiscard]] ls::std::io::section_pair_row_list getList() const;
+      [[nodiscard]] ls::standard::io::section_pair_row_list_element get(size_t _index) const;
+      [[nodiscard]] ls::standard::io::section_pair_row_list_element get(const ls::standard::io::section_pair_identifier &_key) const;
+      [[nodiscard]] ls::standard::io::section_pair_row_list getList() const;
       [[nodiscard]] size_t getRowAmount() const;
-      [[nodiscard]] ls::std::io::section_pair_identifier getSectionId() const;
-      [[nodiscard]] bool hasRow(const ls::std::io::section_pair_identifier &_key);
-      [[nodiscard]] ls::std::core::type::byte_field marshal() override;
+      [[nodiscard]] ls::standard::io::section_pair_identifier getSectionId() const;
+      [[nodiscard]] bool hasRow(const ls::standard::io::section_pair_identifier &_key);
+      [[nodiscard]] ls::standard::core::type::byte_field marshal() override;
       void reserveNewLine(::std::string_view _reservedNewLine);
-      void setSectionId(const ls::std::io::section_pair_identifier &_sectionId);
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      void setSectionId(const ls::standard::io::section_pair_identifier &_sectionId);
+      void unmarshal(const ls::standard::core::type::byte_field &_data) override;
 
     private:
 
       ::std::string reservedNewLine{};
-      ls::std::io::section_pair_row_list rows{};
-      ls::std::io::section_pair_identifier sectionId{};
-      ::std::shared_ptr<ls::std::core::interface_type::ISerializable> serializable{};
+      ls::standard::io::section_pair_row_list rows{};
+      ls::standard::io::section_pair_identifier sectionId{};
+      ::std::shared_ptr<ls::standard::core::interface_type::ISerializable> serializable{};
 
       void _createSerializable();
-      [[nodiscard]] ls::std::io::section_pair_row_list_element _get(const ls::std::io::section_pair_identifier &_key) const;
-      [[nodiscard]] bool _hasRow(const ls::std::io::section_pair_identifier &_key);
-      void _rowExistenceCheck(const ls::std::io::section_pair_identifier &_key);
-      void _setSectionId(const ls::std::io::section_pair_identifier &_sectionId);
+      [[nodiscard]] ls::standard::io::section_pair_row_list_element _get(const ls::standard::io::section_pair_identifier &_key) const;
+      [[nodiscard]] bool _hasRow(const ls::standard::io::section_pair_identifier &_key);
+      void _rowExistenceCheck(const ls::standard::io::section_pair_identifier &_key);
+      void _setSectionId(const ls::standard::io::section_pair_identifier &_sectionId);
   };
 }
 

include/ls-std/io/section-pair/reader/SectionPairFileReader.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -21,21 +22,21 @@
  * @doc: io.SectionPairFileReader.description('This class reads a Section Pair file and writes it to a Section Pair document instance.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairFileReader : public ls::std::core::Class, public ls::std::core::interface_type::IReader
+  class LS_STD_DYNAMIC_GOAL SectionPairFileReader : public ls::standard::core::Class, public ls::standard::core::interface_type::IReader
   {
     public:
 
-      explicit SectionPairFileReader(const ls::std::io::SectionPairFileReaderParameter &_parameter);
+      explicit SectionPairFileReader(const ls::standard::io::SectionPairFileReaderParameter &_parameter);
       ~SectionPairFileReader() noexcept override;
 
-      [[nodiscard]] ::std::shared_ptr<ls::std::io::SectionPairDocument> getDocument() const;
-      ls::std::core::type::byte_field read() override; // nodiscard is optional here
+      [[nodiscard]] ::std::shared_ptr<ls::standard::io::SectionPairDocument> getDocument() const;
+      ls::standard::core::type::byte_field read() override; // nodiscard is optional here
 
     private:
 
-      ls::std::io::SectionPairFileReaderParameter parameter{};
+      ls::standard::io::SectionPairFileReaderParameter parameter{};
 
       void _checkFileExtension() const;
       void _createDocument();

include/ls-std/io/section-pair/reader/SectionPairFileReaderParameter.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -23,7 +24,7 @@
  * @doc: io.SectionPairFileReaderParameter.description('This class holds evaluators and the document instance for Section Pair file reading.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
   class LS_STD_DYNAMIC_GOAL SectionPairFileReaderParameter
   {
@@ -32,21 +33,21 @@ namespace ls::std::io
       SectionPairFileReaderParameter();
       ~SectionPairFileReaderParameter();
 
-      [[nodiscard]] ::std::shared_ptr<ls::std::io::SectionPairDocument> getDocument() const;
-      [[nodiscard]] ::std::shared_ptr<ls::std::core::interface_type::IEvaluator> getFileExistenceEvaluator() const;
+      [[nodiscard]] ::std::shared_ptr<ls::standard::io::SectionPairDocument> getDocument() const;
+      [[nodiscard]] ::std::shared_ptr<ls::standard::core::interface_type::IEvaluator> getFileExistenceEvaluator() const;
       [[nodiscard]] ::std::string getFilePath() const;
-      [[nodiscard]] ::std::shared_ptr<ls::std::core::interface_type::IReader> getReader() const;
-      void setDocument(const ::std::shared_ptr<ls::std::io::SectionPairDocument> &_document);
-      void setFileExistenceEvaluator(const ::std::shared_ptr<ls::std::core::interface_type::IEvaluator> &_fileExistenceEvaluator);
+      [[nodiscard]] ::std::shared_ptr<ls::standard::core::interface_type::IReader> getReader() const;
+      void setDocument(const ::std::shared_ptr<ls::standard::io::SectionPairDocument> &_document);
+      void setFileExistenceEvaluator(const ::std::shared_ptr<ls::standard::core::interface_type::IEvaluator> &_fileExistenceEvaluator);
       void setFilePath(::std::string_view _filePath);
-      void setReader(const ::std::shared_ptr<ls::std::core::interface_type::IReader> &_reader);
+      void setReader(const ::std::shared_ptr<ls::standard::core::interface_type::IReader> &_reader);
 
     private:
 
-      ::std::shared_ptr<ls::std::io::SectionPairDocument> document{};
-      ::std::shared_ptr<ls::std::core::interface_type::IEvaluator> fileExistenceEvaluator{};
+      ::std::shared_ptr<ls::standard::io::SectionPairDocument> document{};
+      ::std::shared_ptr<ls::standard::core::interface_type::IEvaluator> fileExistenceEvaluator{};
       ::std::string filePath{};
-      ::std::shared_ptr<ls::std::core::interface_type::IReader> reader{};
+      ::std::shared_ptr<ls::standard::core::interface_type::IReader> reader{};
   };
 }
 

include/ls-std/io/section-pair/serialization/SerializableSectionPairDocument.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-16
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -22,27 +23,27 @@
  * @doc: io.SerializableSectionPairDocument.description('This class can serialize a Section Pair document for file persistence.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SerializableSectionPairDocument : public ls::std::core::interface_type::ISerializable, public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL SerializableSectionPairDocument : public ls::standard::core::interface_type::ISerializable, public ls::standard::core::Class
   {
     public:
 
-      explicit SerializableSectionPairDocument(const ls::std::io::SerializableSectionPairParameter &_parameter);
+      explicit SerializableSectionPairDocument(const ls::standard::io::SerializableSectionPairParameter &_parameter);
       ~SerializableSectionPairDocument() noexcept override;
 
-      [[nodiscard]] ::std::shared_ptr<ls::std::core::Class> getValue() const;
-      [[nodiscard]] ls::std::core::type::byte_field marshal() override;
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      [[nodiscard]] ::std::shared_ptr<ls::standard::core::Class> getValue() const;
+      [[nodiscard]] ls::standard::core::type::byte_field marshal() override;
+      void unmarshal(const ls::standard::core::type::byte_field &_data) override;
 
     private:
 
-      ls::std::io::SerializableSectionPairParameter parameter{};
+      ls::standard::io::SerializableSectionPairParameter parameter{};
 
-      [[nodiscard]] ls::std::core::type::byte_field _getCurrentRow(size_t _iterations, ::std::string_view _serializedDocument) const;
-      [[nodiscard]] ls::std::core::type::byte_field _getNextSerializedSection(const ls::std::core::type::byte_field &_serializedDocument) const;
+      [[nodiscard]] ls::standard::core::type::byte_field _getCurrentRow(size_t _iterations, ::std::string_view _serializedDocument) const;
+      [[nodiscard]] ls::standard::core::type::byte_field _getNextSerializedSection(const ls::standard::core::type::byte_field &_serializedDocument) const;
       [[nodiscard]] bool _isNotNewSection(::std::string_view _currentRow) const;
-      void _addSection(const ls::std::core::type::byte_field &_serializedSection) const;
+      void _addSection(const ls::standard::core::type::byte_field &_serializedSection) const;
   };
 }
 

include/ls-std/io/section-pair/serialization/SerializableSectionPairParameter.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-17
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -21,7 +22,7 @@
  * @doc: io.SerializableSectionPairParameter.description('This class is holding information for Section Pair serialization.')
  */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
   class LS_STD_DYNAMIC_GOAL SerializableSectionPairParameter
   {
@@ -31,14 +32,14 @@ namespace ls::std::io
       ~SerializableSectionPairParameter();
 
       [[nodiscard]] ::std::string getNewLine() const;
-      [[nodiscard]] ::std::shared_ptr<ls::std::core::Class> getValue() const;
+      [[nodiscard]] ::std::shared_ptr<ls::standard::core::Class> getValue() const;
       void setNewLine(::std::string_view _newLine);
-      void setValue(const ::std::shared_ptr<ls::std::core::Class> &_value);
+      void setValue(const ::std::shared_ptr<ls::standard::core::Class> &_value);
 
     private:
 
       ::std::string parseNewLine{};
-      ::std::shared_ptr<ls::std::core::Class> value{};
+      ::std::shared_ptr<ls::standard::core::Class> value{};
   };
 }
 

include/ls-std/io/section-pair/serialization/SerializableSectionPairRow.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-11
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -22,26 +23,26 @@
  * @doc: io.SerializableSectionPairRow.description('This class can serialize a Section Pair row for file persistence.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SerializableSectionPairRow : public ls::std::core::interface_type::ISerializable, public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL SerializableSectionPairRow : public ls::standard::core::interface_type::ISerializable, public ls::standard::core::Class
   {
     public:
 
-      explicit SerializableSectionPairRow(const ls::std::io::SerializableSectionPairParameter &_parameter);
+      explicit SerializableSectionPairRow(const ls::standard::io::SerializableSectionPairParameter &_parameter);
       ~SerializableSectionPairRow() noexcept override;
 
-      [[nodiscard]] ::std::shared_ptr<ls::std::core::Class> getValue() const;
-      [[nodiscard]] ls::std::core::type::byte_field marshal() override;
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      [[nodiscard]] ::std::shared_ptr<ls::standard::core::Class> getValue() const;
+      [[nodiscard]] ls::standard::core::type::byte_field marshal() override;
+      void unmarshal(const ls::standard::core::type::byte_field &_data) override;
 
     private:
 
-      ls::std::io::SerializableSectionPairParameter parameter{};
+      ls::standard::io::SerializableSectionPairParameter parameter{};
 
       [[nodiscard]] ::std::string _marshalKey() const;
-      void _unmarshalListValue(const ls::std::core::type::byte_field &_data) const;
-      void _unmarshalSingleValue(const ls::std::core::type::byte_field &_data) const;
+      void _unmarshalListValue(const ls::standard::core::type::byte_field &_data) const;
+      void _unmarshalSingleValue(const ls::standard::core::type::byte_field &_data) const;
   };
 }
 

include/ls-std/io/section-pair/serialization/SerializableSectionPairRowListValue.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-11
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -22,25 +23,25 @@
  * @doc: io.SerializableSectionPairRowListValue.description('This class can serialize a Section Pair row list value for file persistence.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SerializableSectionPairRowListValue : public ls::std::core::interface_type::ISerializable, public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL SerializableSectionPairRowListValue : public ls::standard::core::interface_type::ISerializable, public ls::standard::core::Class
   {
     public:
 
-      explicit SerializableSectionPairRowListValue(const ls::std::io::SerializableSectionPairParameter &_parameter);
+      explicit SerializableSectionPairRowListValue(const ls::standard::io::SerializableSectionPairParameter &_parameter);
       ~SerializableSectionPairRowListValue() noexcept override;
 
-      [[nodiscard]] ::std::shared_ptr<ls::std::core::Class> getValue() const;
-      [[nodiscard]] ls::std::core::type::byte_field marshal() override;
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      [[nodiscard]] ::std::shared_ptr<ls::standard::core::Class> getValue() const;
+      [[nodiscard]] ls::standard::core::type::byte_field marshal() override;
+      void unmarshal(const ls::standard::core::type::byte_field &_data) override;
 
     private:
 
-      ls::std::io::SerializableSectionPairParameter parameter{};
+      ls::standard::io::SerializableSectionPairParameter parameter{};
 
       [[nodiscard]] static ::std::string _getLine(::std::string::size_type _position, ::std::string_view _searchText);
-      void _updateSearchText(::std::string::size_type _position, ls::std::core::type::byte_field &_searchText) const;
+      void _updateSearchText(::std::string::size_type _position, ls::standard::core::type::byte_field &_searchText) const;
   };
 }
 

include/ls-std/io/section-pair/serialization/SerializableSectionPairRowSingleValue.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-11
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -21,22 +22,22 @@
  * @doc: io.SerializableSectionPairRowSingleValue.description('This class can serialize a Section Pair single value for file persistence.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SerializableSectionPairRowSingleValue : public ls::std::core::interface_type::ISerializable, public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL SerializableSectionPairRowSingleValue : public ls::standard::core::interface_type::ISerializable, public ls::standard::core::Class
   {
     public:
 
-      explicit SerializableSectionPairRowSingleValue(const ls::std::io::SerializableSectionPairParameter &_parameter);
+      explicit SerializableSectionPairRowSingleValue(const ls::standard::io::SerializableSectionPairParameter &_parameter);
       ~SerializableSectionPairRowSingleValue() noexcept override;
 
-      [[nodiscard]] ::std::shared_ptr<ls::std::core::Class> getValue() const;
-      [[nodiscard]] ls::std::core::type::byte_field marshal() override;
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      [[nodiscard]] ::std::shared_ptr<ls::standard::core::Class> getValue() const;
+      [[nodiscard]] ls::standard::core::type::byte_field marshal() override;
+      void unmarshal(const ls::standard::core::type::byte_field &_data) override;
 
     private:
 
-      ls::std::io::SerializableSectionPairParameter parameter{};
+      ls::standard::io::SerializableSectionPairParameter parameter{};
   };
 }
 

include/ls-std/io/section-pair/serialization/SerializableSectionPairSection.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-14
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -22,37 +23,37 @@
  * @doc: io.SerializableSectionPairSection.description('This class can serialize a Section Pair section for file persistence.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SerializableSectionPairSection : public ls::std::core::interface_type::ISerializable, public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL SerializableSectionPairSection : public ls::standard::core::interface_type::ISerializable, public ls::standard::core::Class
   {
     public:
 
-      explicit SerializableSectionPairSection(const ls::std::io::SerializableSectionPairParameter &_parameter);
+      explicit SerializableSectionPairSection(const ls::standard::io::SerializableSectionPairParameter &_parameter);
       ~SerializableSectionPairSection() noexcept override;
 
-      [[nodiscard]] ::std::shared_ptr<ls::std::core::Class> getValue() const;
-      [[nodiscard]] ls::std::core::type::byte_field marshal() override;
-      void unmarshal(const ls::std::core::type::byte_field &_data) override;
+      [[nodiscard]] ::std::shared_ptr<ls::standard::core::Class> getValue() const;
+      [[nodiscard]] ls::standard::core::type::byte_field marshal() override;
+      void unmarshal(const ls::standard::core::type::byte_field &_data) override;
 
     private:
 
-      ls::std::io::SerializableSectionPairParameter parameter{};
+      ls::standard::io::SerializableSectionPairParameter parameter{};
 
-      [[nodiscard]] ls::std::core::type::byte_field _collectSectionRow(const ls::std::core::type::byte_field &_currentRows, ls::std::io::SectionPairRowEnumType &_type) const;
-      [[nodiscard]] ls::std::core::type::byte_field _collectSectionListValueRow(const core::type::byte_field &_currentRows, ls::std::io::SectionPairRowEnumType &_type) const;
-      [[nodiscard]] static core::type::byte_field _collectSectionSingleValueRow(const ls::std::core::type::byte_field &_firstRow, ls::std::io::SectionPairRowEnumType &type);
+      [[nodiscard]] ls::standard::core::type::byte_field _collectSectionRow(const ls::standard::core::type::byte_field &_currentRows, ls::standard::io::SectionPairRowEnumType &_type) const;
+      [[nodiscard]] ls::standard::core::type::byte_field _collectSectionListValueRow(const core::type::byte_field &_currentRows, ls::standard::io::SectionPairRowEnumType &_type) const;
+      [[nodiscard]] static core::type::byte_field _collectSectionSingleValueRow(const ls::standard::core::type::byte_field &_firstRow, ls::standard::io::SectionPairRowEnumType &type);
       [[nodiscard]] static size_t _getNthSubStringPosition(::std::string_view _text, ::std::string_view _subText);
-      [[nodiscard]] ls::std::core::type::byte_field _getSectionHeader(const ls::std::core::type::byte_field &_data) const;
-      [[nodiscard]] static ls::std::core::type::byte_field _getSectionId(::std::string_view _sectionHeader);
+      [[nodiscard]] ls::standard::core::type::byte_field _getSectionHeader(const ls::standard::core::type::byte_field &_data) const;
+      [[nodiscard]] static ls::standard::core::type::byte_field _getSectionId(::std::string_view _sectionHeader);
       [[nodiscard]] static bool _isListValueRow(::std::string_view _currentRow);
       [[nodiscard]] static bool _isStartingValueRow(const ::std::string &_currentRow);
       [[nodiscard]] static bool _isSingleValueRow(::std::string_view _currentRow);
-      [[nodiscard]] ls::std::core::type::byte_field _marshalRows() const;
-      [[nodiscard]] ls::std::core::type::byte_field _marshalSectionId() const;
-      void _unmarshalRow(const ::std::string &_sectionRow, ls::std::io::SectionPairRowEnumType _type) const;
-      void _unmarshalRows(const ls::std::core::type::byte_field &_serializedRows) const;
-      [[nodiscard]] size_t _unmarshalSectionHeader(const ls::std::core::type::byte_field &_data) const;
+      [[nodiscard]] ls::standard::core::type::byte_field _marshalRows() const;
+      [[nodiscard]] ls::standard::core::type::byte_field _marshalSectionId() const;
+      void _unmarshalRow(const ::std::string &_sectionRow, ls::standard::io::SectionPairRowEnumType _type) const;
+      void _unmarshalRows(const ls::standard::core::type::byte_field &_serializedRows) const;
+      [[nodiscard]] size_t _unmarshalSectionHeader(const ls::standard::core::type::byte_field &_data) const;
   };
 }
 

include/ls-std/io/section-pair/type/SectionPairDocumentTypes.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-15
-* Changed:         2023-02-15
+* Changed:         2026-06-23
 *
 * */
 
@@ -14,10 +15,10 @@
 #include <ls-std/io/section-pair/model/SectionPairSection.hpp>
 #include <memory>
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  using section_pair_document_section_list_element = ::std::shared_ptr<ls::std::io::SectionPairSection>;
-  using section_pair_document_section_list = ::std::list<ls::std::io::section_pair_document_section_list_element>;
+  using section_pair_document_section_list_element = ::std::shared_ptr<ls::standard::io::SectionPairSection>;
+  using section_pair_document_section_list = ::std::list<ls::standard::io::section_pair_document_section_list_element>;
 }
 
 #endif

include/ls-std/io/section-pair/type/SectionPairSectionTypes.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-13
-* Changed:         2023-02-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -14,10 +15,10 @@
 #include <ls-std/io/section-pair/model/SectionPairRow.hpp>
 #include <memory>
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  using section_pair_row_list_element = ::std::shared_ptr<ls::std::io::SectionPairRow>;
-  using section_pair_row_list = ::std::list<ls::std::io::section_pair_row_list_element>;
+  using section_pair_row_list_element = ::std::shared_ptr<ls::standard::io::SectionPairRow>;
+  using section_pair_row_list = ::std::list<ls::standard::io::section_pair_row_list_element>;
 }
 
 #endif

include/ls-std/io/section-pair/validator/SectionPairDocumentValidator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,9 +21,9 @@
  * @doc: io.SectionPairDocumentValidator.description('This validator checks whether a content is a valid Section Pair document.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairDocumentValidator : public ls::std::core::Class, public ls::std::core::interface_type::IValidator
+  class LS_STD_DYNAMIC_GOAL SectionPairDocumentValidator : public ls::standard::core::Class, public ls::standard::core::interface_type::IValidator
   {
     public:
 

include/ls-std/io/section-pair/validator/SectionPairFileExtensionValidator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,9 +21,9 @@
  * @doc: io.SectionPairFileExtensionValidator.description('This validator checks whether a file name has a valid Section Pair file extension.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairFileExtensionValidator : public ls::std::core::Class, public ls::std::core::interface_type::IValidator
+  class LS_STD_DYNAMIC_GOAL SectionPairFileExtensionValidator : public ls::standard::core::Class, public ls::standard::core::interface_type::IValidator
   {
     public:
 

include/ls-std/io/section-pair/validator/SectionPairIdentifierValidator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-09
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -21,13 +22,13 @@
  * @doc: io.SectionPairIdentifierValidator.description('This validator checks whether a string is a valid Section Pair identifier.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairIdentifierValidator : public ls::std::core::Class, public ls::std::core::interface_type::IValidator
+  class LS_STD_DYNAMIC_GOAL SectionPairIdentifierValidator : public ls::standard::core::Class, public ls::standard::core::interface_type::IValidator
   {
     public:
 
-      explicit SectionPairIdentifierValidator(ls::std::io::section_pair_identifier _identifier);
+      explicit SectionPairIdentifierValidator(ls::standard::io::section_pair_identifier _identifier);
       ~SectionPairIdentifierValidator() noexcept override;
 
       [[nodiscard]] static ::std::string getValidationRegex();
@@ -35,7 +36,7 @@ namespace ls::std::io
 
     private:
 
-      ls::std::io::section_pair_identifier identifier{};
+      ls::standard::io::section_pair_identifier identifier{};
 
       [[nodiscard]] static ::std::string _getValidationRegex();
   };

include/ls-std/io/section-pair/validator/SectionPairRowListValueValidator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-19
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,9 +21,9 @@
  * @doc: io.SectionPairRowListValueValidator.description('This validator checks whether a content is a valid Section Pair row list value.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairRowListValueValidator : public ls::std::core::Class, public ls::std::core::interface_type::IValidator
+  class LS_STD_DYNAMIC_GOAL SectionPairRowListValueValidator : public ls::standard::core::Class, public ls::standard::core::interface_type::IValidator
   {
     public:
 

include/ls-std/io/section-pair/validator/SectionPairRowSingleValueValidator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-19
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -19,9 +20,9 @@
  * @doc: io.SectionPairRowSingleValueValidator.description('This validator checks whether a content is a valid Section Pair row single value.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairRowSingleValueValidator : public ls::std::core::Class, public ls::std::core::interface_type::IValidator
+  class LS_STD_DYNAMIC_GOAL SectionPairRowSingleValueValidator : public ls::standard::core::Class, public ls::standard::core::interface_type::IValidator
   {
     public:
 

include/ls-std/io/section-pair/validator/SectionPairRowValidator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,9 +21,9 @@
  * @doc: io.SectionPairRowValidator.description('This validator checks whether a content is a valid Section Pair row.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairRowValidator : public ls::std::core::Class, public ls::std::core::interface_type::IValidator
+  class LS_STD_DYNAMIC_GOAL SectionPairRowValidator : public ls::standard::core::Class, public ls::standard::core::interface_type::IValidator
   {
     public:
 

include/ls-std/io/section-pair/validator/SectionPairSectionValidator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -20,9 +21,9 @@
  * @doc: io.SectionPairSectionValidator.description('This validator checks whether a content is a valid Section Pair section.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairSectionValidator : public ls::std::core::Class, public ls::std::core::interface_type::IValidator
+  class LS_STD_DYNAMIC_GOAL SectionPairSectionValidator : public ls::standard::core::Class, public ls::standard::core::interface_type::IValidator
   {
     public:
 

include/ls-std/io/section-pair/validator/SectionPairValueValidator.hpp

@@ -1,9 +1,10 @@
 /*
 * Author:          Patrick-Christopher Mattulat
+* Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-09
-* Changed:         2024-09-13
+* Changed:         2026-06-23
 *
 * */
 
@@ -21,13 +22,13 @@
  * @doc: io.SectionPairValueValidator.description('This validator checks whether a content is a valid Section Pair value.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL SectionPairValueValidator : public ls::std::core::Class, public ls::std::core::interface_type::IValidator
+  class LS_STD_DYNAMIC_GOAL SectionPairValueValidator : public ls::standard::core::Class, public ls::standard::core::interface_type::IValidator
   {
     public:
 
-      explicit SectionPairValueValidator(ls::std::io::section_pair_row_value _value);
+      explicit SectionPairValueValidator(ls::standard::io::section_pair_row_value _value);
       ~SectionPairValueValidator() noexcept override;
 
       [[nodiscard]] static ::std::string getValidationRegex();
@@ -35,7 +36,7 @@ namespace ls::std::io
 
     private:
 
-      ls::std::io::section_pair_row_value value{};
+      ls::standard::io::section_pair_row_value value{};
 
       [[nodiscard]] static ::std::string _getValidationRegex();
   };

include/ls-std/io/xml/XmlAttribute.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-23
- * Changed:         2024-09-13
+ * Changed:         2026-06-23
  *
  * */
 
@@ -19,9 +20,9 @@
  * @doc: io.XmlAttribute.description('This class represents an XML attribute and can be serialized to an XML tag.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL XmlAttribute : public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL XmlAttribute : public ls::standard::core::Class
   {
     public:
 

include/ls-std/io/xml/XmlDeclaration.hpp

@@ -1,9 +1,10 @@
 /*
  * Author:          Patrick-Christopher Mattulat
+ * Co-Author:       Claude Sonnet 4.6 (LLM)
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2024-09-13
+ * Changed:         2026-06-23
  *
  * */
 
@@ -19,9 +20,9 @@
  * @doc: io.XmlDeclaration.description('This class represents an XML declaration and can be serialized to an XML tag.')
  * */
 
-namespace ls::std::io
+namespace ls::standard::io
 {
-  class LS_STD_DYNAMIC_GOAL XmlDeclaration : public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL XmlDeclaration : public ls::standard::core::Class
   {
     public:
 
@@ -38,11 +39,11 @@ namespace ls::std::io
 
     private:
 
-      ls::std::io::XmlAttribute encoding{"encoding"};
-      ls::std::io::XmlAttribute standalone{"standalone"};
-      ls::std::io::XmlAttribute version{"version"};
+      ls::standard::io::XmlAttribute encoding{"encoding"};
+      ls::standard::io::XmlAttribute standalone{"standalone"};
+      ls::standard::io::XmlAttribute version{"version"};
 
-      [[nodiscard]] static ::std::string _toXmlAttribute(const ls::std::io::XmlAttribute &_attribute);
+      [[nodiscard]] static ::std::string _toXmlAttribute(const ls::standard::io::XmlAttribute &_attribute);
   };
 }