Merge branch 'master' of public/ls-standard-library into development

.clang-tidy

@@ -0,0 +1,147 @@
+# Generated from CLion Inspection settings
+---
+Checks: '-*,
+bugprone-argument-comment,
+bugprone-assert-side-effect,
+bugprone-bad-signal-to-kill-thread,
+bugprone-branch-clone,
+bugprone-copy-constructor-init,
+bugprone-dangling-handle,
+bugprone-dynamic-static-initializers,
+bugprone-fold-init-type,
+bugprone-forward-declaration-namespace,
+bugprone-forwarding-reference-overload,
+bugprone-inaccurate-erase,
+bugprone-incorrect-roundings,
+bugprone-integer-division,
+bugprone-lambda-function-name,
+bugprone-macro-parentheses,
+bugprone-macro-repeated-side-effects,
+bugprone-misplaced-operator-in-strlen-in-alloc,
+bugprone-misplaced-pointer-arithmetic-in-alloc,
+bugprone-misplaced-widening-cast,
+bugprone-move-forwarding-reference,
+bugprone-multiple-statement-macro,
+bugprone-no-escape,
+bugprone-not-null-terminated-result,
+bugprone-parent-virtual-call,
+bugprone-posix-return,
+bugprone-reserved-identifier,
+bugprone-sizeof-container,
+bugprone-sizeof-expression,
+bugprone-spuriously-wake-up-functions,
+bugprone-string-constructor,
+bugprone-string-integer-assignment,
+bugprone-string-literal-with-embedded-nul,
+bugprone-suspicious-enum-usage,
+bugprone-suspicious-include,
+bugprone-suspicious-memory-comparison,
+bugprone-suspicious-memset-usage,
+bugprone-suspicious-missing-comma,
+bugprone-suspicious-semicolon,
+bugprone-suspicious-string-compare,
+bugprone-swapped-arguments,
+bugprone-terminating-continue,
+bugprone-throw-keyword-missing,
+bugprone-too-small-loop-variable,
+bugprone-undefined-memory-manipulation,
+bugprone-undelegated-constructor,
+bugprone-unhandled-self-assignment,
+bugprone-unused-raii,
+bugprone-unused-return-value,
+bugprone-use-after-move,
+bugprone-virtual-near-miss,
+cert-dcl21-cpp,
+cert-dcl58-cpp,
+cert-err34-c,
+cert-err52-cpp,
+cert-err60-cpp,
+cert-flp30-c,
+cert-msc50-cpp,
+cert-msc51-cpp,
+cert-str34-c,
+cppcoreguidelines-interfaces-global-init,
+cppcoreguidelines-narrowing-conversions,
+cppcoreguidelines-pro-type-member-init,
+cppcoreguidelines-pro-type-static-cast-downcast,
+cppcoreguidelines-slicing,
+google-default-arguments,
+google-explicit-constructor,
+google-runtime-operator,
+hicpp-exception-baseclass,
+hicpp-multiway-paths-covered,
+misc-misplaced-const,
+misc-new-delete-overloads,
+misc-no-recursion,
+misc-non-copyable-objects,
+misc-throw-by-value-catch-by-reference,
+misc-unconventional-assign-operator,
+misc-uniqueptr-reset-release,
+modernize-avoid-bind,
+modernize-concat-nested-namespaces,
+modernize-deprecated-headers,
+modernize-deprecated-ios-base-aliases,
+modernize-loop-convert,
+modernize-make-shared,
+modernize-make-unique,
+modernize-pass-by-value,
+modernize-raw-string-literal,
+modernize-redundant-void-arg,
+modernize-replace-auto-ptr,
+modernize-replace-disallow-copy-and-assign-macro,
+modernize-replace-random-shuffle,
+modernize-return-braced-init-list,
+modernize-shrink-to-fit,
+modernize-unary-static-assert,
+modernize-use-auto,
+modernize-use-bool-literals,
+modernize-use-emplace,
+modernize-use-equals-default,
+modernize-use-equals-delete,
+modernize-use-nodiscard,
+modernize-use-noexcept,
+modernize-use-nullptr,
+modernize-use-override,
+modernize-use-transparent-functors,
+modernize-use-uncaught-exceptions,
+mpi-buffer-deref,
+mpi-type-mismatch,
+openmp-use-default-none,
+performance-faster-string-find,
+performance-for-range-copy,
+performance-implicit-conversion-in-loop,
+performance-inefficient-algorithm,
+performance-inefficient-string-concatenation,
+performance-inefficient-vector-operation,
+performance-move-const-arg,
+performance-move-constructor-init,
+performance-no-automatic-move,
+performance-noexcept-move-constructor,
+performance-trivially-destructible,
+performance-type-promotion-in-math-fn,
+performance-unnecessary-copy-initialization,
+performance-unnecessary-value-param,
+portability-simd-intrinsics,
+readability-avoid-const-params-in-decls,
+readability-const-return-type,
+readability-container-size-empty,
+readability-convert-member-functions-to-static,
+readability-delete-null-pointer,
+readability-deleted-default,
+readability-inconsistent-declaration-parameter-name,
+readability-make-member-function-const,
+readability-misleading-indentation,
+readability-misplaced-array-index,
+readability-non-const-parameter,
+readability-redundant-control-flow,
+readability-redundant-declaration,
+readability-redundant-function-ptr-dereference,
+readability-redundant-smartptr-get,
+readability-redundant-string-cstr,
+readability-redundant-string-init,
+readability-simplify-subscript-expr,
+readability-static-accessed-through-instance,
+readability-static-definition-in-anonymous-namespace,
+readability-string-compare,
+readability-uniqueptr-delete-release,
+readability-use-anyofallof'

CMakeLists.txt

@@ -527,6 +527,7 @@ endif ()
 
 if (${LS_STD_BUILD_SHARED})
     add_library("${MODULE_NAME_ENCODING}" SHARED ${SOURCE_FILES_ENCODING})
+    target_link_libraries("${MODULE_NAME_ENCODING}" ${MODULE_NAME_CORE})
     set_target_properties("${MODULE_NAME_ENCODING}" PROPERTIES DEBUG_POSTFIX "-d")
 endif ()
 

README.md

@@ -47,8 +47,11 @@ A __Date__ class comes with this submodule, which you can use to represent a dat
 
 - __logic__ module has been removed from this library and can now be found in __ls-game-tool-kit__ library
 - __core.utils__ module has been removed from this library to provide more clean implementations where it's needed
-- namespaces have been completely removed from module tests to improve readability
-- a new naming convention for files and directories has been introduced, where underscores were replaced by dashes entirely
+- the complexity of source files has been reduced by declaring usages of namespaces at the file beginning sections
+  instead of using those in every definition implementation, this overall improves the readability of the libraries
+  source files
+- a new naming convention for files and directories has been introduced, where underscores were replaced by dashes
+  entirely
 - fetching the library version can now be achieved by using a dedicated __LibraryVersion__ class - the usage of a static function for this purpose has been removed completely
 - missing nodiscard attributes have been added to library classes
 - rename "types" folder in __core__ submodule to stick to naming convention

config/clion-lynar-studios-analysis-profile.xml

@@ -0,0 +1,20 @@
+<profile version="1.0">
+    <option name="myName" value="lynar-studios-analysis-profile"/>
+    <option name="scopesOrder">
+        <list>
+            <option value="All Changed Files"/>
+            <option value="Open Files"/>
+            <option value="Project Files"/>
+            <option value="Project Non-Source Files"/>
+            <option value="Project Source Files"/>
+            <option value="Scratches and Consoles"/>
+            <option value="ls-std"/>
+        </list>
+    </option>
+    <inspection_tool class="Cppcheck" enabled="true" level="WARNING" enabled_by_default="false">
+        <scope name="ls-std" level="WARNING" enabled="true"/>
+    </inspection_tool>
+    <inspection_tool class="UnusedValue" enabled="true" level="WARNING" enabled_by_default="true">
+        <option name="showUnusedInitializers" value="false"/>
+    </inspection_tool>
+</profile>

config/lynar-studios-analysis-profile.xml

@@ -1,9 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="lynar-studios-analysis-profile" />
-    <inspection_tool class="Cppcheck" enabled="false" level="WARNING" enabled_by_default="false" />
-    <inspection_tool class="UnusedValue" enabled="true" level="WARNING" enabled_by_default="true">
-      <option name="showUnusedInitializers" value="false" />
-    </inspection_tool>
-  </profile>
-</component>

include/ls-std/boxing/Boolean.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -24,11 +24,7 @@ namespace ls::std::boxing
 
       explicit Boolean(bool _value);
       Boolean();
-      ~Boolean() override;
-
-      // conversion operator
-
-      operator bool() const;
+      ~Boolean() noexcept override;
 
       // assignment operators
 

include/ls-std/boxing/Double.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -23,11 +23,7 @@ namespace ls::std::boxing
 
       Double();
       explicit Double(double _value);
-      ~Double() override;
-
-      // conversion operator
-
-      operator double() const; // do not make explicit!
+      ~Double() noexcept override;
 
       // assignment operators
 
@@ -83,8 +79,8 @@ namespace ls::std::boxing
 
       // additional functionality
 
-      [[nodiscard]] double getEpsilon();
-      [[nodiscard]] double getValue();
+      [[nodiscard]] double getEpsilon() const;
+      [[nodiscard]] double getValue() const;
       void setEpsilon(double _epsilon);
 
     private:

include/ls-std/boxing/Float.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -23,11 +23,7 @@ namespace ls::std::boxing
 
       Float();
       explicit Float(float _value);
-      ~Float() override;
-
-      // conversion operator
-
-      operator float() const; // do not make explicit!
+      ~Float() noexcept override;
 
       // assignment operators
 
@@ -83,8 +79,8 @@ namespace ls::std::boxing
 
       // additional functionality
 
-      [[nodiscard]] float getEpsilon();
-      [[nodiscard]] float getValue();
+      [[nodiscard]] float getEpsilon() const;
+      [[nodiscard]] float getValue() const;
       void setEpsilon(float _epsilon);
 
     private:

include/ls-std/boxing/Integer.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -23,11 +23,7 @@ namespace ls::std::boxing
 
       explicit Integer(int _value);
       Integer();
-      ~Integer() override;
-
-      // conversion operator
-
-      operator int() const;
+      ~Integer() noexcept override;
 
       // assignment operators
 

include/ls-std/boxing/Long.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2023-02-08
+ * Changed:         2023-02-22
  *
  * */
 
@@ -24,11 +24,7 @@ namespace ls::std::boxing
 
       explicit Long(ls::std::core::type::long_type _value);
       Long();
-      ~Long() override;
-
-      // conversion operator
-
-      operator ls::std::core::type::long_type() const;
+      ~Long() noexcept override;
 
       // assignment operators
 

include/ls-std/boxing/String.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2023-02-08
+ * Changed:         2023-02-23
  *
  * */
 
@@ -26,12 +26,7 @@ namespace ls::std::boxing
 
       String();
       explicit String(::std::string _value);
-      ~String() override;
-
-      // conversion operator
-
-      operator const char *() const;  // do not make explicit!
-      operator ::std::string() const; // do not make explicit!
+      ~String() noexcept override;
 
       // assignment operators
 
@@ -69,7 +64,7 @@ namespace ls::std::boxing
       [[nodiscard]] bool endsWith(const ::std::string &_text);
       [[nodiscard]] bool equalsIgnoreCase(ls::std::boxing::String _string);
       [[nodiscard]] bool equalsIgnoreCase(::std::string _text);
-      [[nodiscard]] ::std::vector<ls::std::core::type::byte> getByteData();
+      [[nodiscard]] ::std::vector<ls::std::core::type::byte_type> getByteData();
       [[nodiscard]] ::std::string padLeft(size_t _width, char _fillCharacter);
       [[nodiscard]] ::std::string padRight(size_t _width, char _fillCharacter);
       [[nodiscard]] ::std::string reverse();

include/ls-std/core/Version.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2023-02-08
+ * Changed:         2023-02-22
  *
  * */
 
@@ -22,7 +22,7 @@ namespace ls::std::core
     public:
 
       explicit Version(ls::std::core::type::version_type _majorVersion, ls::std::core::type::version_type _minorVersion, ls::std::core::type::version_type _patchVersion);
-      ~Version() override;
+      ~Version() noexcept override;
 
       // implementation
 

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-02-08
+* Changed:         2023-02-22
 *
 * */
 
@@ -11,17 +11,18 @@
 #define LS_STD_EMPTY_STRING_ARGUMENT_EVALUATOR_HPP
 
 #include <ls-std/core/interface/IEvaluator.hpp>
