Remove namespaces from core module class definitions

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-22
+ * 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() noexcept = 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-22
+* 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() noexcept = 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-22
+* 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() noexcept = 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-22
+* 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() noexcept = 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-22
+* 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() noexcept = 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() noexcept = 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() noexcept = 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() noexcept = 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 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() noexcept = 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() noexcept = 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())
   {

source/ls-std/core/exception/IllegalArgumentException.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/IllegalArgumentException.hpp>
 
-ls::std::core::IllegalArgumentException::IllegalArgumentException() : ls::std::core::Exception("IllegalArgumentException")
+using ls::std::core::Exception;
+using ls::std::core::IllegalArgumentException;
+using std::move;
+using std::string;
+
+IllegalArgumentException::IllegalArgumentException() : Exception("IllegalArgumentException")
 {}
 
-ls::std::core::IllegalArgumentException::IllegalArgumentException(::std::string _message) : ls::std::core::IllegalArgumentException()
+IllegalArgumentException::IllegalArgumentException(string _message) : IllegalArgumentException()
 {
-  this->message = ::std::move(_message);
+  this->message = ::move(_message);
 }
 
-ls::std::core::IllegalArgumentException::~IllegalArgumentException() noexcept = default;
+IllegalArgumentException::~IllegalArgumentException() noexcept = default;
 
-const char *ls::std::core::IllegalArgumentException::what() const noexcept
+const char *IllegalArgumentException::what() const noexcept
 {
-  ::std::string concatenatedMessage = this->name + " thrown - ";
+  string concatenatedMessage = this->name + " thrown - ";
 
   if (this->message.empty())
   {

source/ls-std/core/exception/IllegalArithmeticOperationException.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/IllegalArithmeticOperationException.hpp>
 
-ls::std::core::IllegalArithmeticOperationException::IllegalArithmeticOperationException() : ls::std::core::Exception("IllegalArithmeticOperationException")
+using ls::std::core::Exception;
+using ls::std::core::IllegalArithmeticOperationException;
+using std::move;
+using std::string;
+
+IllegalArithmeticOperationException::IllegalArithmeticOperationException() : Exception("IllegalArithmeticOperationException")
 {}
 
-ls::std::core::IllegalArithmeticOperationException::IllegalArithmeticOperationException(::std::string _message) : ls::std::core::IllegalArithmeticOperationException()
+IllegalArithmeticOperationException::IllegalArithmeticOperationException(string _message) : IllegalArithmeticOperationException()
 {
-  this->message = ::std::move(_message);
+  this->message = ::move(_message);
 }
 
-ls::std::core::IllegalArithmeticOperationException::~IllegalArithmeticOperationException() noexcept = default;
+IllegalArithmeticOperationException::~IllegalArithmeticOperationException() noexcept = default;
 
-const char *ls::std::core::IllegalArithmeticOperationException::what() const noexcept
+const char *IllegalArithmeticOperationException::what() const noexcept
 {
-  ::std::string concatenatedMessage = this->name + " thrown - ";
+  string concatenatedMessage = this->name + " thrown - ";
 
   if (this->message.empty())
   {

source/ls-std/core/exception/IncompleteJsonException.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/IncompleteJsonException.hpp>
 
-ls::std::core::IncompleteJsonException::IncompleteJsonException() : ls::std::core::Exception("IncompleteJsonException")
+using ls::std::core::Exception;
+using ls::std::core::IncompleteJsonException;
+using std::move;
+using std::string;
+
+IncompleteJsonException::IncompleteJsonException() : Exception("IncompleteJsonException")
 {}
 
-ls::std::core::IncompleteJsonException::IncompleteJsonException(::std::string _message) : ls::std::core::IncompleteJsonException()
+IncompleteJsonException::IncompleteJsonException(string _message) : IncompleteJsonException()
 {
-  this->message = ::std::move(_message);
+  this->message = ::move(_message);
 }
 
-ls::std::core::IncompleteJsonException::~IncompleteJsonException() noexcept = default;
+IncompleteJsonException::~IncompleteJsonException() noexcept = default;
 
-const char *ls::std::core::IncompleteJsonException::what() const noexcept
+const char *IncompleteJsonException::what() const noexcept
 {
-  ::std::string concatenatedMessage = this->name + " thrown - ";
+  string concatenatedMessage = this->name + " thrown - ";
 
   if (this->message.empty())
   {

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

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

source/ls-std/core/exception/NullPointerException.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/NullPointerException.hpp>
 
-ls::std::core::NullPointerException::NullPointerException() : ls::std::core::Exception("NullPointerException")
+using ls::std::core::Exception;
+using ls::std::core::NullPointerException;
+using std::move;
+using std::string;
+
+NullPointerException::NullPointerException() : Exception("NullPointerException")
 {}
 
-ls::std::core::NullPointerException::NullPointerException(::std::string _message) : ls::std::core::NullPointerException()
+NullPointerException::NullPointerException(string _message) : NullPointerException()
 {
-  this->message = ::std::move(_message);
+  this->message = ::move(_message);
 }
 
-ls::std::core::NullPointerException::~NullPointerException() noexcept = default;
+NullPointerException::~NullPointerException() noexcept = default;
 
-const char *ls::std::core::NullPointerException::what() const noexcept
+const char *NullPointerException::what() const noexcept
 {
-  ::std::string concatenatedMessage = this->name + " thrown - ";
+  string concatenatedMessage = this->name + " thrown - ";
 
   if (this->message.empty())
   {

source/ls-std/core/interface/IBoxing.cpp

@@ -3,12 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2023-02-04
- * Changed:         2023-02-04
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/interface/IBoxing.hpp>
 
-ls::std::core::interface_type::IBoxing::IBoxing() = default;
+using ls::std::core::interface_type::IBoxing;
 
-ls::std::core::interface_type::IBoxing::~IBoxing() = default;
+IBoxing::IBoxing() = default;
+
+IBoxing::~IBoxing() = default;

source/ls-std/core/interface/IEncoding.cpp

@@ -3,12 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2023-02-04
- * Changed:         2023-02-04
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/interface/IEncoding.hpp>
 
-ls::std::core::interface_type::IEncoding::IEncoding() = default;
+using ls::std::core::interface_type::IEncoding;
 
-ls::std::core::interface_type::IEncoding::~IEncoding() = default;
+IEncoding::IEncoding() = default;
+
+IEncoding::~IEncoding() = default;

source/ls-std/core/interface/IEvaluator.cpp

@@ -3,12 +3,14 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-02-08
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/core/interface/IEvaluator.hpp>
 
-ls::std::core::interface_type::IEvaluator::IEvaluator() = default;
+using ls::std::core::interface_type::IEvaluator;
 
-ls::std::core::interface_type::IEvaluator::~IEvaluator() = default;
+IEvaluator::IEvaluator() = default;
+
+IEvaluator::~IEvaluator() = default;

source/ls-std/core/interface/IEventSubscriber.cpp

@@ -3,12 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2023-02-04
- * Changed:         2023-02-04
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/interface/IEventSubscriber.hpp>
 
-ls::std::core::interface_type::IEventSubscriber::IEventSubscriber() = default;
+using ls::std::core::interface_type::IEventSubscriber;
 
-ls::std::core::interface_type::IEventSubscriber::~IEventSubscriber() = default;
+IEventSubscriber::IEventSubscriber() = default;
+
+IEventSubscriber::~IEventSubscriber() = default;

source/ls-std/core/interface/IListener.cpp

@@ -3,12 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2023-02-04
- * Changed:         2023-02-04
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/interface/IListener.hpp>
 
-ls::std::core::interface_type::IListener::IListener() = default;
+using ls::std::core::interface_type::IListener;
 
-ls::std::core::interface_type::IListener::~IListener() = default;
+IListener::IListener() = default;
+
+IListener::~IListener() = default;

source/ls-std/core/interface/IReader.cpp

@@ -3,12 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2023-02-04
- * Changed:         2023-02-04
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/interface/IReader.hpp>
 
-ls::std::core::interface_type::IReader::IReader() = default;
+using ls::std::core::interface_type::IReader;
 
-ls::std::core::interface_type::IReader::~IReader() = default;
+IReader::IReader() = default;
+
+IReader::~IReader() = default;

source/ls-std/core/interface/ISerializable.cpp

@@ -3,12 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2023-02-04
- * Changed:         2023-02-04
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/interface/ISerializable.hpp>
 
-ls::std::core::interface_type::ISerializable::ISerializable() = default;
+using ls::std::core::interface_type::ISerializable;
 
-ls::std::core::interface_type::ISerializable::~ISerializable() = default;
+ISerializable::ISerializable() = default;
+
+ISerializable::~ISerializable() = default;

source/ls-std/core/interface/IStorable.cpp

@@ -3,12 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2023-02-04
- * Changed:         2023-02-04
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/interface/IStorable.hpp>
 
-ls::std::core::interface_type::IStorable::IStorable() = default;
+using ls::std::core::interface_type::IStorable;
 
-ls::std::core::interface_type::IStorable::~IStorable() = default;
+IStorable::IStorable() = default;
+
+IStorable::~IStorable() = default;

source/ls-std/core/interface/IValidator.cpp

@@ -3,12 +3,14 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-02-08
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/core/interface/IValidator.hpp>
 
-ls::std::core::interface_type::IValidator::IValidator() = default;
+using ls::std::core::interface_type::IValidator;
 
-ls::std::core::interface_type::IValidator::~IValidator() = default;
+IValidator::IValidator() = default;
+
+IValidator::~IValidator() = default;

source/ls-std/core/interface/IWriter.cpp

@@ -3,12 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2023-02-04
- * Changed:         2023-02-04
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/interface/IWriter.hpp>
 
-ls::std::core::interface_type::IWriter::IWriter() = default;
+using ls::std::core::interface_type::IWriter;
 
-ls::std::core::interface_type::IWriter::~IWriter() = default;
+IWriter::IWriter() = default;
+
+IWriter::~IWriter() = default;