+#include <ls-std/os/dynamic-goal.hpp>
 #include <string>
 
 namespace ls::std::core
 {
-  class EmptyStringArgumentEvaluator : public ls::std::core::interface_type::IEvaluator
+  class LS_STD_DYNAMIC_GOAL EmptyStringArgumentEvaluator : public ls::std::core::interface_type::IEvaluator
   {
     public:
 
       explicit EmptyStringArgumentEvaluator(::std::string _argument);
       explicit EmptyStringArgumentEvaluator(::std::string _argument, ::std::string _message);
-      ~EmptyStringArgumentEvaluator() override;
+      ~EmptyStringArgumentEvaluator() noexcept override;
 
       void evaluate() override;
 

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2023-02-10
+* Changed:         2023-02-22
 *
 * */
 
@@ -11,17 +11,18 @@
 #define LS_STD_INDEX_OUT_OF_BOUNDS_EVALUATOR_EVALUATOR_HPP
 
 #include <ls-std/core/interface/IEvaluator.hpp>
+#include <ls-std/os/dynamic-goal.hpp>
 #include <string>
 
 namespace ls::std::core
 {
-  class IndexOutOfBoundsEvaluator : public ls::std::core::interface_type::IEvaluator
+  class LS_STD_DYNAMIC_GOAL IndexOutOfBoundsEvaluator : public ls::std::core::interface_type::IEvaluator
   {
     public:
 
       explicit IndexOutOfBoundsEvaluator(size_t _index, size_t _size);
       explicit IndexOutOfBoundsEvaluator(size_t _index, size_t _size, ::std::string _message);
-      ~IndexOutOfBoundsEvaluator() override;
+      ~IndexOutOfBoundsEvaluator() noexcept override;
 
       void evaluate() override;
 

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-02-08
+* Changed:         2023-02-22
 *
 * */
 
@@ -11,18 +11,19 @@
 #define LS_STD_NULL_POINTER_ARGUMENT_EVALUATOR_HPP
 
 #include <ls-std/core/interface/IEvaluator.hpp>
+#include <ls-std/os/dynamic-goal.hpp>
 #include <memory>
 #include <string>
 
 namespace ls::std::core
 {
-  class NullPointerArgumentEvaluator : public ls::std::core::interface_type::IEvaluator
+  class LS_STD_DYNAMIC_GOAL NullPointerArgumentEvaluator : public ls::std::core::interface_type::IEvaluator
   {
     public:
 
-    explicit NullPointerArgumentEvaluator(const ::std::shared_ptr<void> &_argument);
-    explicit NullPointerArgumentEvaluator(const ::std::shared_ptr<void> &_argument, ::std::string _message);
-    ~NullPointerArgumentEvaluator() override;
+      explicit NullPointerArgumentEvaluator(const ::std::shared_ptr<void> &_argument);
+      explicit NullPointerArgumentEvaluator(const ::std::shared_ptr<void> &_argument, ::std::string _message);
+      ~NullPointerArgumentEvaluator() noexcept override;
 
       void evaluate() override;
 

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-02-10
+* Changed:         2023-02-22
 *
 * */
 
@@ -11,18 +11,19 @@
 #define LS_STD_NULL_POINTER_EVALUATOR_HPP
 
 #include <ls-std/core/interface/IEvaluator.hpp>
+#include <ls-std/os/dynamic-goal.hpp>
 #include <memory>
 #include <string>
 
 namespace ls::std::core
 {
-  class NullPointerEvaluator : public ls::std::core::interface_type::IEvaluator // TODO: add missing dynamic goal
+  class LS_STD_DYNAMIC_GOAL NullPointerEvaluator : public ls::std::core::interface_type::IEvaluator
   {
     public:
 
       explicit NullPointerEvaluator(const ::std::shared_ptr<void> &_argument);
       explicit NullPointerEvaluator(const ::std::shared_ptr<void> &_argument, ::std::string _message);
-      ~NullPointerEvaluator() override;
+      ~NullPointerEvaluator() noexcept override;
 
       void evaluate() override;
 

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

@@ -22,7 +22,7 @@ namespace ls::std::core
 
       EventNotHandledException();
       explicit EventNotHandledException(::std::string _message);
-      ~EventNotHandledException() override;
+      ~EventNotHandledException() noexcept override;
 
       [[nodiscard]] const char *what() const noexcept override;
   };

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

@@ -22,7 +22,7 @@ namespace ls::std::core
 
       EventNotSubscribedException();
       explicit EventNotSubscribedException(::std::string _message);
-      ~EventNotSubscribedException() override;
+      ~EventNotSubscribedException() noexcept override;
 
       [[nodiscard]] const char *what() const noexcept override;
   };

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

@@ -21,7 +21,7 @@ namespace ls::std::core
     public:
 
       explicit Exception(::std::string _name);
-      ~Exception() override;
+      ~Exception() noexcept override;
 
       [[nodiscard]] ::std::string getName() const;
       [[nodiscard]] const char *what() const noexcept override;

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

@@ -22,7 +22,7 @@ namespace ls::std::core
 
       FileNotFoundException();
       explicit FileNotFoundException(::std::string _message);
-      ~FileNotFoundException() override;
+      ~FileNotFoundException() noexcept override;
 
       [[nodiscard]] const char *what() const noexcept override;
   };

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

@@ -22,7 +22,7 @@ namespace ls::std::core
 
       FileOperationException();
       explicit FileOperationException(::std::string _message);
-      ~FileOperationException() override;
+      ~FileOperationException() noexcept override;
 
       [[nodiscard]] const char *what() const noexcept override;
   };

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

@@ -22,7 +22,7 @@ namespace ls::std::core
 
       IllegalArgumentException();
       explicit IllegalArgumentException(::std::string _message);
-      ~IllegalArgumentException() override;
+      ~IllegalArgumentException() noexcept override;
 
       [[nodiscard]] const char *what() const noexcept override;
   };

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

@@ -7,8 +7,8 @@
  *
  * */
 
-#ifndef LS_STD_ILLEGAL_OPERATION_EXCEPTION_HPP
-#define LS_STD_ILLEGAL_OPERATION_EXCEPTION_HPP
+#ifndef LS_STD_ILLEGAL_ARITHMETIC_OPERATION_EXCEPTION_HPP
+#define LS_STD_ILLEGAL_ARITHMETIC_OPERATION_EXCEPTION_HPP
 
 #include <ls-std/core/exception/Exception.hpp>
 #include <ls-std/os/dynamic-goal.hpp>
@@ -22,7 +22,7 @@ namespace ls::std::core
 
       IllegalArithmeticOperationException();
       explicit IllegalArithmeticOperationException(::std::string _message);
-      ~IllegalArithmeticOperationException() override;
+      ~IllegalArithmeticOperationException() noexcept override;
 
       [[nodiscard]] const char *what() const noexcept override;
   };

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

@@ -22,7 +22,7 @@ namespace ls::std::core
 
       IncompleteJsonException();
       explicit IncompleteJsonException(::std::string _message);
-      ~IncompleteJsonException() override;
+      ~IncompleteJsonException() noexcept override;
 
       [[nodiscard]] const char *what() const noexcept override;
   };

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

@@ -22,7 +22,7 @@ namespace ls::std::core
 
       IndexOutOfBoundsException();
       explicit IndexOutOfBoundsException(::std::string _message);
-      ~IndexOutOfBoundsException() override;
+      ~IndexOutOfBoundsException() noexcept override;
 
       [[nodiscard]] const char *what() const noexcept override;
   };

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

@@ -22,7 +22,7 @@ namespace ls::std::core
 
       NullPointerException();
       explicit NullPointerException(::std::string _message);
-      ~NullPointerException() override;
+      ~NullPointerException() noexcept override;
 
       [[nodiscard]] const char *what() const noexcept override;
   };

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

@@ -1,21 +0,0 @@
-/*
- * Author:          Patrick-Christopher Mattulat
- * Company:         Lynar Studios
- * E-Mail:          webmaster@lynarstudios.com
- * Created:         2020-12-25
- * Changed:         2023-02-08
- *
- * */
-
-#ifndef LS_STD_KV_TYPES_HPP
-#define LS_STD_KV_TYPES_HPP
-
-#include <string>
-
-namespace ls::std::core::type
-{
-  using kv_key = ::std::string;
-  using kv_value = ::std::string;
-}
-
-#endif

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2023-02-08
+ * Changed:         2023-02-23
  *
  * */
 
@@ -15,7 +15,7 @@
 
 namespace ls::std::core::type
 {
-  using byte = char;
+  using byte_type = char;
   using byte_field = ::std::string;
   using long_type = long long int;
   using version_type = uint16_t;

include/ls-std/encoding/Base64.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-01-03
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -23,7 +23,7 @@ namespace ls::std::encoding
     public:
 
       Base64();
-      ~Base64() override;
+      ~Base64() noexcept override;
 
       // implementation
 

include/ls-std/event/Event.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2023-02-08
+ * Changed:         2023-02-22
  *
  * */
 
@@ -23,7 +23,7 @@ namespace ls::std::event
     public:
 
       explicit Event(const ls::std::core::type::event_id &_id);
-      ~Event() override;
+      ~Event() noexcept override;
 
       // additional functionality
 

include/ls-std/event/EventHandler.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -25,7 +25,7 @@ namespace ls::std::event
     public:
 
       explicit EventHandler(const ls::std::core::type::event_id &_id);
-      ~EventHandler() override;
+      ~EventHandler() noexcept override;
 
       [[nodiscard]] ls::std::core::type::event_id getId();
 

include/ls-std/event/EventManager.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2023-02-08
+ * Changed:         2023-02-22
  *
  * */
 
@@ -25,7 +25,7 @@ namespace ls::std::event
     public:
 
       explicit EventManager();
-      ~EventManager() override;
+      ~EventManager() noexcept override;
 
       // implementation
 

include/ls-std/event/Narrator.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -23,7 +23,7 @@ namespace ls::std::event
     public:
 
       Narrator();
-      ~Narrator() override;
+      ~Narrator() noexcept override;
 
       bool addListener(const ::std::shared_ptr<ls::std::core::interface_type::IListener> &_listener); // nodiscard is optional here
       void clear();

include/ls-std/event/serialization/SerializableJsonEvent.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-07
- * Changed:         2023-02-08
+ * Changed:         2023-02-22
  *
  * */
 
@@ -24,7 +24,7 @@ namespace ls::std::event
     public:
 
       explicit SerializableJsonEvent(const ::std::shared_ptr<ls::std::event::Event> &_value);
-      ~SerializableJsonEvent() override;
+      ~SerializableJsonEvent() noexcept override;
 
       // implementation
 

include/ls-std/io/File.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2023-02-18
+ * Changed:         2023-02-22
  *
  * */
 
@@ -30,7 +30,7 @@ namespace ls::std::io
     public:
 
       explicit File(::std::string _absoluteFilePath);
-      ~File() override;
+      ~File() noexcept override;
 
       // comparison operators
 

include/ls-std/io/FileOutputStream.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -24,7 +24,7 @@ namespace ls::std::io
 
       explicit FileOutputStream(ls::std::io::File &_file);
       explicit FileOutputStream(ls::std::io::File &_file, bool _append);
-      ~FileOutputStream() override;
+      ~FileOutputStream() noexcept override;
 
       void close();
       bool write(const ls::std::core::type::byte_field &_data) override; // nodiscard is optional here

include/ls-std/io/FilePathSeparator.hpp

@@ -3,12 +3,12 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
-#ifndef FILE_PATH_SEPARATOR_HPP
-#define FILE_PATH_SEPARATOR_HPP
+#ifndef LS_STD_FILE_PATH_SEPARATOR_HPP
+#define LS_STD_FILE_PATH_SEPARATOR_HPP
 
 #include <ls-std/os/dynamic-goal.hpp>
 #include <string>

include/ls-std/io/FilePathSeparatorMatch.hpp

@@ -3,12 +3,12 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2023-02-05
+ * Changed:         2023-02-22
  *
  * */
 
-#ifndef LS_STD_FILE_PATH_MATCH_HPP
-#define LS_STD_FILE_PATH_MATCH_HPP
+#ifndef LS_STD_FILE_PATH_SEPARATOR_MATCH_HPP
+#define LS_STD_FILE_PATH_SEPARATOR_MATCH_HPP
 
 #include <ls-std/os/dynamic-goal.hpp>
 

include/ls-std/io/FileReader.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -22,7 +22,7 @@ namespace ls::std::io
     public:
 
       explicit FileReader(ls::std::io::File &_file);
-      ~FileReader() override;
+      ~FileReader() noexcept override;
 
       [[nodiscard]] ls::std::core::type::byte_field read() override;
       void reset(ls::std::io::File &_file);
@@ -30,8 +30,6 @@ namespace ls::std::io
     private:
 
       ls::std::io::File file;
-
-      static void _init(ls::std::io::File &_file);
   };
 }
 

include/ls-std/io/FileWriter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -22,7 +22,7 @@ namespace ls::std::io
     public:
 
       explicit FileWriter(ls::std::io::File &_file);
-      ~FileWriter() override;
+      ~FileWriter() noexcept override;
 
       void reset(ls::std::io::File &_file);
       bool write(const ls::std::core::type::byte_field &_data) override; // nodiscard is optional here
@@ -30,8 +30,6 @@ namespace ls::std::io
     private:
 
       ls::std::io::File file;
-
-      static void _init(ls::std::io::File &_file);
   };
 }
 

include/ls-std/io/StandardOutputWriter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-06
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -20,7 +20,7 @@ namespace ls::std::io
     public:
 
       StandardOutputWriter();
-      ~StandardOutputWriter() override;
+      ~StandardOutputWriter() noexcept override;
 
       bool write(const ls::std::core::type::byte_field &_data) override; // nodiscard is optional here
   };

include/ls-std/io/StorableFile.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -23,7 +23,7 @@ namespace ls::std::io
     public:
 
       explicit StorableFile(const ::std::string &_path);
-      ~StorableFile() override;
+      ~StorableFile() noexcept override;
 
       [[nodiscard]] ::std::shared_ptr<ls::std::io::File> getFile();
       [[nodiscard]] ls::std::core::type::byte_field load() override;

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2023-02-21
+* Changed:         2023-02-22
 *
 * */
 
@@ -22,7 +22,7 @@ namespace ls::std::io
     public:
 
       explicit FileExistenceEvaluator(::std::string _filePath);
-      ~FileExistenceEvaluator() override;
+      ~FileExistenceEvaluator() noexcept override;
 
       void evaluate() override;
 

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -23,9 +23,8 @@ namespace ls::std::io
 
       explicit LogLevel(const ls::std::io::LogLevelValue &_value);
       LogLevel();
-      ~LogLevel() override;
-
-      operator unsigned char() const;
+      ~LogLevel() noexcept override;
+      ;
       ls::std::io::LogLevel &operator=(const ls::std::io::LogLevelValue &_value);
       bool operator<(const ls::std::io::LogLevelValue &_value);
       bool operator<=(const ls::std::io::LogLevelValue &_value);
@@ -33,6 +32,7 @@ namespace ls::std::io
       bool operator>=(const ls::std::io::LogLevelValue &_value);
       bool operator==(const ls::std::io::LogLevelValue &_value);
 
+      [[nodiscard]] ls::std::io::LogLevelValue getValue();
       void setLogLevel(const ls::std::io::LogLevelValue &_value);
       void setLogLevel(const ::std::string &_value);
       [[nodiscard]] ::std::string toString() const;

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2023-02-06
+ * Changed:         2023-02-23
  *
  * */
 
@@ -25,16 +25,16 @@ namespace ls::std::io
     public:
 
       explicit Logger(const ::std::shared_ptr<ls::std::core::interface_type::IWriter> &_writer);
-      ~Logger() override;
+      ~Logger() noexcept override;
 
-      void debug(const ls::std::core::type::byte *_data);
-      void error(const ls::std::core::type::byte *_data);
-      void fatal(const ls::std::core::type::byte *_data);
+      void debug(const ls::std::core::type::byte_type *_data);
+      void error(const ls::std::core::type::byte_type *_data);
+      void fatal(const ls::std::core::type::byte_type *_data);
       [[nodiscard]] ls::std::io::LogLevel getLogLevel();
-      void info(const ls::std::core::type::byte *_data);
+      void info(const ls::std::core::type::byte_type *_data);
       void setLogLevel(const ls::std::io::LogLevelValue &_logLevelValue);
-      void trace(const ls::std::core::type::byte *_data);
-      void warn(const ls::std::core::type::byte *_data);
+      void trace(const ls::std::core::type::byte_type *_data);
+      void warn(const ls::std::core::type::byte_type *_data);
 
     private:
 
@@ -45,7 +45,7 @@ namespace ls::std::io
       [[nodiscard]] static ::std::string _buildCharacterChain(size_t _amount);
       [[nodiscard]] static ::std::string _createFillContent(const ::std::string &_text);
       [[nodiscard]] static ::std::string _generateTimeString(tm *_localTime);
-      void _log(const ls::std::core::type::byte *_data, const ls::std::io::LogLevel &_logLevel);
+      void _log(const ls::std::core::type::byte_type *_data, const ls::std::io::LogLevel &_logLevel);
       [[nodiscard]] static ::std::string _padRight(const ::std::string &_text);
   };
 }

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-09
-* Changed:         2023-02-19
+* Changed:         2023-02-22
 *
 * */
 
@@ -22,7 +22,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairIdentifierArgumentEvaluator(ls::std::io::section_pair_identifier _identifier);
-      ~SectionPairIdentifierArgumentEvaluator() override;
+      ~SectionPairIdentifierArgumentEvaluator() noexcept override;
 
       void evaluate() override;
 

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2023-02-20
+* Changed:         2023-02-22
 *
 * */
 
@@ -22,7 +22,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairRowArgumentEvaluator(::std::string _sectionPairRow);
-      ~SectionPairRowArgumentEvaluator() override;
+      ~SectionPairRowArgumentEvaluator() noexcept override;
 
       void evaluate() override;
 

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2023-02-20
+* Changed:         2023-02-22
 *
 * */
 
@@ -22,7 +22,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairRowListValueArgumentEvaluator(::std::string _listValueRow);
-      ~SectionPairRowListValueArgumentEvaluator() override;
+      ~SectionPairRowListValueArgumentEvaluator() noexcept override;
 
       void evaluate() override;
 

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-19
-* Changed:         2023-02-19
+* Changed:         2023-02-22
 *
 * */
 
@@ -22,7 +22,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairRowSingleValueArgumentEvaluator(::std::string _singleValueRow);
-      ~SectionPairRowSingleValueArgumentEvaluator() override;
+      ~SectionPairRowSingleValueArgumentEvaluator() noexcept override;
 
       void evaluate() override;
 

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2023-02-20
+* Changed:         2023-02-22
 *
 * */
 
@@ -22,7 +22,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairSectionArgumentEvaluator(::std::string _section);
-      ~SectionPairSectionArgumentEvaluator() override;
+      ~SectionPairSectionArgumentEvaluator() noexcept override;
 
       void evaluate() override;
 

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2023-02-19
+* Changed:         2023-02-22
 *
 * */
 
@@ -23,7 +23,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairValueArgumentEvaluator(ls::std::io::section_pair_row_value _value);
-      ~SectionPairValueArgumentEvaluator() override;
+      ~SectionPairValueArgumentEvaluator() noexcept override;
 
       void evaluate() override;
 

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-15
-* Changed:         2023-02-21
+* Changed:         2023-02-23
 *
 * */
 
@@ -24,14 +24,16 @@ namespace ls::std::io
     public:
 
       SectionPairDocument();
-      ~SectionPairDocument() override;
+      ~SectionPairDocument() noexcept override;
 
-      void add(const section_pair_document_section_list_element &_section);
+      void add(const ls::std::io::section_pair_document_section_list_element &_section);
       void clear();
-      [[nodiscard]] section_pair_document_section_list_element get(size_t _index);
+      [[nodiscard]] ls::std::io::section_pair_document_section_list_element get(size_t _index);
+      [[nodiscard]] ls::std::io::section_pair_document_section_list_element get(const ls::std::io::section_pair_identifier &_sectionId);
       [[nodiscard]] size_t getAmountOfSections();
       [[nodiscard]] ::std::string getHeader();
-      [[nodiscard]] section_pair_document_section_list getSectionList();
+      [[nodiscard]] ls::std::io::section_pair_document_section_list getSectionList();
+      [[nodiscard]] bool hasSection(const ls::std::io::section_pair_identifier &_sectionId);
       [[nodiscard]] ls::std::core::type::byte_field marshal() override;
       void reserveNewLine(const ::std::string &_reservedNewLine);
       void unmarshal(const ls::std::core::type::byte_field &_data) override;
@@ -45,6 +47,7 @@ namespace ls::std::io
 
       void _checkSectionExistence(const ls::std::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);
       [[nodiscard]] bool _hasSection(const ls::std::io::section_pair_identifier &_identifier);
   };
 }

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-02-17
+* Changed:         2023-02-22
 *
 * */
 
@@ -26,7 +26,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairRow(const ls::std::io::section_pair_identifier &_key, const ls::std::io::SectionPairRowEnumType &_type);
-      ~SectionPairRow() override;
+      ~SectionPairRow() noexcept override;
 
       [[nodiscard]] ls::std::io::section_pair_identifier getKey();
       [[nodiscard]] ::std::shared_ptr<ls::std::io::SectionPairRowValue> getValue();

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2023-02-16
+* Changed:         2023-02-22
 *
 * */
 
@@ -14,15 +14,16 @@
 #include <list>
 #include <ls-std/core/Class.hpp>
 #include <ls-std/io/section-pair/SectionPairTypes.hpp>
+#include <ls-std/os/dynamic-goal.hpp>
 
 namespace ls::std::io
 {
-  class 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::std::core::Class, public ls::std::io::SectionPairRowValue
   {
     public:
 
       SectionPairRowListValue();
-      ~SectionPairRowListValue() override;
+      ~SectionPairRowListValue() noexcept override;
 
       void add(const ls::std::io::section_pair_row_value &_value);
       void clear();

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2023-02-13
+* Changed:         2023-02-22
 *
 * */
 
@@ -24,7 +24,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairRowSingleValue(const ls::std::io::section_pair_row_value &_value);
-      ~SectionPairRowSingleValue() override;
+      ~SectionPairRowSingleValue() noexcept override;
 
       [[nodiscard]] ls::std::io::section_pair_row_value get();
       [[nodiscard]] ls::std::io::SectionPairRowEnumType getType() override;

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2023-02-17
+* Changed:         2023-02-22
 *
 * */
 
@@ -21,7 +21,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairRowValue(const ls::std::io::SectionPairRowEnumType &_type);
-      ~SectionPairRowValue() override;
+      ~SectionPairRowValue() noexcept override;
 
       virtual ls::std::io::SectionPairRowEnumType getType() = 0;
       [[nodiscard]] ls::std::core::type::byte_field marshal() override;

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-13
-* Changed:         2023-02-18
+* Changed:         2023-02-23
 *
 * */
 
@@ -26,14 +26,16 @@ namespace ls::std::io
     public:
 
       explicit SectionPairSection(const ls::std::io::section_pair_identifier &_sectionId);
-      ~SectionPairSection() override;
+      ~SectionPairSection() noexcept override;
 
-      void add(const section_pair_row_list_element &_row);
+      void add(const ls::std::io::section_pair_row_list_element &_row);
       void clear();
-      [[nodiscard]] section_pair_row_list_element get(size_t _index);
+      [[nodiscard]] ls::std::io::section_pair_row_list_element get(size_t _index);
+      [[nodiscard]] ls::std::io::section_pair_row_list_element get(const ls::std::io::section_pair_identifier &_key);
       [[nodiscard]] ls::std::io::section_pair_row_list getList();
       [[nodiscard]] size_t getRowAmount();
       [[nodiscard]] ls::std::io::section_pair_identifier getSectionId();
+      [[nodiscard]] bool hasRow(const ls::std::io::section_pair_identifier &_key);
       [[nodiscard]] ls::std::core::type::byte_field marshal() override;
       void reserveNewLine(const ::std::string &_reservedNewLine);
       void setSectionId(const ls::std::io::section_pair_identifier &_sectionId);
@@ -47,6 +49,7 @@ namespace ls::std::io
       ::std::shared_ptr<ls::std::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);
       [[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);

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2023-02-21
+* Changed:         2023-02-22
 *
 * */
 
@@ -23,7 +23,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairFileReader(const ls::std::io::SectionPairFileReaderParameter &_parameter);
-      ~SectionPairFileReader() override;
+      ~SectionPairFileReader() noexcept override;
 
       [[nodiscard]] ::std::shared_ptr<ls::std::io::SectionPairDocument> getDocument();
       ls::std::core::type::byte_field read() override; // nodiscard is optional here

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-16
-* Changed:         2023-02-18
+* Changed:         2023-02-22
 *
 * */
 
@@ -23,7 +23,7 @@ namespace ls::std::io
     public:
 
       explicit SerializableSectionPairDocument(const ls::std::io::SerializableSectionPairParameter &_parameter);
-      ~SerializableSectionPairDocument() override;
+      ~SerializableSectionPairDocument() noexcept override;
 
       [[nodiscard]] ::std::shared_ptr<ls::std::core::Class> getValue();
       [[nodiscard]] ls::std::core::type::byte_field marshal() override;

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-11
-* Changed:         2023-02-17
+* Changed:         2023-02-22
 *
 * */
 
@@ -13,17 +13,18 @@
 #include "SerializableSectionPairParameter.hpp"
 #include <ls-std/core/Class.hpp>
 #include <ls-std/core/interface/ISerializable.hpp>
+#include <ls-std/os/dynamic-goal.hpp>
 #include <memory>
 #include <string>
 
 namespace ls::std::io
 {
-  class SerializableSectionPairRow : public ls::std::core::interface_type::ISerializable, public ls::std::core::Class
+  class LS_STD_DYNAMIC_GOAL SerializableSectionPairRow : public ls::std::core::interface_type::ISerializable, public ls::std::core::Class
   {
     public:
 
       explicit SerializableSectionPairRow(const ls::std::io::SerializableSectionPairParameter &_parameter);
-      ~SerializableSectionPairRow() override;
+      ~SerializableSectionPairRow() noexcept override;
 
       [[nodiscard]] ::std::shared_ptr<ls::std::core::Class> getValue();
       [[nodiscard]] ls::std::core::type::byte_field marshal() override;

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-11
-* Changed:         2023-02-17
+* Changed:         2023-02-22
 *
 * */
 
@@ -23,7 +23,7 @@ namespace ls::std::io
     public:
 
       explicit SerializableSectionPairRowListValue(const ls::std::io::SerializableSectionPairParameter &_parameter);
-      ~SerializableSectionPairRowListValue() override;
+      ~SerializableSectionPairRowListValue() noexcept override;
 
       [[nodiscard]] ::std::shared_ptr<ls::std::core::Class> getValue();
       [[nodiscard]] ls::std::core::type::byte_field marshal() override;

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-11
-* Changed:         2023-02-17
+* Changed:         2023-02-22
 *
 * */
 
@@ -23,7 +23,7 @@ namespace ls::std::io
     public:
 
       explicit SerializableSectionPairRowSingleValue(const ls::std::io::SerializableSectionPairParameter &_parameter);
-      ~SerializableSectionPairRowSingleValue() override;
+      ~SerializableSectionPairRowSingleValue() noexcept override;
 
       [[nodiscard]] ::std::shared_ptr<ls::std::core::Class> getValue();
       [[nodiscard]] ls::std::core::type::byte_field marshal() override;

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-14
-* Changed:         2023-02-20
+* Changed:         2023-02-22
 *
 * */
 
@@ -23,7 +23,7 @@ namespace ls::std::io
     public:
 
       explicit SerializableSectionPairSection(const ls::std::io::SerializableSectionPairParameter &_parameter);
-      ~SerializableSectionPairSection() override;
+      ~SerializableSectionPairSection() noexcept override;
 
       [[nodiscard]] ::std::shared_ptr<ls::std::core::Class> getValue();
       [[nodiscard]] ls::std::core::type::byte_field marshal() override;
@@ -34,8 +34,8 @@ namespace ls::std::io
       ls::std::io::SerializableSectionPairParameter parameter{};
 
       [[nodiscard]] ls::std::core::type::byte_field _collectSectionRow(const ls::std::core::type::byte_field &_currentRows, ls::std::io::SectionPairRowEnumType &_type);
-      [[nodiscard]] ls::std::core::type::byte_field _collectSectionListValueRow(const core::type::byte_field &_currentRows, SectionPairRowEnumType &_type);
-      [[nodiscard]] static core::type::byte_field _collectSectionSingleValueRow(const ls::std::core::type::byte_field &_firstRow, SectionPairRowEnumType &type);
+      [[nodiscard]] ls::std::core::type::byte_field _collectSectionListValueRow(const core::type::byte_field &_currentRows, ls::std::io::SectionPairRowEnumType &_type);
+      [[nodiscard]] static core::type::byte_field _collectSectionSingleValueRow(const ls::std::core::type::byte_field &_firstRow, ls::std::io::SectionPairRowEnumType &type);
       [[nodiscard]] static size_t _getNthSubStringPosition(const ls::std::core::type::byte_field &_text, const ls::std::core::type::byte_field &_subText);
       [[nodiscard]] ls::std::core::type::byte_field _getSectionHeader(const ls::std::core::type::byte_field &_data);
       [[nodiscard]] static ls::std::core::type::byte_field _getSectionId(const ls::std::core::type::byte_field &_sectionHeader);

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2023-02-21
+* Changed:         2023-02-22
 *
 * */
 
@@ -22,7 +22,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairDocumentValidator(::std::string _document);
-      ~SectionPairDocumentValidator() override;
+      ~SectionPairDocumentValidator() noexcept override;
 
       [[nodiscard]] bool isValid() override;
 

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2023-02-21
+* Changed:         2023-02-22
 *
 * */
 
@@ -22,7 +22,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairFileExtensionValidator(::std::string _fileName);
-      ~SectionPairFileExtensionValidator() override;
+      ~SectionPairFileExtensionValidator() noexcept override;
 
       [[nodiscard]] bool isValid() override;
 

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-09
-* Changed:         2023-02-18
+* Changed:         2023-02-22
 *
 * */
 
@@ -23,7 +23,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairIdentifierValidator(ls::std::io::section_pair_identifier _identifier);
-      ~SectionPairIdentifierValidator() override;
+      ~SectionPairIdentifierValidator() noexcept override;
 
       [[nodiscard]] static ::std::string getValidationRegex();
       [[nodiscard]] bool isValid() override;

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-19
-* Changed:         2023-02-20
+* Changed:         2023-02-22
 *
 * */
 
@@ -22,7 +22,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairRowListValueValidator(::std::string _listValueRow);
-      ~SectionPairRowListValueValidator() override;
+      ~SectionPairRowListValueValidator() noexcept override;
 
       [[nodiscard]] static ::std::string getValidationRegex();
       [[nodiscard]] bool isValid() override;

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-19
-* Changed:         2023-02-20
+* Changed:         2023-02-22
 *
 * */
 
@@ -21,7 +21,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairRowSingleValueValidator(::std::string _singleValueRow);
-      ~SectionPairRowSingleValueValidator() override;
+      ~SectionPairRowSingleValueValidator() noexcept override;
 
       [[nodiscard]] static ::std::string getValidationRegex();
       [[nodiscard]] bool isValid() override;

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2023-02-20
+* Changed:         2023-02-22
 *
 * */
 
@@ -22,7 +22,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairRowValidator(::std::string _row);
-      ~SectionPairRowValidator() override;
+      ~SectionPairRowValidator() noexcept override;
 
       [[nodiscard]] static ::std::string getValidationRegex();
       [[nodiscard]] bool isValid() override;

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2023-02-20
+* Changed:         2023-02-22
 *
 * */
 
@@ -22,7 +22,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairSectionValidator(::std::string _section);
-      ~SectionPairSectionValidator() override;
+      ~SectionPairSectionValidator() noexcept override;
 
       [[nodiscard]] static ::std::string getValidationRegex();
       [[nodiscard]] bool isValid() override;

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

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-09
-* Changed:         2023-02-19
+* Changed:         2023-02-22
 *
 * */
 
@@ -23,7 +23,7 @@ namespace ls::std::io
     public:
 
       explicit SectionPairValueValidator(ls::std::io::section_pair_row_value _value);
-      ~SectionPairValueValidator() override;
+      ~SectionPairValueValidator() noexcept override;
 
       [[nodiscard]] static ::std::string getValidationRegex();
       [[nodiscard]] bool isValid() override;

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-23
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -21,7 +21,7 @@ namespace ls::std::io
     public:
 
       explicit XmlAttribute(const ::std::string &_name);
-      ~XmlAttribute() override;
+      ~XmlAttribute() noexcept override;
 
       [[nodiscard]] ::std::string getName();
       [[nodiscard]] ::std::string getValue();

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -21,7 +21,7 @@ namespace ls::std::io
     public:
 
       explicit XmlDeclaration(const ::std::string &_version);
-      ~XmlDeclaration() override;
+      ~XmlDeclaration() noexcept override;
 
       [[nodiscard]] ::std::string getEncoding();
       [[nodiscard]] ::std::string getStandalone();

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -23,7 +23,7 @@ namespace ls::std::io
     public:
 
       XmlDocument();
-      ~XmlDocument() override;
+      ~XmlDocument() noexcept override;
 
       [[nodiscard]] ::std::shared_ptr<ls::std::io::XmlDeclaration> getDeclaration();
       [[nodiscard]] ::std::shared_ptr<ls::std::io::XmlNode> getRootElement();

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-24
- * Changed:         2023-02-08
+ * Changed:         2023-02-22
  *
  * */
 
@@ -23,7 +23,7 @@ namespace ls::std::io
     public:
 
       explicit XmlNode(::std::string _name);
-      ~XmlNode() override;
+      ~XmlNode() noexcept override;
 
       bool addAttributeAfter(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute, const ::std::string &_name);                 // nodiscard is optional here
       bool addAttributeBefore(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute, const ::std::string &_name);                // nodiscard is optional here

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

@@ -3,12 +3,12 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-17
- * Changed:         2023-02-05
+ * Changed:         2023-02-22
  *
  * */
 
-#ifndef LS_STD_XML_PARSE_DATA_HPP
-#define LS_STD_XML_PARSE_DATA_HPP
+#ifndef LS_STD_XML_PARSE_PARAMETER_HPP
+#define LS_STD_XML_PARSE_PARAMETER_HPP
 
 #include "XmlNode.hpp"
 #include <cstdint>

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-25
- * Changed:         2023-02-08
+ * Changed:         2023-02-22
  *
  * */
 
@@ -25,7 +25,7 @@ namespace ls::std::io
     public:
 
       explicit XmlParser(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
-      ~XmlParser() override;
+      ~XmlParser() noexcept override;
 
       [[nodiscard]] ::std::shared_ptr<ls::std::io::XmlDocument> getDocument();
       void parse(const ls::std::core::type::byte_field &_data);

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

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-08
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -26,7 +26,7 @@ namespace ls::std::io
     public:
 
       explicit XmlReader(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document, const ::std::string &_absolutePath);
-      ~XmlReader() override;
+      ~XmlReader() noexcept override;
 
       // implementation
 

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

@@ -38,7 +38,6 @@
 #include <ls-std/core/interface/IWriter.hpp>
 
 #include <ls-std/core/type/EventTypes.hpp>
-#include <ls-std/core/type/KvTypes.hpp>
 #include <ls-std/core/type/Types.hpp>
 
 #include <ls-std/core/Class.hpp>

include/ls-std/time/Date.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2023-02-06
+ * Changed:         2023-02-22
  *
  * */
 
@@ -21,7 +21,7 @@ namespace ls::std::time
     public:
 
       Date();
-      ~Date() override;
+      ~Date() noexcept override;
 
       // arithmetic operators
 

source/ls-std/boxing/Boolean.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-09
- * Changed:         2023-02-07
+ * Changed:         2023-02-23
  *
  * */
 
@@ -11,68 +11,71 @@
 #include <ls-std/boxing/Boolean.hpp>
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::boxing::Boolean::Boolean(bool _value) : ls::std::core::Class("Boolean"), value(_value)
-{}
-
-ls::std::boxing::Boolean::Boolean() : ls::std::core::Class("Boolean")
-{}
+using ls::std::boxing::Boolean;
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using std::string;
+using std::transform;
 
-ls::std::boxing::Boolean::~Boolean() = default;
-
-ls::std::boxing::Boolean::operator bool() const
+Boolean::Boolean(bool _value) : Boolean()
 {
-  return this->value;
+  this->value = _value;
 }
 
-ls::std::boxing::Boolean &ls::std::boxing::Boolean::operator=(int _value)
+Boolean::Boolean() : Class("Boolean")
+{}
+
+Boolean::~Boolean() noexcept = default;
+
+Boolean &Boolean::operator=(int _value)
 {
   this->value = _value;
   return *this;
 }
 
-ls::std::boxing::Boolean &ls::std::boxing::Boolean::operator=(bool _value)
+Boolean &Boolean::operator=(bool _value)
 {
   this->value = _value;
   return *this;
 }
 
-bool ls::std::boxing::Boolean::operator&&(const ls::std::boxing::Boolean &_boolean) const
+bool Boolean::operator&&(const Boolean &_boolean) const
 {
-  return this->value && _boolean;
+  return this->value && _boolean.getValue();
 }
 
-bool ls::std::boxing::Boolean::operator&&(bool _value) const
+bool Boolean::operator&&(bool _value) const
 {
   return this->value && _value;
 }
 
-bool ls::std::boxing::Boolean::operator&&(int _value) const
+bool Boolean::operator&&(int _value) const
 {
   return this->value && _value;
 }
 
-bool ls::std::boxing::Boolean::operator||(const ls::std::boxing::Boolean &_boolean) const
+bool Boolean::operator||(const Boolean &_boolean) const
 {
-  return this->value || _boolean;
+  return this->value || _boolean.getValue();
 }
 
-bool ls::std::boxing::Boolean::operator||(bool _value) const
+bool Boolean::operator||(bool _value) const
 {
   return this->value || _value;
 }
 
-bool ls::std::boxing::Boolean::operator||(int _value) const
+bool Boolean::operator||(int _value) const
 {
   return this->value || _value;
 }
 
-void ls::std::boxing::Boolean::parse(::std::string _parseText)
+void Boolean::parse(string _parseText)
 {
-  ::std::transform(_parseText.begin(), _parseText.end(), _parseText.begin(), ::tolower);
+  transform(_parseText.begin(), _parseText.end(), _parseText.begin(), ::tolower);
 
   if (_parseText != this->TRUE_STRING && _parseText != this->FALSE_STRING)
   {
-    throw ls::std::core::IllegalArgumentException{_parseText + " is not a valid string representation"};
+    throw IllegalArgumentException{_parseText + " is not a valid string representation"};
   }
   else
   {
@@ -88,39 +91,39 @@ void ls::std::boxing::Boolean::parse(::std::string _parseText)
   }
 }
 
-::std::string ls::std::boxing::Boolean::toString()
+string Boolean::toString()
 {
   return this->_toString();
 }
 
-bool ls::std::boxing::Boolean::getValue() const
+bool Boolean::getValue() const
 {
   return this->value;
 }
 
-bool ls::std::boxing::Boolean::XOR(const ls::std::boxing::Boolean &_leftExpression, const ls::std::boxing::Boolean &_rightExpression)
+bool Boolean::XOR(const Boolean &_leftExpression, const Boolean &_rightExpression)
 {
-  return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression);
+  return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression.getValue());
 }
 
-bool ls::std::boxing::Boolean::XOR(const ls::std::boxing::Boolean &_leftExpression, bool _rightExpression)
+bool Boolean::XOR(const Boolean &_leftExpression, bool _rightExpression)
 {
   return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression);
 }
 
-bool ls::std::boxing::Boolean::XOR(bool _leftExpression, const ls::std::boxing::Boolean &_rightExpression)
+bool Boolean::XOR(bool _leftExpression, const Boolean &_rightExpression)
 {
-  return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression);
+  return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression.getValue());
 }
 
-bool ls::std::boxing::Boolean::XOR(bool _leftExpression, bool _rightExpression)
+bool Boolean::XOR(bool _leftExpression, bool _rightExpression)
 {
   return (_leftExpression && !_rightExpression) || (!_leftExpression && _rightExpression);
 }
 
-::std::string ls::std::boxing::Boolean::_toString() const
+string Boolean::_toString() const
 {
-  ::std::string booleanString{};
+  string booleanString{};
 
   if (this->value)
   {

source/ls-std/boxing/Double.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2023-02-07
+ * Changed:         2023-02-23
  *
  * */
 
@@ -11,222 +11,225 @@
 #include <ls-std/boxing/Double.hpp>
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::boxing::Double::Double() : ls::std::core::Class("Double")
-{
-  this->_assignEpsilon(0.00000001);
-}
+using ls::std::boxing::Double;
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using std::fabs;
+using std::stod;
+using std::string;
+using std::to_string;
 
-ls::std::boxing::Double::Double(double _value) : ls::std::core::Class("Double"), value(_value)
+Double::Double() : Class("Double")
 {
   this->_assignEpsilon(0.00000001);
 }
 
-ls::std::boxing::Double::~Double() = default;
-
-ls::std::boxing::Double::operator double() const
+Double::Double(double _value) : Double()
 {
-  return this->value;
+  this->value = _value;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator=(double _value)
+Double::~Double() noexcept = default;
+
+Double &Double::operator=(double _value)
 {
   this->value = _value;
   return *this;
 }
 
-double ls::std::boxing::Double::operator-() const
+double Double::operator-() const
 {
   return -this->value;
 }
 
-double ls::std::boxing::Double::operator+(const ls::std::boxing::Double &_double) const
+double Double::operator+(const Double &_double) const
 {
-  return this->value + _double;
+  return this->value + _double.getValue();
 }
 
-double ls::std::boxing::Double::operator+(double _value) const
+double Double::operator+(double _value) const
 {
   return this->value + _value;
 }
 
-double ls::std::boxing::Double::operator*(const ls::std::boxing::Double &_double) const
+double Double::operator*(const Double &_double) const
 {
-  return this->value * _double;
+  return this->value * _double.getValue();
 }
 
-double ls::std::boxing::Double::operator*(double _value) const
+double Double::operator*(double _value) const
 {
   return this->value * _value;
 }
 
-double ls::std::boxing::Double::operator-(const ls::std::boxing::Double &_double) const
+double Double::operator-(const Double &_double) const
 {
-  return this->value - _double;
+  return this->value - _double.getValue();
 }
 
-double ls::std::boxing::Double::operator-(double _value) const
+double Double::operator-(double _value) const
 {
   return this->value - _value;
 }
 
-double ls::std::boxing::Double::operator/(const ls::std::boxing::Double &_double) const
+double Double::operator/(const Double &_double) const
 {
-  return this->value / _double;
+  return this->value / _double.getValue();
 }
 
-double ls::std::boxing::Double::operator/(double _value) const
+double Double::operator/(double _value) const
 {
   return this->value / _value;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator+=(const ls::std::boxing::Double &_double)
+Double &Double::operator+=(const Double &_double)
 {
-  this->value += _double;
+  this->value += _double.getValue();
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator+=(double _value)
+Double &Double::operator+=(double _value)
 {
   this->value += _value;
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator-=(const ls::std::boxing::Double &_double)
+Double &Double::operator-=(const Double &_double)
 {
-  this->value -= _double;
+  this->value -= _double.getValue();
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator-=(double _value)
+Double &Double::operator-=(double _value)
 {
   this->value -= _value;
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator*=(const ls::std::boxing::Double &_double)
+Double &Double::operator*=(const Double &_double)
 {
-  this->value *= _double;
+  this->value *= _double.getValue();
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator*=(double _value)
+Double &Double::operator*=(double _value)
 {
   this->value *= _value;
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator/=(const ls::std::boxing::Double &_double)
+Double &Double::operator/=(const Double &_double)
 {
-  this->value /= _double;
+  this->value /= _double.getValue();
   return *this;
 }
 
-ls::std::boxing::Double &ls::std::boxing::Double::operator/=(double _value)
+Double &Double::operator/=(double _value)
 {
   this->value /= _value;
   return *this;
 }
 
-bool ls::std::boxing::Double::operator==(const ls::std::boxing::Double &_double) const
+bool Double::operator==(const Double &_double) const
 {
-  return ::std::fabs(this->value - _double) < this->epsilon;
+  return fabs(this->value - _double.getValue()) < this->epsilon;
 }
 
-bool ls::std::boxing::Double::operator==(double _value) const
+bool Double::operator==(double _value) const
 {
-  return ::std::fabs(this->value - _value) < this->epsilon;
+  return fabs(this->value - _value) < this->epsilon;
 }
 
-bool ls::std::boxing::Double::operator!=(const ls::std::boxing::Double &_double) const
+bool Double::operator!=(const Double &_double) const
 {
-  return ::std::fabs(this->value - _double) >= this->epsilon;
+  return fabs(this->value - _double.getValue()) >= this->epsilon;
 }
 
-bool ls::std::boxing::Double::operator!=(double _value) const
+bool Double::operator!=(double _value) const
 {
-  return ::std::fabs(this->value - _value) >= this->epsilon;
+  return fabs(this->value - _value) >= this->epsilon;
 }
 
-bool ls::std::boxing::Double::operator>(const ls::std::boxing::Double &_double) const
+bool Double::operator>(const Double &_double) const
 {
-  return this->value > _double;
+  return this->value > _double.getValue();
 }
 
-bool ls::std::boxing::Double::operator>(double _value) const
+bool Double::operator>(double _value) const
 {
   return this->value > _value;
 }
 
-bool ls::std::boxing::Double::operator>=(const ls::std::boxing::Double &_double) const
+bool Double::operator>=(const Double &_double) const
 {
-  return this->value >= _double;
+  return this->value >= _double.getValue();
 }
 
-bool ls::std::boxing::Double::operator>=(double _value) const
+bool Double::operator>=(double _value) const
 {
   return this->value >= _value;
 }
 
-bool ls::std::boxing::Double::operator<(const ls::std::boxing::Double &_double) const
+bool Double::operator<(const Double &_double) const
 {
-  return this->value < _double;
+  return this->value < _double.getValue();
 }
 
-bool ls::std::boxing::Double::operator<(double _value) const
+bool Double::operator<(double _value) const
 {
   return this->value < _value;
 }
 
-bool ls::std::boxing::Double::operator<=(const ls::std::boxing::Double &_double) const
+bool Double::operator<=(const Double &_double) const
 {
-  return this->value <= _double;
+  return this->value <= _double.getValue();
 }
 
-bool ls::std::boxing::Double::operator<=(double _value) const
+bool Double::operator<=(double _value) const
 {
   return this->value <= _value;
 }
 
-void ls::std::boxing::Double::operator++()
+void Double::operator++()
 {
   this->value += 1.0f;
 }
 
-void ls::std::boxing::Double::operator--()
+void Double::operator--()
 {
   this->value -= 1.0f;
 }
 
-void ls::std::boxing::Double::parse(::std::string _parseText)
+void Double::parse(string _parseText)
 {
-  this->value = ::std::stod(_parseText);
+  this->value = stod(_parseText);
 }
 
-::std::string ls::std::boxing::Double::toString()
+string Double::toString()
 {
-  return ::std::to_string(this->value);
+  return to_string(this->value);
 }
 
-double ls::std::boxing::Double::getEpsilon()
+double Double::getEpsilon() const
 {
   return this->epsilon;
 }
 
-double ls::std::boxing::Double::getValue()
+double Double::getValue() const
 {
   return this->value;
 }
 
-void ls::std::boxing::Double::setEpsilon(double _epsilon)
+void Double::setEpsilon(double _epsilon)
 {
   this->_assignEpsilon(_epsilon);
 }
 
-void ls::std::boxing::Double::_assignEpsilon(double _epsilon)
+void Double::_assignEpsilon(double _epsilon)
 {
   if (_epsilon <= 0.0)
   {
-    throw ls::std::core::IllegalArgumentException{"_epsilon is less than or equal zero"};
+    throw IllegalArgumentException{"_epsilon is less than or equal zero"};
   }
 
   this->epsilon = _epsilon;

source/ls-std/boxing/Float.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2023-02-07
+ * Changed:         2023-02-23
  *
  * */
 
@@ -11,218 +11,223 @@
 #include <ls-std/boxing/Float.hpp>
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::boxing::Float::Float() : ls::std::core::Class("Float"), epsilon(0.00001f)
-{}
+using ls::std::boxing::Float;
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using std::fabs;
+using std::stof;
+using std::string;
+using std::to_string;
 
-ls::std::boxing::Float::Float(float _value) : ls::std::core::Class("Float"), epsilon(0.00001f), value(_value)
+Float::Float() : Class("Float"), epsilon(0.00001f)
 {}
 
-ls::std::boxing::Float::~Float() = default;
-
-ls::std::boxing::Float::operator float() const
+Float::Float(float _value) : Float()
 {
-  return this->value;
+  this->value = _value;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator=(float _value)
+Float::~Float() noexcept = default;
+
+Float &Float::operator=(float _value)
 {
   this->value = _value;
   return *this;
 }
 
-float ls::std::boxing::Float::operator-() const
+float Float::operator-() const
 {
   return -this->value;
 }
 
-float ls::std::boxing::Float::operator+(const ls::std::boxing::Float &_float) const
+float Float::operator+(const Float &_float) const
 {
-  return this->value + _float;
+  return this->value + _float.getValue();
 }
 
-float ls::std::boxing::Float::operator+(float _value) const
+float Float::operator+(float _value) const
 {
   return this->value + _value;
 }
 
-float ls::std::boxing::Float::operator*(const ls::std::boxing::Float &_float) const
+float Float::operator*(const Float &_float) const
 {
-  return this->value * _float;
+  return this->value * _float.getValue();
 }
 
-float ls::std::boxing::Float::operator*(float _value) const
+float Float::operator*(float _value) const
 {
   return this->value * _value;
 }
 
-float ls::std::boxing::Float::operator-(const ls::std::boxing::Float &_float) const
+float Float::operator-(const Float &_float) const
 {
-  return this->value - _float;
+  return this->value - _float.getValue();
 }
 
-float ls::std::boxing::Float::operator-(float _value) const
+float Float::operator-(float _value) const
 {
   return this->value - _value;
 }
 
-float ls::std::boxing::Float::operator/(const ls::std::boxing::Float &_float) const
+float Float::operator/(const Float &_float) const
 {
-  return this->value / _float;
+  return this->value / _float.getValue();
 }
 
-float ls::std::boxing::Float::operator/(float _value) const
+float Float::operator/(float _value) const
 {
   return this->value / _value;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator+=(const ls::std::boxing::Float &_float)
+Float &Float::operator+=(const Float &_float)
 {
-  this->value += _float;
+  this->value += _float.getValue();
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator+=(float _value)
+Float &Float::operator+=(float _value)
 {
   this->value += _value;
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator-=(const ls::std::boxing::Float &_float)
+Float &Float::operator-=(const Float &_float)
 {
-  this->value -= _float;
+  this->value -= _float.getValue();
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator-=(float _value)
+Float &Float::operator-=(float _value)
 {
   this->value -= _value;
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator*=(const ls::std::boxing::Float &_float)
+Float &Float::operator*=(const Float &_float)
 {
-  this->value *= _float;
+  this->value *= _float.getValue();
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator*=(float _value)
+Float &Float::operator*=(float _value)
 {
   this->value *= _value;
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator/=(const ls::std::boxing::Float &_float)
+Float &Float::operator/=(const Float &_float)
 {
-  this->value /= _float;
+  this->value /= _float.getValue();
   return *this;
 }
 
-ls::std::boxing::Float &ls::std::boxing::Float::operator/=(float _value)
+Float &Float::operator/=(float _value)
 {
   this->value /= _value;
   return *this;
 }
 
-bool ls::std::boxing::Float::operator==(const ls::std::boxing::Float &_float) const
+bool Float::operator==(const Float &_float) const
 {
-  return ::std::fabs(this->value - _float) < this->epsilon;
+  return fabs(this->value - _float.getValue()) < this->epsilon;
 }
 
-bool ls::std::boxing::Float::operator==(float _value) const
+bool Float::operator==(float _value) const
 {
-  return ::std::fabs(this->value - _value) < this->epsilon;
+  return fabs(this->value - _value) < this->epsilon;
 }
 
-bool ls::std::boxing::Float::operator!=(const ls::std::boxing::Float &_float) const
+bool Float::operator!=(const Float &_float) const
 {
-  return ::std::fabs(this->value - _float) >= this->epsilon;
+  return fabs(this->value - _float.getValue()) >= this->epsilon;
 }
 
-bool ls::std::boxing::Float::operator!=(float _value) const
+bool Float::operator!=(float _value) const
 {
-  return ::std::fabs(this->value - _value) >= this->epsilon;
+  return fabs(this->value - _value) >= this->epsilon;
 }
 
-bool ls::std::boxing::Float::operator>(const ls::std::boxing::Float &_float) const
+bool Float::operator>(const Float &_float) const
 {
-  return this->value > _float;
+  return this->value > _float.getValue();
 }
 
-bool ls::std::boxing::Float::operator>(float _value) const
+bool Float::operator>(float _value) const
 {
   return this->value > _value;
 }
 
-bool ls::std::boxing::Float::operator>=(const ls::std::boxing::Float &_float) const
+bool Float::operator>=(const Float &_float) const
 {
-  return this->value >= _float;
+  return this->value >= _float.getValue();
 }
 
-bool ls::std::boxing::Float::operator>=(float _value) const
+bool Float::operator>=(float _value) const
 {
   return this->value >= _value;
 }
 
-bool ls::std::boxing::Float::operator<(const ls::std::boxing::Float &_float) const
+bool Float::operator<(const Float &_float) const
 {
-  return this->value < _float;
+  return this->value < _float.getValue();
 }
 
-bool ls::std::boxing::Float::operator<(float _value) const
+bool Float::operator<(float _value) const
 {
   return this->value < _value;
 }
 
-bool ls::std::boxing::Float::operator<=(const ls::std::boxing::Float &_float) const
+bool Float::operator<=(const Float &_float) const
 {
-  return this->value <= _float;
+  return this->value <= _float.getValue();
 }
 
-bool ls::std::boxing::Float::operator<=(float _value) const
+bool Float::operator<=(float _value) const
 {
   return this->value <= _value;
 }
 
-void ls::std::boxing::Float::operator++()
+void Float::operator++()
 {
   this->value += 1.0f;
 }
 
-void ls::std::boxing::Float::operator--()
+void Float::operator--()
 {
   this->value -= 1.0f;
 }
 
-void ls::std::boxing::Float::parse(::std::string _parseText)
+void Float::parse(string _parseText)
 {
-  this->value = ::std::stof(_parseText);
+  this->value = stof(_parseText);
 }
 
-::std::string ls::std::boxing::Float::toString()
+string Float::toString()
 {
-  return ::std::to_string(this->value);
+  return to_string(this->value);
 }
 
-float ls::std::boxing::Float::getEpsilon()
+float Float::getEpsilon() const
 {
   return this->epsilon;
 }
 
-float ls::std::boxing::Float::getValue()
+float Float::getValue() const
 {
   return this->value;
 }
 
-void ls::std::boxing::Float::setEpsilon(float _epsilon)
+void Float::setEpsilon(float _epsilon)
 {
   this->_assignEpsilon(_epsilon);
 }
 
-void ls::std::boxing::Float::_assignEpsilon(float _epsilon)
+void Float::_assignEpsilon(float _epsilon)
 {
   if (_epsilon <= 0.0)
   {
-    throw ls::std::core::IllegalArgumentException{"epsilon is less than or equal zero"};
+    throw IllegalArgumentException{"epsilon is less than or equal zero"};
   }
 
   this->epsilon = _epsilon;

source/ls-std/boxing/Integer.cpp

@@ -3,266 +3,270 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2023-02-07
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/boxing/Integer.hpp>
 #include <ls-std/core/exception/IllegalArithmeticOperationException.hpp>
 
-ls::std::boxing::Integer::Integer(int _value) : ls::std::core::Class("Integer"), value(_value)
-{}
-
-ls::std::boxing::Integer::Integer() : ls::std::core::Class("Integer")
-{}
+using ls::std::boxing::Integer;
+using ls::std::core::Class;
+using ls::std::core::IllegalArithmeticOperationException;
+using std::stoi;
+using std::string;
+using std::to_string;
 
-ls::std::boxing::Integer::~Integer() = default;
-
-ls::std::boxing::Integer::operator int() const
+Integer::Integer(int _value) : Integer()
 {
-  return this->value;
+  this->value = _value;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator=(int _value)
+Integer::Integer() : Class("Integer")
+{}
+
+Integer::~Integer() noexcept = default;
+
+Integer &Integer::operator=(int _value)
 {
   this->value = _value;
   return *this;
 }
 
-int ls::std::boxing::Integer::operator-() const
+int Integer::operator-() const
 {
   return -this->value;
 }
 
-int ls::std::boxing::Integer::operator+(const ls::std::boxing::Integer &_integer) const
+int Integer::operator+(const Integer &_integer) const
 {
-  return this->value + _integer;
+  return this->value + _integer.getValue();
 }
 
-int ls::std::boxing::Integer::operator+(int _value) const
+int Integer::operator+(int _value) const
 {
   return this->value + _value;
 }
 
-int ls::std::boxing::Integer::operator*(const ls::std::boxing::Integer &_integer) const
+int Integer::operator*(const Integer &_integer) const
 {
-  return this->value * _integer;
+  return this->value * _integer.getValue();
 }
 
-int ls::std::boxing::Integer::operator*(int _value) const
+int Integer::operator*(int _value) const
 {
   return this->value * _value;
 }
 
-int ls::std::boxing::Integer::operator-(const ls::std::boxing::Integer &_integer) const
+int Integer::operator-(const Integer &_integer) const
 {
-  return this->value - _integer;
+  return this->value - _integer.getValue();
 }
 
-int ls::std::boxing::Integer::operator-(int _value) const
+int Integer::operator-(int _value) const
 {
   return this->value - _value;
 }
 
-int ls::std::boxing::Integer::operator/(const ls::std::boxing::Integer &_integer) const
+int Integer::operator/(const Integer &_integer) const
 {
   if (_integer == 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
-  return this->value / _integer;
+  return this->value / _integer.getValue();
 }
 
-int ls::std::boxing::Integer::operator/(int _value) const
+int Integer::operator/(int _value) const
 {
   if (_value == 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
   return this->value / _value;
 }
 
-int ls::std::boxing::Integer::operator%(const ls::std::boxing::Integer &_integer) const
+int Integer::operator%(const Integer &_integer) const
 {
-  return this->value % _integer;
+  return this->value % _integer.getValue();
 }
 
-int ls::std::boxing::Integer::operator%(int _value) const
+int Integer::operator%(int _value) const
 {
   return this->value % _value;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator+=(const ls::std::boxing::Integer &_integer)
+Integer &Integer::operator+=(const Integer &_integer)
 {
-  this->value += _integer;
+  this->value += _integer.getValue();
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator+=(int _value)
+Integer &Integer::operator+=(int _value)
 {
   this->value += _value;
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator-=(const ls::std::boxing::Integer &_integer)
+Integer &Integer::operator-=(const Integer &_integer)
 {
-  this->value -= _integer;
+  this->value -= _integer.getValue();
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator-=(int _value)
+Integer &Integer::operator-=(int _value)
 {
   this->value -= _value;
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator*=(const ls::std::boxing::Integer &_integer)
+Integer &Integer::operator*=(const Integer &_integer)
 {
-  this->value *= _integer;
+  this->value *= _integer.getValue();
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator*=(int _value)
+Integer &Integer::operator*=(int _value)
 {
   this->value *= _value;
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator/=(const ls::std::boxing::Integer &_integer)
+Integer &Integer::operator/=(const Integer &_integer)
 {
   if (_integer == 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
-  this->value /= _integer;
+  this->value /= _integer.getValue();
   return *this;
 }
 
-ls::std::boxing::Integer &ls::std::boxing::Integer::operator/=(int _value)
+Integer &Integer::operator/=(int _value)
 {
   if (_value == 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
   this->value /= _value;
   return *this;
 }
 
-bool ls::std::boxing::Integer::operator==(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator==(const Integer &_integer) const
 {
-  return this->value == _integer;
+  return this->value == _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator==(int _value) const
+bool Integer::operator==(int _value) const
 {
   return this->value == _value;
 }
 
-bool ls::std::boxing::Integer::operator!=(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator!=(const Integer &_integer) const
 {
-  return this->value != _integer;
+  return this->value != _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator!=(int _value) const
+bool Integer::operator!=(int _value) const
 {
   return this->value != _value;
 }
 
-bool ls::std::boxing::Integer::operator>(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator>(const Integer &_integer) const
 {
-  return this->value > _integer;
+  return this->value > _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator>(int _value) const
+bool Integer::operator>(int _value) const
 {
   return this->value > _value;
 }
 
-bool ls::std::boxing::Integer::operator>=(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator>=(const Integer &_integer) const
 {
-  return this->value >= _integer;
+  return this->value >= _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator>=(int _value) const
+bool Integer::operator>=(int _value) const
 {
   return this->value >= _value;
 }
 
-bool ls::std::boxing::Integer::operator<(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator<(const Integer &_integer) const
 {
-  return this->value < _integer;
+  return this->value < _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator<(int _value) const
+bool Integer::operator<(int _value) const
 {
   return this->value < _value;
 }
 
-bool ls::std::boxing::Integer::operator<=(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator<=(const Integer &_integer) const
 {
-  return this->value <= _integer;
+  return this->value <= _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator<=(int _value) const
+bool Integer::operator<=(int _value) const
 {
   return this->value <= _value;
 }
 
-bool ls::std::boxing::Integer::operator&&(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator&&(const Integer &_integer) const
 {
-  return this->value && _integer;
+  return this->value && _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator&&(int _value) const
+bool Integer::operator&&(int _value) const
 {
   return this->value && _value;
 }
 
-bool ls::std::boxing::Integer::operator&&(bool _expression) const
+bool Integer::operator&&(bool _expression) const
 {
   return this->value && _expression;
 }
 
-bool ls::std::boxing::Integer::operator||(const ls::std::boxing::Integer &_integer) const
+bool Integer::operator||(const Integer &_integer) const
 {
-  return this->value || _integer;
+  return this->value || _integer.getValue();
 }
 
-bool ls::std::boxing::Integer::operator||(int _value) const
+bool Integer::operator||(int _value) const
 {
   return this->value || _value;
 }
 
-bool ls::std::boxing::Integer::operator||(bool _expression) const
+bool Integer::operator||(bool _expression) const
 {
   return this->value || _expression;
 }
 
-void ls::std::boxing::Integer::operator++()
+void Integer::operator++()
 {
   this->value += 1;
 }
 
-void ls::std::boxing::Integer::operator--()
+void Integer::operator--()
 {
   this->value -= 1;
 }
 
-void ls::std::boxing::Integer::parse(::std::string _parseText)
+void Integer::parse(string _parseText)
 {
-  this->value = ::std::stoi(_parseText);
+  this->value = stoi(_parseText);
 }
 
-std::string ls::std::boxing::Integer::toString()
+string Integer::toString()
 {
-  return ::std::to_string(this->value);
+  return to_string(this->value);
 }
 
-int ls::std::boxing::Integer::getValue() const
+int Integer::getValue() const
 {
   return this->value;
 }

source/ls-std/boxing/Long.cpp

@@ -3,266 +3,271 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2023-02-07
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/boxing/Long.hpp>
 #include <ls-std/core/exception/IllegalArithmeticOperationException.hpp>
 
-ls::std::boxing::Long::Long(ls::std::core::type::long_type _value) : ls::std::core::Class("Long"), value(_value)
-{}
-
-ls::std::boxing::Long::Long() : ls::std::core::Class("Long")
-{}
+using ls::std::boxing::Long;
+using ls::std::core::Class;
+using ls::std::core::IllegalArithmeticOperationException;
+using ls::std::core::type::long_type;
+using std::stoll;
+using std::string;
+using std::to_string;
 
-ls::std::boxing::Long::~Long() = default;
-
-ls::std::boxing::Long::operator ls::std::core::type::long_type() const
+Long::Long(long_type _value) : Long()
 {
-  return this->value;
+  this->value = _value;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator=(ls::std::core::type::long_type _value)
+Long::Long() : Class("Long")
+{}
+
+Long::~Long() noexcept = default;
+
+Long &Long::operator=(long_type _value)
 {
   this->value = _value;
   return *this;
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator-() const
+long_type Long::operator-() const
 {
   return -this->value;
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator+(const ls::std::boxing::Long &_long) const
+long_type Long::operator+(const Long &_long) const
 {
-  return this->value + _long;
+  return this->value + _long.getValue();
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator+(ls::std::core::type::long_type _value) const
+long_type Long::operator+(long_type _value) const
 {
   return this->value + _value;
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator*(const ls::std::boxing::Long &_long) const
+long_type Long::operator*(const Long &_long) const
 {
-  return this->value * _long;
+  return this->value * _long.getValue();
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator*(ls::std::core::type::long_type _value) const
+long_type Long::operator*(long_type _value) const
 {
   return this->value * _value;
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator-(const ls::std::boxing::Long &_long) const
+long_type Long::operator-(const Long &_long) const
 {
-  return this->value - _long;
+  return this->value - _long.getValue();
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator-(ls::std::core::type::long_type _value) const
+long_type Long::operator-(long_type _value) const
 {
   return this->value - _value;
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator/(const ls::std::boxing::Long &_long) const
+long_type Long::operator/(const Long &_long) const
 {
-  if (_long == (ls::std::core::type::long_type) 0)
+  if (_long == (long_type) 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
-  return this->value / _long;
+  return this->value / _long.getValue();
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator/(ls::std::core::type::long_type _value) const
+long_type Long::operator/(long_type _value) const
 {
   if (_value == 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
   return this->value / _value;
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator%(const ls::std::boxing::Long &_long) const
+long_type Long::operator%(const Long &_long) const
 {
-  return this->value % _long;
+  return this->value % _long.getValue();
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::operator%(ls::std::core::type::long_type _value) const
+long_type Long::operator%(long_type _value) const
 {
   return this->value % _value;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator+=(const ls::std::boxing::Long &_long)
+Long &Long::operator+=(const Long &_long)
 {
-  this->value += _long;
+  this->value += _long.getValue();
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator+=(ls::std::core::type::long_type _value)
+Long &Long::operator+=(long_type _value)
 {
   this->value += _value;
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator-=(const ls::std::boxing::Long &_long)
+Long &Long::operator-=(const Long &_long)
 {
-  this->value -= _long;
+  this->value -= _long.getValue();
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator-=(ls::std::core::type::long_type _value)
+Long &Long::operator-=(long_type _value)
 {
   this->value -= _value;
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator*=(const ls::std::boxing::Long &_long)
+Long &Long::operator*=(const Long &_long)
 {
-  this->value *= _long;
+  this->value *= _long.getValue();
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator*=(ls::std::core::type::long_type _value)
+Long &Long::operator*=(long_type _value)
 {
   this->value *= _value;
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator/=(const ls::std::boxing::Long &_long)
+Long &Long::operator/=(const Long &_long)
 {
-  if (_long == (ls::std::core::type::long_type) 0)
+  if (_long == (long_type) 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
-  this->value /= _long;
+  this->value /= _long.getValue();
   return *this;
 }
 
-ls::std::boxing::Long &ls::std::boxing::Long::operator/=(ls::std::core::type::long_type _value)
+Long &Long::operator/=(long_type _value)
 {
   if (_value == 0)
   {
-    throw ls::std::core::IllegalArithmeticOperationException{"division by zero is not allowed"};
+    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
   }
 
   this->value /= _value;
   return *this;
 }
 
-bool ls::std::boxing::Long::operator==(const ls::std::boxing::Long &_long) const
+bool Long::operator==(const Long &_long) const
 {
-  return this->value == _long;
+  return this->value == _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator==(ls::std::core::type::long_type _value) const
+bool Long::operator==(long_type _value) const
 {
   return this->value == _value;
 }
 
-bool ls::std::boxing::Long::operator!=(const ls::std::boxing::Long &_long) const
+bool Long::operator!=(const Long &_long) const
 {
-  return this->value != _long;
+  return this->value != _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator!=(ls::std::core::type::long_type _value) const
+bool Long::operator!=(long_type _value) const
 {
   return this->value != _value;
 }
 
-bool ls::std::boxing::Long::operator>(const ls::std::boxing::Long &_long) const
+bool Long::operator>(const Long &_long) const
 {
-  return this->value > _long;
+  return this->value > _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator>(ls::std::core::type::long_type _value) const
+bool Long::operator>(long_type _value) const
 {
   return this->value > _value;
 }
 
-bool ls::std::boxing::Long::operator>=(const ls::std::boxing::Long &_long) const
+bool Long::operator>=(const Long &_long) const
 {
-  return this->value >= _long;
+  return this->value >= _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator>=(ls::std::core::type::long_type _value) const
+bool Long::operator>=(long_type _value) const
 {
   return this->value >= _value;
 }
 
-bool ls::std::boxing::Long::operator<(const ls::std::boxing::Long &_long) const
+bool Long::operator<(const Long &_long) const
 {
-  return this->value < _long;
+  return this->value < _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator<(ls::std::core::type::long_type _value) const
+bool Long::operator<(long_type _value) const
 {
   return this->value < _value;
 }
 
-bool ls::std::boxing::Long::operator<=(const ls::std::boxing::Long &_long) const
+bool Long::operator<=(const Long &_long) const
 {
-  return this->value <= _long;
+  return this->value <= _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator<=(ls::std::core::type::long_type _value) const
+bool Long::operator<=(long_type _value) const
 {
   return this->value <= _value;
 }
 
-bool ls::std::boxing::Long::operator&&(const ls::std::boxing::Long &_long) const
+bool Long::operator&&(const Long &_long) const
 {
-  return this->value && _long;
+  return this->value && _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator&&(ls::std::core::type::long_type _value) const
+bool Long::operator&&(long_type _value) const
 {
   return this->value && _value;
 }
 
-bool ls::std::boxing::Long::operator&&(bool _expression) const
+bool Long::operator&&(bool _expression) const
 {
   return this->value && _expression;
 }
 
-bool ls::std::boxing::Long::operator||(const ls::std::boxing::Long &_long) const
+bool Long::operator||(const Long &_long) const
 {
-  return this->value || _long;
+  return this->value || _long.getValue();
 }
 
-bool ls::std::boxing::Long::operator||(ls::std::core::type::long_type _value) const
+bool Long::operator||(long_type _value) const
 {
   return this->value || _value;
 }
 
-bool ls::std::boxing::Long::operator||(bool _expression) const
+bool Long::operator||(bool _expression) const
 {
   return this->value || _expression;
 }
 
-void ls::std::boxing::Long::operator++()
+void Long::operator++()
 {
   this->value += 1;
 }
 
-void ls::std::boxing::Long::operator--()
+void Long::operator--()
 {
   this->value -= 1;
 }
 
-void ls::std::boxing::Long::parse(::std::string _parseText)
+void Long::parse(string _parseText)
 {
-  this->value = ::std::stoll(_parseText);
+  this->value = stoll(_parseText);
 }
 
-std::string ls::std::boxing::Long::toString()
+string Long::toString()
 {
-  return ::std::to_string(this->value);
+  return to_string(this->value);
 }
 
-ls::std::core::type::long_type ls::std::boxing::Long::getValue() const
+long_type Long::getValue() const
 {
   return this->value;
 }

source/ls-std/boxing/String.cpp

@@ -3,194 +3,198 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-14
- * Changed:         2023-02-07
+ * Changed:         2023-02-23
  *
  * */
 
 #include <algorithm>
 #include <ls-std/boxing/String.hpp>
 
-ls::std::boxing::String::String() : ls::std::core::Class("String")
-{}
+using ls::std::boxing::String;
+using ls::std::core::Class;
+using ls::std::core::type::byte_type;
+using std::move;
+using std::reverse;
+using std::string;
+using std::transform;
+using std::vector;
 
-ls::std::boxing::String::String(::std::string _value) : ls::std::core::Class("String"), value(::std::move(_value))
+String::String() : Class("String")
 {}
 
-ls::std::boxing::String::~String() = default;
-
-ls::std::boxing::String::operator const char *() const
+String::String(string _value) : String()
 {
-  return this->value.c_str();
+  this->value = ::move(_value);
 }
 
-ls::std::boxing::String::operator ::std::string() const
-{
-  return this->value;
-}
+String::~String() noexcept = default;
 
-ls::std::boxing::String &ls::std::boxing::String::operator=(::std::string _value)
+String &String::operator=(string _value)
 {
-  this->value = ::std::move(_value);
+  this->value = ::move(_value);
   return *this;
 }
 
-::std::string ls::std::boxing::String::operator+(ls::std::boxing::String _string) const
+string String::operator+(String _string) const
 {
   return this->value + _string.toString();
 }
 
-::std::string ls::std::boxing::String::operator+(const ::std::string &_string) const
+string String::operator+(const string &_string) const
 {
   return this->value + _string;
 }
 
-::std::string ls::std::boxing::String::operator+(const char *_string) const
+string String::operator+(const char *_string) const
 {
   return this->value + _string;
 }
 
-::std::string ls::std::boxing::String::operator-(int _number)
+string String::operator-(int _number)
 {
-  ::std::string copy = this->value;
+  string copy = this->value;
   return copy.substr(0, copy.size() - _number);
 }
 
-ls::std::boxing::String &ls::std::boxing::String::operator+=(ls::std::boxing::String _string)
+String &String::operator+=(String _string)
 {
   this->value = this->value + _string.toString();
   return *this;
 }
 
-ls::std::boxing::String &ls::std::boxing::String::operator+=(const ::std::string &_text)
+String &String::operator+=(const string &_text)
 {
   this->value = this->value + _text;
   return *this;
 }
 
-bool ls::std::boxing::String::operator==(ls::std::boxing::String _string)
+bool String::operator==(String _string)
 {
   return this->value == _string.toString();
 }
 
-bool ls::std::boxing::String::operator==(const ::std::string &_value)
+bool String::operator==(const string &_value)
 {
   return this->value == _value;
 }
 
-bool ls::std::boxing::String::operator==(const char *_value)
+bool String::operator==(const char *_value)
 {
   return this->value == _value;
 }
 
-bool ls::std::boxing::String::operator!=(ls::std::boxing::String _string)
+bool String::operator!=(String _string)
 {
   return this->value != _string.toString();
 }
 
-bool ls::std::boxing::String::operator!=(const ::std::string &_value)
+bool String::operator!=(const string &_value)
 {
   return this->value != _value;
 }
 
-bool ls::std::boxing::String::operator!=(const char *_value)
+bool String::operator!=(const char *_value)
 {
   return this->value != _value;
 }
 
-void ls::std::boxing::String::parse(::std::string _parseText)
+void String::parse(string _parseText)
 {
-  this->value = ::std::move(_parseText);
+  this->value = ::move(_parseText);
 }
 
-::std::string ls::std::boxing::String::toString()
+string String::toString()
 {
   return this->value;
 }
 
-bool ls::std::boxing::String::contains(const ::std::string &_text)
+bool String::contains(const string &_text)
 {
-  return this->value.find(_text) != ::std::string::npos;
+  return this->value.find(_text) != string::npos;
 }
 
-bool ls::std::boxing::String::endsWith(const ::std::string &_text)
+bool String::endsWith(const string &_text)
 {
   return this->value.rfind(_text) == (this->value.size() - _text.size());
 }
 
-bool ls::std::boxing::String::equalsIgnoreCase(ls::std::boxing::String _string)
+bool String::equalsIgnoreCase(String _string)
 {
   return this->toLowerCase() == _string.toLowerCase();
 }
 
-bool ls::std::boxing::String::equalsIgnoreCase(::std::string _text)
+bool String::equalsIgnoreCase(string _text)
 {
-  return this->toLowerCase() == ls::std::boxing::String{::std::move(_text)}.toLowerCase();
+  return this->toLowerCase() == String{::move(_text)}.toLowerCase();
 }
 
-::std::vector<ls::std::core::type::byte> ls::std::boxing::String::getByteData()
+vector<byte_type> String::getByteData()
 {
-  ::std::vector<ls::std::core::type::byte> byteData(this->value.begin(), this->value.end());
+  vector<byte_type> byteData(this->value.begin(), this->value.end());
   byteData.push_back('\0');
 
   return byteData;
 }
 
-::std::string ls::std::boxing::String::padLeft(size_t _width, const char _fillCharacter)
+string String::padLeft(size_t _width, const char _fillCharacter)
 {
-  return ls::std::boxing::String::_createFillContent(this->value, _width, _fillCharacter) + this->value;
+  return String::_createFillContent(this->value, _width, _fillCharacter) + this->value;
 }
 
-::std::string ls::std::boxing::String::padRight(size_t _width, const char _fillCharacter)
+string String::padRight(size_t _width, const char _fillCharacter)
 {
-  return this->value + ls::std::boxing::String::_createFillContent(this->value, _width, _fillCharacter);
+  return this->value + String::_createFillContent(this->value, _width, _fillCharacter);
 }
 
-::std::string ls::std::boxing::String::reverse()
+string String::reverse()
 {
-  ::std::string copy = this->value;
-  ::std::reverse(copy.begin(), copy.end());
+  string copy = this->value;
+  ::reverse(copy.begin(), copy.end());
 
   return copy;
 }
 
-bool ls::std::boxing::String::startsWith(const ::std::string &_text)
+bool String::startsWith(const string &_text)
 {
   return this->value.rfind(_text, 0) == 0;
 }
 
-::std::string ls::std::boxing::String::toLowerCase()
+string String::toLowerCase()
 {
-  ::std::string copy = this->value;
-  ::std::transform(copy.begin(), copy.end(), copy.begin(), ::tolower);
+  string copy = this->value;
+  transform(copy.begin(), copy.end(), copy.begin(), ::tolower);
 
   return copy;
 }
 
-::std::string ls::std::boxing::String::toUpperCase()
+string String::toUpperCase()
 {
-  ::std::string copy = this->value;
-  ::std::transform(copy.begin(), copy.end(), copy.begin(), ::toupper);
+  string copy = this->value;
+  transform(copy.begin(), copy.end(), copy.begin(), ::toupper);
 
   return copy;
 }
 
-::std::string ls::std::boxing::String::_buildCharacterChain(size_t _amount, const char _fillCharacter)
+string String::_buildCharacterChain(size_t _amount, const char _fillCharacter)
 {
-  ::std::string fillContent{};
+  string fillContent{};
 
-  for (size_t iteration{}; iteration < _amount; iteration++) { fillContent += _fillCharacter; }
+  for (size_t iteration{}; iteration < _amount; iteration++)
+  {
+    fillContent += _fillCharacter;
+  }
 
   return fillContent;
 }
 
-::std::string ls::std::boxing::String::_createFillContent(const ::std::string &_text, size_t _width, const char _fillCharacter)
+string String::_createFillContent(const string &_text, size_t _width, const char _fillCharacter)
 {
   size_t fillSize = _text.size() > _width ? 0 : _width - _text.size();
-  ::std::string fillContent{};
+  string fillContent{};
 
   if (fillSize > 0)
   {
-    fillContent = ls::std::boxing::String::_buildCharacterChain(fillSize, _fillCharacter);
+    fillContent = String::_buildCharacterChain(fillSize, _fillCharacter);
   }
 
   return fillContent;

source/ls-std/core/Class.cpp

@@ -3,27 +3,31 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-07
- * Changed:         2023-02-08
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/Class.hpp>
 #include <ls-std/core/evaluator/EmptyStringArgumentEvaluator.hpp>
 
-ls::std::core::Class::Class(const ::std::string &_name)
+using ls::std::core::Class;
+using ls::std::core::EmptyStringArgumentEvaluator;
+using std::string;
+
+Class::Class(const string &_name)
 {
   this->_assignClassName(_name);
 }
 
-ls::std::core::Class::~Class() = default;
+Class::~Class() = default;
 
-::std::string ls::std::core::Class::getClassName()
+string Class::getClassName()
 {
   return this->name;
 }
 
-void ls::std::core::Class::_assignClassName(const ::std::string &_name)
+void Class::_assignClassName(const string &_name)
 {
-  ls::std::core::EmptyStringArgumentEvaluator{_name, "class name is empty!"}.evaluate();
+  EmptyStringArgumentEvaluator{_name, "class name is empty!"}.evaluate();
   this->name = _name;
 }

source/ls-std/core/ConditionalFunctionExecutor.cpp

@@ -3,18 +3,21 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-13
-* Changed:         2023-02-21
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/core/ConditionalFunctionExecutor.hpp>
 
-ls::std::core::ConditionalFunctionExecutor::ConditionalFunctionExecutor(bool _condition) : condition(_condition)
+using ls::std::core::ConditionalFunctionExecutor;
+using std::function;
+
+ConditionalFunctionExecutor::ConditionalFunctionExecutor(bool _condition) : condition(_condition)
 {}
 
-ls::std::core::ConditionalFunctionExecutor::~ConditionalFunctionExecutor() = default;
+ConditionalFunctionExecutor::~ConditionalFunctionExecutor() = default;
 
-void ls::std::core::ConditionalFunctionExecutor::execute(const ::std::function<void()> &_function) const
+void ConditionalFunctionExecutor::execute(const function<void()> &_function) const
 {
   if (this->condition)
   {

source/ls-std/core/LibraryVersion.cpp

@@ -3,17 +3,20 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-05
-* Changed:         2023-02-05
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/core/LibraryVersion.hpp>
 
-ls::std::core::LibraryVersion::LibraryVersion() = default;
+using ls::std::core::LibraryVersion;
+using std::string;
 
-ls::std::core::LibraryVersion::~LibraryVersion() = default;
+LibraryVersion::LibraryVersion() = default;
 
-::std::string ls::std::core::LibraryVersion::getVersion()
+LibraryVersion::~LibraryVersion() = default;
+
+string LibraryVersion::getVersion()
 {
   return "2023.1.0";
 }

source/ls-std/core/Version.cpp

@@ -3,92 +3,101 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-28
- * Changed:         2023-02-04
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/Version.hpp>
 #include <regex>
 
-ls::std::core::Version::Version(ls::std::core::type::version_type _majorVersion, ls::std::core::type::version_type _minorVersion, ls::std::core::type::version_type _patchVersion) : majorVersion(_majorVersion), minorVersion(_minorVersion), patchVersion(_patchVersion)
+using ls::std::core::Version;
+using ls::std::core::type::byte_field;
+using ls::std::core::type::version_type;
+using std::regex;
+using std::regex_match;
+using std::stoi;
+using std::string;
+using std::to_string;
+
+Version::Version(version_type _majorVersion, version_type _minorVersion, version_type _patchVersion) : majorVersion(_majorVersion), minorVersion(_minorVersion), patchVersion(_patchVersion)
 {}
 
-ls::std::core::Version::~Version() = default;
+Version::~Version() noexcept = default;
 
-ls::std::core::type::byte_field ls::std::core::Version::marshal()
+byte_field Version::marshal()
 {
-  ls::std::core::type::byte_field data{};
+  byte_field data{};
 
-  data += ::std::to_string(this->majorVersion) + ".";
-  data += ::std::to_string(this->minorVersion) + ".";
-  data += ::std::to_string(this->patchVersion);
+  data += to_string(this->majorVersion) + ".";
+  data += to_string(this->minorVersion) + ".";
+  data += to_string(this->patchVersion);
 
   return data;
 }
 
-void ls::std::core::Version::unmarshal(const ls::std::core::type::byte_field &_data)
+void Version::unmarshal(const byte_field &_data)
 {
-  ::std::string field = _data;
+  string field = _data;
 
-  if (ls::std::core::Version::_isValid(_data))
+  if (Version::_isValid(_data))
   {
     size_t position = field.find('.');
-    ::std::string subSequence = field.substr(0, position);
-    this->majorVersion = ::std::stoi(subSequence);
+    string subSequence = field.substr(0, position);
+    this->majorVersion = stoi(subSequence);
     field.erase(0, position + 1);
 
     position = field.find('.');
     subSequence = field.substr(0, position);
-    this->minorVersion = ::std::stoi(subSequence);
+    this->minorVersion = stoi(subSequence);
     field.erase(0, position + 1);
 
-    this->patchVersion = ::std::stoi(field);
+    this->patchVersion = stoi(field);
   }
 }
 
-ls::std::core::type::version_type ls::std::core::Version::getMajorVersion() const
+version_type Version::getMajorVersion() const
 {
   return this->majorVersion;
 }
 
-ls::std::core::type::version_type ls::std::core::Version::getMinorVersion() const
+version_type Version::getMinorVersion() const
 {
   return this->minorVersion;
 }
 
-ls::std::core::type::version_type ls::std::core::Version::getPatchVersion() const
+version_type Version::getPatchVersion() const
 {
   return this->patchVersion;
 }
 
-bool ls::std::core::Version::isValid(const ::std::string &_versionString)
+bool Version::isValid(const string &_versionString)
 {
-  return ls::std::core::Version::_isValid(_versionString);
+  return Version::_isValid(_versionString);
 }
 
-void ls::std::core::Version::setMajorVersion(ls::std::core::type::version_type _major)
+void Version::setMajorVersion(version_type _major)
 {
   this->majorVersion = _major;
 }
 
-void ls::std::core::Version::setMinorVersion(ls::std::core::type::version_type _minor)
+void Version::setMinorVersion(version_type _minor)
 {
   this->minorVersion = _minor;
 }
 
-void ls::std::core::Version::setPatchVersion(ls::std::core::type::version_type _patch)
+void Version::setPatchVersion(version_type _patch)
 {
   this->patchVersion = _patch;
 }
 
-bool ls::std::core::Version::_isValid(const ::std::string &_versionString)
+bool Version::_isValid(const string &_versionString)
 {
   bool isValidVersionString{};
-  static ::std::regex versionRegex{R"(\d+[.]\d+[.]\d+)"};
+  static regex versionRegex{R"(\d+[.]\d+[.]\d+)"};
 
   if (!_versionString.empty())
   {
-    isValidVersionString = ::std::regex_match(_versionString.begin(), _versionString.end(), versionRegex);
+    isValidVersionString = regex_match(_versionString.begin(), _versionString.end(), versionRegex);
   }
 
   return isValidVersionString;

source/ls-std/core/evaluator/EmptyStringArgumentEvaluator.cpp

@@ -3,32 +3,37 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-02-08
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/core/evaluator/EmptyStringArgumentEvaluator.hpp>
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::core::EmptyStringArgumentEvaluator::EmptyStringArgumentEvaluator(::std::string _argument) : argument(::std::move(_argument))
+using ls::std::core::EmptyStringArgumentEvaluator;
+using ls::std::core::IllegalArgumentException;
+using std::move;
+using std::string;
+
+EmptyStringArgumentEvaluator::EmptyStringArgumentEvaluator(string _argument) : argument(::move(_argument))
 {}
 
-ls::std::core::EmptyStringArgumentEvaluator::EmptyStringArgumentEvaluator(::std::string _argument, ::std::string _message) : argument(::std::move(_argument)), message(::std::move(_message))
+EmptyStringArgumentEvaluator::EmptyStringArgumentEvaluator(string _argument, string _message) : argument(::move(_argument)), message(::move(_message))
 {}
 
-ls::std::core::EmptyStringArgumentEvaluator::~EmptyStringArgumentEvaluator() = default;
+EmptyStringArgumentEvaluator::~EmptyStringArgumentEvaluator() noexcept = default;
 
-void ls::std::core::EmptyStringArgumentEvaluator::evaluate()
+void EmptyStringArgumentEvaluator::evaluate()
 {
   if (this->argument.empty())
   {
     if (this->message.empty())
     {
-      throw ls::std::core::IllegalArgumentException{"passed argument is empty!"};
+      throw IllegalArgumentException{"passed argument is empty!"};
     }
     else
     {
-      throw ls::std::core::IllegalArgumentException{this->message};
+      throw IllegalArgumentException{this->message};
     }
   }
 }

source/ls-std/core/evaluator/IndexOutOfBoundsEvaluator.cpp

@@ -3,32 +3,37 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2023-02-10
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/core/evaluator/IndexOutOfBoundsEvaluator.hpp>
 #include <ls-std/core/exception/IndexOutOfBoundsException.hpp>
 
-ls::std::core::IndexOutOfBoundsEvaluator::IndexOutOfBoundsEvaluator(size_t _index, size_t _size) : index(_index), size(_size)
+using ls::std::core::IndexOutOfBoundsEvaluator;
+using ls::std::core::IndexOutOfBoundsException;
+using std::move;
+using std::string;
+
+IndexOutOfBoundsEvaluator::IndexOutOfBoundsEvaluator(size_t _index, size_t _size) : index(_index), size(_size)
 {}
 
-ls::std::core::IndexOutOfBoundsEvaluator::IndexOutOfBoundsEvaluator(size_t _index, size_t _size, ::std::string _message) : index(_index), size(_size), message(::std::move(_message))
+IndexOutOfBoundsEvaluator::IndexOutOfBoundsEvaluator(size_t _index, size_t _size, string _message) : index(_index), size(_size), message(::move(_message))
 {}
 
-ls::std::core::IndexOutOfBoundsEvaluator::~IndexOutOfBoundsEvaluator() = default;
+IndexOutOfBoundsEvaluator::~IndexOutOfBoundsEvaluator() noexcept = default;
 
-void ls::std::core::IndexOutOfBoundsEvaluator::evaluate()
+void IndexOutOfBoundsEvaluator::evaluate()
 {
   if (this->index >= this->size)
   {
     if (this->message.empty())
     {
-      throw ls::std::core::IndexOutOfBoundsException{};
+      throw IndexOutOfBoundsException{};
     }
     else
     {
-      throw ls::std::core::IndexOutOfBoundsException{this->message};
+      throw IndexOutOfBoundsException{this->message};
     }
   }
 }

source/ls-std/core/evaluator/NullPointerArgumentEvaluator.cpp

@@ -3,32 +3,38 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-02-08
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp>
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 
-ls::std::core::NullPointerArgumentEvaluator::NullPointerArgumentEvaluator(const ::std::shared_ptr<void> &_argument) : argument(_argument)
+using ls::std::core::IllegalArgumentException;
+using ls::std::core::NullPointerArgumentEvaluator;
+using std::move;
+using std::shared_ptr;
+using std::string;
+
+NullPointerArgumentEvaluator::NullPointerArgumentEvaluator(const shared_ptr<void> &_argument) : argument(_argument)
 {}
 
-ls::std::core::NullPointerArgumentEvaluator::NullPointerArgumentEvaluator(const ::std::shared_ptr<void> &_argument, ::std::string _message) : argument(_argument), message(::std::move(_message))
+NullPointerArgumentEvaluator::NullPointerArgumentEvaluator(const shared_ptr<void> &_argument, string _message) : argument(_argument), message(::move(_message))
 {}
 
-ls::std::core::NullPointerArgumentEvaluator::~NullPointerArgumentEvaluator() = default;
+NullPointerArgumentEvaluator::~NullPointerArgumentEvaluator() noexcept = default;
 
-void ls::std::core::NullPointerArgumentEvaluator::evaluate()
+void NullPointerArgumentEvaluator::evaluate()
 {
   if (this->argument == nullptr)
   {
     if (this->message.empty())
     {
-      throw ls::std::core::IllegalArgumentException{"passed argument is null!"};
+      throw IllegalArgumentException{"passed argument is null!"};
     }
     else
     {
-      throw ls::std::core::IllegalArgumentException{this->message};
+      throw IllegalArgumentException{this->message};
     }
   }
 }

source/ls-std/core/evaluator/NullPointerEvaluator.cpp

@@ -3,32 +3,38 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-02-08
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/core/evaluator/NullPointerEvaluator.hpp>
 #include <ls-std/core/exception/NullPointerException.hpp>
 
-ls::std::core::NullPointerEvaluator::NullPointerEvaluator(const ::std::shared_ptr<void> &_argument) : argument(_argument)
+using ls::std::core::NullPointerEvaluator;
+using ls::std::core::NullPointerException;
+using std::move;
+using std::shared_ptr;
+using std::string;
+
+NullPointerEvaluator::NullPointerEvaluator(const shared_ptr<void> &_argument) : argument(_argument)
 {}
 
-ls::std::core::NullPointerEvaluator::NullPointerEvaluator(const ::std::shared_ptr<void> &_argument, ::std::string _message) : argument(_argument), message(::std::move(_message))
+NullPointerEvaluator::NullPointerEvaluator(const shared_ptr<void> &_argument, string _message) : argument(_argument), message(::move(_message))
 {}
 
-ls::std::core::NullPointerEvaluator::~NullPointerEvaluator() = default;
+NullPointerEvaluator::~NullPointerEvaluator() noexcept = default;
 
-void ls::std::core::NullPointerEvaluator::evaluate()
+void NullPointerEvaluator::evaluate()
 {
   if (this->argument == nullptr)
   {
     if (this->message.empty())
     {
-      throw ls::std::core::NullPointerException{"reference in use is null!"};
+      throw NullPointerException{"reference in use is null!"};
     }
     else
     {
-      throw ls::std::core::NullPointerException{this->message};
+      throw NullPointerException{this->message};
     }
   }
 }

source/ls-std/core/exception/EventNotHandledException.cpp

@@ -3,26 +3,31 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2023-02-04
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/exception/EventNotHandledException.hpp>
 #include <ls-std/core/exception/ExceptionMessage.hpp>
 
-ls::std::core::EventNotHandledException::EventNotHandledException() : ls::std::core::Exception("EventNotHandledException")
+using ls::std::core::EventNotHandledException;
+using ls::std::core::Exception;
+using std::move;
+using std::string;
+
+EventNotHandledException::EventNotHandledException() : Exception("EventNotHandledException")
 {}
 
-ls::std::core::EventNotHandledException::EventNotHandledException(::std::string _message) : ls::std::core::EventNotHandledException()
+EventNotHandledException::EventNotHandledException(string _message) : EventNotHandledException()
 {
-  this->message = ::std::move(_message);
+  this->message = ::move(_message);
 }
 
-ls::std::core::EventNotHandledException::~EventNotHandledException() = default;
+EventNotHandledException::~EventNotHandledException() noexcept = default;
 
-const char *ls::std::core::EventNotHandledException::what() const noexcept
+const char *EventNotHandledException::what() const noexcept
 {
-  ::std::string concatenatedMessage = this->name + " thrown - ";
+  string concatenatedMessage = this->name + " thrown - ";
 
   if (this->message.empty())
   {

source/ls-std/core/exception/EventNotSubscribedException.cpp

@@ -3,26 +3,31 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2023-02-04
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/exception/EventNotSubscribedException.hpp>
 #include <ls-std/core/exception/ExceptionMessage.hpp>
 
-ls::std::core::EventNotSubscribedException::EventNotSubscribedException() : ls::std::core::Exception("EventNotSubscribedException")
+using ls::std::core::EventNotSubscribedException;
+using ls::std::core::Exception;
+using std::move;
+using std::string;
+
+EventNotSubscribedException::EventNotSubscribedException() : Exception("EventNotSubscribedException")
 {}
 
-ls::std::core::EventNotSubscribedException::EventNotSubscribedException(::std::string _message) : ls::std::core::EventNotSubscribedException()
+EventNotSubscribedException::EventNotSubscribedException(string _message) : EventNotSubscribedException()
 {
-  this->message = ::std::move(_message);
+  this->message = ::move(_message);
 }
 
-ls::std::core::EventNotSubscribedException::~EventNotSubscribedException() = default;
+EventNotSubscribedException::~EventNotSubscribedException() noexcept = default;
 
-const char *ls::std::core::EventNotSubscribedException::what() const noexcept
+const char *EventNotSubscribedException::what() const noexcept
 {
-  ::std::string concatenatedMessage = this->name + " thrown - ";
+  string concatenatedMessage = this->name + " thrown - ";
 
   if (this->message.empty())
   {

source/ls-std/core/exception/Exception.cpp

@@ -3,23 +3,27 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-22
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/core/exception/Exception.hpp>
 
-ls::std::core::Exception::Exception(::std::string _name) : name(::std::move(_name))
+using ls::std::core::Exception;
+using std::move;
+using std::string;
+
+Exception::Exception(string _name) : name(::move(_name))
 {}
 
-ls::std::core::Exception::~Exception() = default;
+Exception::~Exception() noexcept = default;
 
-::std::string ls::std::core::Exception::getName() const
+string Exception::getName() const
 {
   return this->name;
 }
 
-const char *ls::std::core::Exception::what() const noexcept
+const char *Exception::what() const noexcept
 {
-  return "base exception class class in use - method not implemented!";
+  return "base exception class in use - method not implemented!";
 }

source/ls-std/core/exception/ExceptionMessage.cpp

@@ -3,19 +3,23 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-07
-* Changed:         2023-02-07
+* Changed:         2023-02-23
 *
 * */
 
 #include <cstring>
 #include <ls-std/core/exception/ExceptionMessage.hpp>
 
-ls::std::core::ExceptionMessage::ExceptionMessage(::std::string _message) : message(::std::move(_message))
+using ls::std::core::ExceptionMessage;
+using std::move;
+using std::string;
+
+ExceptionMessage::ExceptionMessage(string _message) : message(::move(_message))
 {}
 
-ls::std::core::ExceptionMessage::~ExceptionMessage() = default;
+ExceptionMessage::~ExceptionMessage() = default;
 
-char *ls::std::core::ExceptionMessage::toCharacterPointer()
+char *ExceptionMessage::toCharacterPointer()
 {
   char *rawPointerMessage{};
 

source/ls-std/core/exception/FileNotFoundException.cpp

@@ -3,26 +3,31 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2023-02-04
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/exception/ExceptionMessage.hpp>
 #include <ls-std/core/exception/FileNotFoundException.hpp>
 
-ls::std::core::FileNotFoundException::FileNotFoundException() : ls::std::core::Exception("FileNotFoundException")
+using ls::std::core::Exception;
+using ls::std::core::FileNotFoundException;
+using std::move;
+using std::string;
+
+FileNotFoundException::FileNotFoundException() : Exception("FileNotFoundException")
 {}
 
-ls::std::core::FileNotFoundException::FileNotFoundException(::std::string _message) : ls::std::core::FileNotFoundException()
+FileNotFoundException::FileNotFoundException(string _message) : FileNotFoundException()
 {
-  this->message = ::std::move(_message);
+  this->message = ::move(_message);
 }
 
-ls::std::core::FileNotFoundException::~FileNotFoundException() = default;
+FileNotFoundException::~FileNotFoundException() noexcept = default;
 
-const char *ls::std::core::FileNotFoundException::what() const noexcept
+const char *FileNotFoundException::what() const noexcept
 {
-  ::std::string concatenatedMessage = this->name + " thrown - ";
+  string concatenatedMessage = this->name + " thrown - ";
 
   if (this->message.empty())
   {

source/ls-std/core/exception/FileOperationException.cpp

@@ -3,26 +3,31 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2023-02-04
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/exception/ExceptionMessage.hpp>
 #include <ls-std/core/exception/FileOperationException.hpp>
 
-ls::std::core::FileOperationException::FileOperationException() : ls::std::core::Exception("FileOperationException")
+using ls::std::core::Exception;
+using ls::std::core::FileOperationException;
+using std::move;
+using std::string;
+
+FileOperationException::FileOperationException() : Exception("FileOperationException")
 {}
 
-ls::std::core::FileOperationException::FileOperationException(::std::string _message) : ls::std::core::FileOperationException()
+FileOperationException::FileOperationException(string _message) : FileOperationException()
 {
-  this->message = ::std::move(_message);
+  this->message = ::move(_message);
 }
 
-ls::std::core::FileOperationException::~FileOperationException() = default;
+FileOperationException::~FileOperationException() noexcept = default;
 
-const char *ls::std::core::FileOperationException::what() const noexcept
+const char *FileOperationException::what() const noexcept
 {
-  ::std::string concatenatedMessage = this->name + " thrown - ";
+  string concatenatedMessage = this->name + " thrown - ";
 
   if (this->message.empty())
   {