Remove namespaces from io module class definitions

source/ls-std/io/File.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
@@ -13,6 +13,7 @@
   #include <direct.h>
 #endif
 #include <fstream>
+#include <list>
 #include <ls-std/core/exception/FileOperationException.hpp>
 #include <ls-std/io/File.hpp>
 #include <ls-std/io/FilePathSeparator.hpp>
@@ -27,113 +28,134 @@
 #endif
 #include <vector>
 
-ls::std::io::File::File(::std::string _absoluteFilePath) : ls::std::core::Class("File"), absoluteFilePath(ls::std::io::File::_normalizePath(::std::move(_absoluteFilePath)))
+using ls::std::core::Class;
+using ls::std::core::FileOperationException;
+using ls::std::io::File;
+using ls::std::io::FilePathSeparator;
+using ls::std::io::FilePathSeparatorMatch;
+using std::find_if;
+using std::getline;
+using std::ifstream;
+using std::ios;
+using std::list;
+using std::move;
+using std::ofstream;
+using std::remove;
+using std::remove_if;
+using std::rename;
+using std::replace;
+using std::streampos;
+using std::string;
+using std::stringstream;
+using std::vector;
+
+File::File(string _absoluteFilePath) : Class("File"), absoluteFilePath(File::_normalizePath(::move(_absoluteFilePath)))
 {}
 
-ls::std::io::File::~File() noexcept = default;
+File::~File() noexcept = default;
 
-bool ls::std::io::File::operator==(ls::std::io::File &_file)
+bool File::operator==(File &_file)
 {
-  return ls::std::io::File::_equals(*this, _file);
+  return File::_equals(*this, _file);
 }
 
-bool ls::std::io::File::operator!=(ls::std::io::File &_file)
+bool File::operator!=(File &_file)
 {
-  return !ls::std::io::File::_equals(*this, _file);
+  return !File::_equals(*this, _file);
 }
 
-bool ls::std::io::File::canExecute()
+bool File::canExecute()
 {
-  return ls::std::io::File::_isExecutable(this->absoluteFilePath);
+  return File::_isExecutable(this->absoluteFilePath);
 }
 
-bool ls::std::io::File::canRead()
+bool File::canRead()
 {
   bool readable;
 
 #if defined(unix) || defined(__APPLE__)
-  readable = ls::std::io::File::_isReadableUnix(this->absoluteFilePath);
+  readable = File::_isReadableUnix(this->absoluteFilePath);
 #endif
 #ifdef _WIN32
-  readable = ls::std::io::File::_isReadableWindows(this->absoluteFilePath);
+  readable = File::_isReadableWindows(this->absoluteFilePath);
 #endif
 
   return readable;
 }
 
-bool ls::std::io::File::canWrite()
+bool File::canWrite()
 {
-  return ls::std::io::File::_isWritable(this->absoluteFilePath);
+  return File::_isWritable(this->absoluteFilePath);
 }
 
-void ls::std::io::File::createNewFile()
+void File::createNewFile()
 {
-  if (!ls::std::io::File::_exists(this->absoluteFilePath))
+  if (!File::_exists(this->absoluteFilePath))
   {
-    ::std::ofstream file{this->absoluteFilePath};
+    ofstream file{this->absoluteFilePath};
     file.close();
   }
   else
   {
-    throw ls::std::core::FileOperationException{"operation: create new file"};
+    throw FileOperationException{"operation: create new file"};
   }
 }
 
-bool ls::std::io::File::exists()
+bool File::exists()
 {
-  return ls::std::io::File::_exists(this->absoluteFilePath);
+  return File::_exists(this->absoluteFilePath);
 }
 
-::std::string ls::std::io::File::getAbsoluteFilePath()
+string File::getAbsoluteFilePath()
 {
   return this->absoluteFilePath;
 }
 
-::std::string ls::std::io::File::getName()
+string File::getName()
 {
-  ::std::string copy = this->absoluteFilePath;
+  string copy = this->absoluteFilePath;
 
   // if it's a directory, remove separator from end, if it does exist
 
-  if (ls::std::io::File::_isDirectory(this->absoluteFilePath))
+  if (File::_isDirectory(this->absoluteFilePath))
   {
-    copy.erase(::std::remove_if(copy.end() - 1, copy.end(), ls::std::io::FilePathSeparatorMatch()), copy.end());
+    copy.erase(remove_if(copy.end() - 1, copy.end(), FilePathSeparatorMatch()), copy.end());
   }
 
   // now get the file / directory name
 
-  auto base = ::std::find_if(copy.rbegin(), copy.rend(), ls::std::io::FilePathSeparatorMatch()).base();
-  return ::std::string{base, copy.end()};
+  auto base = find_if(copy.rbegin(), copy.rend(), FilePathSeparatorMatch()).base();
+  return string{base, copy.end()};
 }
 
-::std::string ls::std::io::File::getParent()
+string File::getParent()
 {
-  return ls::std::io::File::_getParent(this->absoluteFilePath);
+  return File::_getParent(this->absoluteFilePath);
 }
 
-::std::string ls::std::io::File::getWorkingDirectory()
+string File::getWorkingDirectory()
 {
-  ::std::string workingDirectory{};
+  string workingDirectory{};
 
 #if defined(unix) || defined(__APPLE__)
-  workingDirectory = ls::std::io::File::_getWorkingDirectoryUnix();
+  workingDirectory = File::_getWorkingDirectoryUnix();
 #endif
 #ifdef _WIN32
-  workingDirectory = ls::std::io::File::_getWorkingDirectoryWindows();
+  workingDirectory = File::_getWorkingDirectoryWindows();
 #endif
 
   return workingDirectory;
 }
 
-long ls::std::io::File::getSize()
+long File::getSize()
 {
-  ::std::streampos fileSize{};
+  streampos fileSize{};
 
-  if (ls::std::io::File::_exists(this->absoluteFilePath))
+  if (File::_exists(this->absoluteFilePath))
   {
-    ::std::ifstream fileHandler{this->absoluteFilePath, ::std::ios::in};
+    ifstream fileHandler{this->absoluteFilePath, ios::in};
     fileSize = fileHandler.tellg();
-    fileHandler.seekg(0, ::std::ios::end);
+    fileHandler.seekg(0, ios::end);
     fileSize = fileHandler.tellg() - fileSize;
     fileHandler.close();
   }
@@ -141,68 +163,68 @@ long ls::std::io::File::getSize()
   return (long) fileSize;
 }
 
-bool ls::std::io::File::isDirectory()
+bool File::isDirectory()
 {
-  return ls::std::io::File::_isDirectory(this->absoluteFilePath);
+  return File::_isDirectory(this->absoluteFilePath);
 }
 
-bool ls::std::io::File::isFile()
+bool File::isFile()
 {
-  return ls::std::io::File::_isFile(this->absoluteFilePath);
+  return File::_isFile(this->absoluteFilePath);
 }
 
-time_t ls::std::io::File::lastModified()
+time_t File::lastModified()
 {
-  return ls::std::io::File::_lastModified(this->absoluteFilePath);
+  return File::_lastModified(this->absoluteFilePath);
 }
 
-::std::list<::std::string> ls::std::io::File::list()
+::list<string> File::list()
 {
-  ::std::list<::std::string> fileList{};
+  ::list<string> fileList{};
 
-  if (ls::std::io::File::_isDirectory(this->absoluteFilePath))
+  if (File::_isDirectory(this->absoluteFilePath))
   {
-    fileList = ls::std::io::File::_list(this->absoluteFilePath);
+    fileList = File::_list(this->absoluteFilePath);
   }
 
   return fileList;
 }
 
-::std::list<::std::string> ls::std::io::File::listFiles()
+::list<string> File::listFiles()
 {
-  ::std::list<::std::string> fileList{};
+  ::list<string> fileList{};
 
-  if (ls::std::io::File::_isDirectory(this->absoluteFilePath))
+  if (File::_isDirectory(this->absoluteFilePath))
   {
-    fileList = ls::std::io::File::_listFiles(this->absoluteFilePath);
+    fileList = File::_listFiles(this->absoluteFilePath);
   }
 
   return fileList;
 }
 
-void ls::std::io::File::makeDirectory()
+void File::makeDirectory()
 {
-  if (!ls::std::io::File::_makeDirectory(this->absoluteFilePath))
+  if (!File::_makeDirectory(this->absoluteFilePath))
   {
-    throw ls::std::core::FileOperationException{"operation: create directory"};
+    throw FileOperationException{"operation: create directory"};
   }
 }
 
-void ls::std::io::File::makeDirectories()
+void File::makeDirectories()
 {
-  ::std::vector<::std::string> subDirectories = ls::std::io::File::_splitIntoSubDirectoryNames(this->absoluteFilePath);
-  const char separator = ls::std::io::FilePathSeparator::get();
-  ::std::string currentHierarchy{};
+  vector<string> subDirectories = File::_splitIntoSubDirectoryNames(this->absoluteFilePath);
+  const char separator = FilePathSeparator::get();
+  string currentHierarchy{};
 
   for (const auto &subDirectory : subDirectories)
   {
     currentHierarchy += subDirectory;
 
-    if (!ls::std::io::File::_exists(currentHierarchy + separator) && !currentHierarchy.empty())
+    if (!File::_exists(currentHierarchy + separator) && !currentHierarchy.empty())
     {
-      if (!ls::std::io::File::_makeDirectory(currentHierarchy))
+      if (!File::_makeDirectory(currentHierarchy))
       {
-        throw ls::std::core::FileOperationException{"operation: create directory"}; // TODO: add missing test
+        throw FileOperationException{"operation: create directory"};
       }
     }
 
@@ -210,22 +232,22 @@ void ls::std::io::File::makeDirectories()
   }
 }
 
-void ls::std::io::File::remove()
+void File::remove()
 {
-  if (ls::std::io::File::_isFile(this->absoluteFilePath))
+  if (File::_isFile(this->absoluteFilePath))
   {
-    ::std::remove(this->absoluteFilePath.c_str());
+    ::remove(this->absoluteFilePath.c_str());
   }
 
-  if (ls::std::io::File::_isDirectory(this->absoluteFilePath))
+  if (File::_isDirectory(this->absoluteFilePath))
   {
-    ls::std::io::File::_remove(this->absoluteFilePath);
+    File::_remove(this->absoluteFilePath);
   }
 }
 
-bool ls::std::io::File::renameTo(const ::std::string &_newName)
+bool File::renameTo(const string &_newName)
 {
-  bool renamed = ls::std::io::File::_renameTo(this->absoluteFilePath, _newName);
+  bool renamed = File::_renameTo(this->absoluteFilePath, _newName);
 
   if (renamed)
   {
@@ -235,17 +257,17 @@ bool ls::std::io::File::renameTo(const ::std::string &_newName)
   return renamed;
 }
 
-void ls::std::io::File::reset(const ::std::string &_newPath)
+void File::reset(const string &_newPath)
 {
-  this->absoluteFilePath = ls::std::io::File::_normalizePath(_newPath);
+  this->absoluteFilePath = File::_normalizePath(_newPath);
 }
 
 #ifdef _WIN32
 
-void ls::std::io::File::_addToFileListWindows(const ::std::string &_path, bool _withDirectories, WIN32_FIND_DATA _data, ::std::list<::std::string> &_list)
+void File::_addToFileListWindows(const string &_path, bool _withDirectories, WIN32_FIND_DATA _data, ::list<string> &_list)
 {
-  const char separator = ls::std::io::FilePathSeparator::get();
-  ::std::string absolutePath = _path + separator + _data.cFileName;
+  const char separator = FilePathSeparator::get();
+  string absolutePath = _path + separator + _data.cFileName;
 
   if (_withDirectories)
   {
@@ -253,7 +275,7 @@ void ls::std::io::File::_addToFileListWindows(const ::std::string &_path, bool _
   }
   else
   {
-    if (ls::std::io::File::_isFile(absolutePath))
+    if (File::_isFile(absolutePath))
     {
       _list.emplace_back(absolutePath);
     }
@@ -264,10 +286,10 @@ void ls::std::io::File::_addToFileListWindows(const ::std::string &_path, bool _
 
 #if defined(unix) || defined(__APPLE__)
 
-void ls::std::io::File::_addToFileListUnix(const ::std::string &_path, bool _withDirectories, dirent *directoryEntity, ::std::list<::std::string> &_list)
+void File::_addToFileListUnix(const string &_path, bool _withDirectories, dirent *directoryEntity, ::list<string> &_list)
 {
-  const char separator = ls::std::io::FilePathSeparator::get();
-  ::std::string absolutePath = _path + separator + directoryEntity->d_name;
+  const char separator = FilePathSeparator::get();
+  string absolutePath = _path + separator + directoryEntity->d_name;
 
   if (_withDirectories)
   {
@@ -275,7 +297,7 @@ void ls::std::io::File::_addToFileListUnix(const ::std::string &_path, bool _wit
   }
   else
   {
-    if (ls::std::io::File::_isFile(absolutePath))
+    if (File::_isFile(absolutePath))
     {
       _list.emplace_back(absolutePath);
     }
@@ -284,7 +306,7 @@ void ls::std::io::File::_addToFileListUnix(const ::std::string &_path, bool _wit
 
 #endif
 
-bool ls::std::io::File::_equals(ls::std::io::File &_file, ls::std::io::File &_foreignFile)
+bool File::_equals(File &_file, File &_foreignFile)
 {
   bool isEqual = _file.getAbsoluteFilePath() == _foreignFile.getAbsoluteFilePath();
 
@@ -298,7 +320,7 @@ bool ls::std::io::File::_equals(ls::std::io::File &_file, ls::std::io::File &_fo
   return isEqual;
 }
 
-bool ls::std::io::File::_exists(const ::std::string &_path)
+bool File::_exists(const string &_path)
 {
   struct stat _stat
   {
@@ -306,11 +328,11 @@ bool ls::std::io::File::_exists(const ::std::string &_path)
   return (stat(_path.c_str(), &_stat) == 0);
 }
 
-::std::string ls::std::io::File::_getParent(const ::std::string &_path)
+string File::_getParent(const string &_path)
 {
-  ::std::string parent{};
-  ::std::vector<::std::string> subDirectoryNames = ls::std::io::File::_splitIntoSubDirectoryNames(_path);
-  const char separator = ls::std::io::FilePathSeparator::get();
+  string parent{};
+  vector<string> subDirectoryNames = File::_splitIntoSubDirectoryNames(_path);
+  const char separator = FilePathSeparator::get();
   subDirectoryNames.pop_back();
 
   for (auto const &subDirectoryName : subDirectoryNames)
@@ -323,18 +345,18 @@ bool ls::std::io::File::_exists(const ::std::string &_path)
 
 #if defined(unix) || defined(__APPLE__)
 
-::std::string ls::std::io::File::_getWorkingDirectoryUnix()
+string File::_getWorkingDirectoryUnix()
 {
-  ::std::string workingDirectory{};
+  string workingDirectory{};
   char buffer[PATH_MAX];
 
   if (getcwd(buffer, sizeof(buffer)) == nullptr)
   {
-    throw ls::std::core::FileOperationException{"operation: get working directory"};
+    throw FileOperationException{"operation: get working directory"};
   }
   else
   {
-    workingDirectory = ::std::string(buffer);
+    workingDirectory = string(buffer);
   }
 
   return workingDirectory;
@@ -344,18 +366,18 @@ bool ls::std::io::File::_exists(const ::std::string &_path)
 
 #ifdef _WIN32
 
-::std::string ls::std::io::File::_getWorkingDirectoryWindows()
+string File::_getWorkingDirectoryWindows()
 {
-  ::std::string workingDirectory{};
+  string workingDirectory{};
   TCHAR buffer[MAX_PATH];
 
   if (!GetCurrentDirectory(MAX_PATH, buffer))
   {
-    throw ls::std::core::FileOperationException{"operation: get working directory"};
+    throw FileOperationException{"operation: get working directory"};
   }
   else
   {
-    workingDirectory = ::std::string(buffer);
+    workingDirectory = string(buffer);
   }
 
   return workingDirectory;
@@ -363,7 +385,7 @@ bool ls::std::io::File::_exists(const ::std::string &_path)
 
 #endif
 
-bool ls::std::io::File::_isDirectory(const ::std::string &_path)
+bool File::_isDirectory(const string &_path)
 {
   bool match{};
   struct stat _stat
@@ -378,11 +400,11 @@ bool ls::std::io::File::_isDirectory(const ::std::string &_path)
   return match;
 }
 
-bool ls::std::io::File::_isExecutable(const ::std::string &_path)
+bool File::_isExecutable(const string &_path)
 {
   bool executable{};
 
-  if (ls::std::io::File::_exists(_path))
+  if (File::_exists(_path))
   {
     struct stat _stat
     {
@@ -397,7 +419,7 @@ bool ls::std::io::File::_isExecutable(const ::std::string &_path)
   return executable;
 }
 
-bool ls::std::io::File::_isFile(const ::std::string &_path)
+bool File::_isFile(const string &_path)
 {
   bool match{};
   struct stat _stat
@@ -414,11 +436,11 @@ bool ls::std::io::File::_isFile(const ::std::string &_path)
 
 #if defined(unix) || defined(__APPLE__)
 
-bool ls::std::io::File::_isReadableUnix(const ::std::string &_path)
+bool File::_isReadableUnix(const string &_path)
 {
   bool readable{};
 
-  if (ls::std::io::File::_exists(_path))
+  if (File::_exists(_path))
   {
     struct stat _stat
     {
@@ -431,7 +453,7 @@ bool ls::std::io::File::_isReadableUnix(const ::std::string &_path)
   }
   else
   {
-    throw ls::std::core::FileOperationException{"operation: fetch permissions"};
+    throw FileOperationException{"operation: fetch permissions"};
   }
 
   return readable;
@@ -441,7 +463,7 @@ bool ls::std::io::File::_isReadableUnix(const ::std::string &_path)
 
 #ifdef _WIN32
 
-bool ls::std::io::File::_isReadableWindows(const ::std::string &_path)
+bool File::_isReadableWindows(const string &_path)
 {
   bool readable;
   WIN32_FIND_DATA data{};
@@ -453,7 +475,7 @@ bool ls::std::io::File::_isReadableWindows(const ::std::string &_path)
   }
   else
   {
-    throw ls::std::core::FileOperationException{"operation: fetch permissions"};
+    throw FileOperationException{"operation: fetch permissions"};
   }
 
   return readable;
@@ -461,11 +483,11 @@ bool ls::std::io::File::_isReadableWindows(const ::std::string &_path)
 
 #endif
 
-bool ls::std::io::File::_isWritable(const ::std::string &_path)
+bool File::_isWritable(const string &_path)
 {
   bool writable{};
 
-  if (ls::std::io::File::_exists(_path))
+  if (File::_exists(_path))
   {
     struct stat _stat
     {
@@ -480,7 +502,7 @@ bool ls::std::io::File::_isWritable(const ::std::string &_path)
   return writable;
 }
 
-time_t ls::std::io::File::_lastModified(const ::std::string &_path)
+time_t File::_lastModified(const string &_path)
 {
   time_t lastModifiedTimeStamp{};
   struct stat _stat
@@ -495,29 +517,29 @@ time_t ls::std::io::File::_lastModified(const ::std::string &_path)
   return lastModifiedTimeStamp;
 }
 
-::std::list<::std::string> ls::std::io::File::_list(const ::std::string &_path)
+::list<string> File::_list(const string &_path)
 {
-  ::std::list<::std::string> filesInDirectory{};
+  ::list<string> filesInDirectory{};
 
 #if defined(unix) || defined(__APPLE__)
-  filesInDirectory = ls::std::io::File::_listUnix(_path, true);
+  filesInDirectory = File::_listUnix(_path, true);
 #endif
 #ifdef _WIN32
-  filesInDirectory = ls::std::io::File::_listWindows(_path, true);
+  filesInDirectory = File::_listWindows(_path, true);
 #endif
 
   return filesInDirectory;
 }
 
-::std::list<::std::string> ls::std::io::File::_listFiles(const ::std::string &_path)
+::list<string> File::_listFiles(const string &_path)
 {
-  ::std::list<::std::string> filesInDirectory{};
+  ::list<string> filesInDirectory{};
 
 #if defined(unix) || defined(__APPLE__)
-  filesInDirectory = ls::std::io::File::_listUnix(_path, false);
+  filesInDirectory = File::_listUnix(_path, false);
 #endif
 #ifdef _WIN32
-  filesInDirectory = ls::std::io::File::_listWindows(_path, false);
+  filesInDirectory = File::_listWindows(_path, false);
 #endif
 
   return filesInDirectory;
@@ -525,16 +547,16 @@ time_t ls::std::io::File::_lastModified(const ::std::string &_path)
 
 #if defined(unix) || defined(__APPLE__)
 
-::std::list<::std::string> ls::std::io::File::_listUnix(const ::std::string &_path, bool withDirectories)
+::list<string> File::_listUnix(const string &_path, bool withDirectories)
 {
-  ::std::list<::std::string> filesInDirectory{};
+  ::list<string> filesInDirectory{};
   DIR *directory = opendir(_path.c_str());
   struct dirent *directoryEntity;
-  ::std::string absolutePath{};
+  string absolutePath{};
 
   while ((directoryEntity = readdir(directory)) != nullptr)
   {
-    ls::std::io::File::_addToFileListUnix(_path, withDirectories, directoryEntity, filesInDirectory);
+    File::_addToFileListUnix(_path, withDirectories, directoryEntity, filesInDirectory);
   }
 
   closedir(directory);
@@ -545,18 +567,18 @@ time_t ls::std::io::File::_lastModified(const ::std::string &_path)
 
 #ifdef _WIN32
 
-::std::list<::std::string> ls::std::io::File::_listWindows(const ::std::string &_path, bool withDirectories)
+::list<string> File::_listWindows(const string &_path, bool withDirectories)
 {
-  ::std::list<::std::string> filesInDirectory{};
+  ::list<string> filesInDirectory{};
   WIN32_FIND_DATA data{};
   HANDLE hFind;
-  ::std::string pattern{_path + ls::std::io::FilePathSeparator::get() + "*"};
+  string pattern{_path + FilePathSeparator::get() + "*"};
 
   if ((hFind = FindFirstFile(pattern.c_str(), &data)) != INVALID_HANDLE_VALUE)
   {
     do
     {
-      ls::std::io::File::_addToFileListWindows(_path, withDirectories, data, filesInDirectory);
+      File::_addToFileListWindows(_path, withDirectories, data, filesInDirectory);
     } while (FindNextFile(hFind, &data) != 0);
 
     FindClose(hFind);
@@ -567,7 +589,7 @@ time_t ls::std::io::File::_lastModified(const ::std::string &_path)
 
 #endif
 
-bool ls::std::io::File::_makeDirectory(const ::std::string &_path)
+bool File::_makeDirectory(const string &_path)
 {
   int result;
 
@@ -582,18 +604,18 @@ bool ls::std::io::File::_makeDirectory(const ::std::string &_path)
   return result == 0;
 }
 
-::std::string ls::std::io::File::_normalizePath(::std::string _path)
+string File::_normalizePath(string _path)
 {
-  _path = ls::std::io::File::_replaceWrongSeparator(_path);
-  _path = ls::std::io::File::_reduceSeparators(_path);
+  _path = File::_replaceWrongSeparator(_path);
+  _path = File::_reduceSeparators(_path);
 
   return _path;
 }
 
-::std::string ls::std::io::File::_reduceSeparators(const ::std::string &_path)
+string File::_reduceSeparators(const string &_path)
 {
-  static const char separator = {ls::std::io::FilePathSeparator::get()};
-  ::std::string normalizedPath{};
+  static const char separator = {FilePathSeparator::get()};
+  string normalizedPath{};
   int index{};
 
   while (index < _path.size())
@@ -617,19 +639,19 @@ bool ls::std::io::File::_makeDirectory(const ::std::string &_path)
   return normalizedPath;
 }
 
-void ls::std::io::File::_remove(const ::std::string &_path)
+void File::_remove(const string &_path)
 {
 #if defined(unix) || defined(__APPLE__)
-  ls::std::io::File::_removeUnix(_path);
+  File::_removeUnix(_path);
 #endif
 #ifdef _WIN32
-  ls::std::io::File::_removeWindows(_path);
+  File::_removeWindows(_path);
 #endif
 }
 
 #if defined(unix) || defined(__APPLE__)
 
-void ls::std::io::File::_removeUnix(const ::std::string &_path)
+void File::_removeUnix(const string &_path)
 {
   rmdir(_path.c_str());
 }
@@ -638,42 +660,42 @@ void ls::std::io::File::_removeUnix(const ::std::string &_path)
 
 #ifdef _WIN32
 
-void ls::std::io::File::_removeWindows(const ::std::string &_path)
+void File::_removeWindows(const string &_path)
 {
   _rmdir(_path.c_str());
 }
 
 #endif
 
-bool ls::std::io::File::_renameTo(const ::std::string &_oldName, const ::std::string &_newName)
+bool File::_renameTo(const string &_oldName, const string &_newName)
 {
-  return ::std::rename(_oldName.c_str(), _newName.c_str()) == 0;
+  return rename(_oldName.c_str(), _newName.c_str()) == 0;
 }
 
-::std::string ls::std::io::File::_replaceWrongSeparator(::std::string _path)
+string File::_replaceWrongSeparator(string _path)
 {
-  static const char unixSeparator = ls::std::io::FilePathSeparator::getUnixFilePathSeparator();
-  static const char windowsSeparator = ls::std::io::FilePathSeparator::getWindowsFilePathSeparator();
+  static const char unixSeparator = FilePathSeparator::getUnixFilePathSeparator();
+  static const char windowsSeparator = FilePathSeparator::getWindowsFilePathSeparator();
 
 #if defined(unix) || defined(__APPLE__)
-  ::std::replace(_path.begin(), _path.end(), windowsSeparator, unixSeparator);
+  replace(_path.begin(), _path.end(), windowsSeparator, unixSeparator);
 #endif
 
 #ifdef _WIN32
-  ::std::replace(_path.begin(), _path.end(), unixSeparator, windowsSeparator);
+  replace(_path.begin(), _path.end(), unixSeparator, windowsSeparator);
 #endif
 
   return _path;
 }
 
-::std::vector<::std::string> ls::std::io::File::_splitIntoSubDirectoryNames(const ::std::string &_path)
+vector<string> File::_splitIntoSubDirectoryNames(const string &_path)
 {
-  ::std::vector<::std::string> subDirectoryNames{};
-  ::std::stringstream _stream{_path};
-  ::std::string subDirectoryName{};
-  const char separator = ls::std::io::FilePathSeparator::get();
+  vector<string> subDirectoryNames{};
+  stringstream _stream{_path};
+  string subDirectoryName{};
+  const char separator = FilePathSeparator::get();
 
-  while (::std::getline(_stream, subDirectoryName, separator))
+  while (getline(_stream, subDirectoryName, separator))
   {
     subDirectoryNames.push_back(subDirectoryName);
   }

source/ls-std/io/FileOutputStream.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
@@ -11,27 +11,35 @@
 #include <ls-std/io/FileOutputStream.hpp>
 #include <ls-std/io/evaluator/FileExistenceEvaluator.hpp>
 
-ls::std::io::FileOutputStream::FileOutputStream(ls::std::io::File &_file) : ls::std::core::Class("FileOutputStream"), file(_file)
+using ls::std::core::Class;
+using ls::std::core::FileOperationException;
+using ls::std::core::type::byte_field;
+using ls::std::io::File;
+using ls::std::io::FileExistenceEvaluator;
+using ls::std::io::FileOutputStream;
+using std::ios;
+
+FileOutputStream::FileOutputStream(File &_file) : Class("FileOutputStream"), file(_file)
 {
   this->_init();
 }
 
-ls::std::io::FileOutputStream::FileOutputStream(ls::std::io::File &_file, bool _append) : ls::std::core::Class("FileOutputStream"), append(_append), file(_file)
+FileOutputStream::FileOutputStream(File &_file, bool _append) : Class("FileOutputStream"), append(_append), file(_file)
 {
   this->_init();
 }
 
-ls::std::io::FileOutputStream::~FileOutputStream() noexcept
+FileOutputStream::~FileOutputStream() noexcept
 {
   this->_close();
 }
 
-void ls::std::io::FileOutputStream::close()
+void FileOutputStream::close()
 {
   this->_close();
 }
 
-bool ls::std::io::FileOutputStream::write(const ls::std::core::type::byte_field &_data)
+bool FileOutputStream::write(const byte_field &_data)
 {
   bool succeeded{};
 
@@ -44,13 +52,13 @@ bool ls::std::io::FileOutputStream::write(const ls::std::core::type::byte_field
   }
   else
   {
-    throw ls::std::core::FileOperationException{"operation: write"};
+    throw FileOperationException{"operation: write"};
   }
 
   return succeeded;
 }
 
-void ls::std::io::FileOutputStream::_close()
+void FileOutputStream::_close()
 {
   if (this->outputStream.is_open())
   {
@@ -58,13 +66,13 @@ void ls::std::io::FileOutputStream::_close()
   }
 }
 
-void ls::std::io::FileOutputStream::_init()
+void FileOutputStream::_init()
 {
-  ls::std::io::FileExistenceEvaluator{this->file.getAbsoluteFilePath()}.evaluate();
+  FileExistenceEvaluator{this->file.getAbsoluteFilePath()}.evaluate();
 
   if (this->append)
   {
-    this->outputStream.open(this->file.getAbsoluteFilePath(), ::std::ios::out | ::std::ios::app);
+    this->outputStream.open(this->file.getAbsoluteFilePath(), ios::out | ios::app);
   }
   else
   {

source/ls-std/io/FilePathSeparator.cpp

@@ -3,36 +3,37 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-04
-* Changed:         2023-02-04
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/io/FilePathSeparator.hpp>
 
-ls::std::io::FilePathSeparator::FilePathSeparator() = default;
+using ls::std::io::FilePathSeparator;
 
-ls::std::io::FilePathSeparator::~FilePathSeparator() = default;
+FilePathSeparator::FilePathSeparator() = default;
 
-char ls::std::io::FilePathSeparator::get()
-{
-  char separator;
+FilePathSeparator::~FilePathSeparator() = default;
 
-#ifdef _WIN32
-  separator = ls::std::io::FilePathSeparator::getWindowsFilePathSeparator();
-#endif
 #if defined(unix) || defined(__APPLE__)
-  separator = ls::std::io::FilePathSeparator::getUnixFilePathSeparator();
+char FilePathSeparator::get()
+{
+  return '/';
+}
 #endif
-
-  return separator;
+#ifdef _WIN32
+char FilePathSeparator::get()
+{
+  return '\\';
 }
+#endif
 
-char ls::std::io::FilePathSeparator::getUnixFilePathSeparator()
+char FilePathSeparator::getUnixFilePathSeparator()
 {
   return '/';
 }
 
-char ls::std::io::FilePathSeparator::getWindowsFilePathSeparator()
+char FilePathSeparator::getWindowsFilePathSeparator()
 {
   return '\\';
 }

source/ls-std/io/FilePathSeparatorMatch.cpp

@@ -3,18 +3,21 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-05
-* Changed:         2023-02-05
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/io/FilePathSeparator.hpp>
 #include <ls-std/io/FilePathSeparatorMatch.hpp>
 
-ls::std::io::FilePathSeparatorMatch::FilePathSeparatorMatch() = default;
+using ls::std::io::FilePathSeparator;
+using ls::std::io::FilePathSeparatorMatch;
 
-ls::std::io::FilePathSeparatorMatch::~FilePathSeparatorMatch() = default;
+FilePathSeparatorMatch::FilePathSeparatorMatch() = default;
 
-bool ls::std::io::FilePathSeparatorMatch::operator()(char _char) const
+FilePathSeparatorMatch::~FilePathSeparatorMatch() = default;
+
+bool FilePathSeparatorMatch::operator()(char _char) const
 {
-  return _char == ls::std::io::FilePathSeparator::getWindowsFilePathSeparator() || _char == ls::std::io::FilePathSeparator::getUnixFilePathSeparator();
+  return _char == FilePathSeparator::getWindowsFilePathSeparator() || _char == FilePathSeparator::getUnixFilePathSeparator();
 }

source/ls-std/io/FileReader.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
@@ -12,35 +12,44 @@
 #include <ls-std/io/FileReader.hpp>
 #include <ls-std/io/evaluator/FileExistenceEvaluator.hpp>
 
-ls::std::io::FileReader::FileReader(ls::std::io::File &_file) : ls::std::core::Class("FileReader"), file(_file)
+using ls::std::core::Class;
+using ls::std::core::FileOperationException;
+using ls::std::core::type::byte;
+using ls::std::core::type::byte_field;
+using ls::std::io::File;
+using ls::std::io::FileExistenceEvaluator;
+using ls::std::io::FileReader;
+using std::ifstream;
+
+FileReader::FileReader(File &_file) : Class("FileReader"), file(_file)
 {
-  ls::std::io::FileExistenceEvaluator{_file.getAbsoluteFilePath()}.evaluate();
+  FileExistenceEvaluator{_file.getAbsoluteFilePath()}.evaluate();
 }
 
-ls::std::io::FileReader::~FileReader() noexcept = default;
+FileReader::~FileReader() noexcept = default;
 
-ls::std::core::type::byte_field ls::std::io::FileReader::read()
+byte_field FileReader::read()
 {
-  ls::std::core::type::byte *data;
-  ::std::ifstream inputStream{this->file.getAbsoluteFilePath(), ::std::ifstream::binary};
+  byte *data;
+  ifstream inputStream{this->file.getAbsoluteFilePath(), ifstream::binary};
   int length = (int) this->file.getSize();
-  data = new ls::std::core::type::byte[length];
+  data = new byte[length];
   inputStream.read(data, length);
 
   if (inputStream.fail())
   {
-    throw ls::std::core::FileOperationException{"operation: read"};
+    throw FileOperationException{"operation: read"};
   }
 
   inputStream.close();
-  ls::std::core::type::byte_field readData = ls::std::core::type::byte_field{data, (size_t) this->file.getSize()};
+  byte_field readData = byte_field{data, (size_t) this->file.getSize()};
   delete[] data;
 
   return readData;
 }
 
-void ls::std::io::FileReader::reset(ls::std::io::File &_file)
+void FileReader::reset(File &_file)
 {
-  ls::std::io::FileExistenceEvaluator{_file.getAbsoluteFilePath()}.evaluate();
+  FileExistenceEvaluator{_file.getAbsoluteFilePath()}.evaluate();
   this->file = _file;
 }

source/ls-std/io/FileWriter.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
@@ -11,22 +11,29 @@
 #include <ls-std/io/FileWriter.hpp>
 #include <ls-std/io/evaluator/FileExistenceEvaluator.hpp>
 
-ls::std::io::FileWriter::FileWriter(ls::std::io::File &_file) : ls::std::core::Class("FileWriter"), file(_file)
+using ls::std::core::Class;
+using ls::std::core::type::byte_field;
+using ls::std::io::File;
+using ls::std::io::FileExistenceEvaluator;
+using ls::std::io::FileWriter;
+using ::std::ofstream;
+
+FileWriter::FileWriter(File &_file) : Class("FileWriter"), file(_file)
 {
-  ls::std::io::FileExistenceEvaluator{_file.getAbsoluteFilePath()}.evaluate();
+  FileExistenceEvaluator{_file.getAbsoluteFilePath()}.evaluate();
 }
 
-ls::std::io::FileWriter::~FileWriter() noexcept = default;
+FileWriter::~FileWriter() noexcept = default;
 
-void ls::std::io::FileWriter::reset(ls::std::io::File &_file)
+void FileWriter::reset(File &_file)
 {
-  ls::std::io::FileExistenceEvaluator{_file.getAbsoluteFilePath()}.evaluate();
+  FileExistenceEvaluator{_file.getAbsoluteFilePath()}.evaluate();
   this->file = _file;
 }
 
-bool ls::std::io::FileWriter::write(const ls::std::core::type::byte_field &_data)
+bool FileWriter::write(const byte_field &_data)
 {
-  ::std::ofstream outputStream{};
+  ofstream outputStream{};
   outputStream.open(this->file.getAbsoluteFilePath());
   outputStream << _data;
 

source/ls-std/io/NewLine.cpp

@@ -3,36 +3,39 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-04
-* Changed:         2023-02-04
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/io/NewLine.hpp>
 
-ls::std::io::NewLine::NewLine() = default;
+using ls::std::io::NewLine;
+using std::string;
 
-ls::std::io::NewLine::~NewLine() = default;
+NewLine::NewLine() = default;
 
-::std::string ls::std::io::NewLine::get()
+NewLine::~NewLine() = default;
+
+string NewLine::get()
 {
-  ::std::string newLine{};
+  string newLine{};
 
 #if defined(unix) || defined(__APPLE__)
-  newLine = ls::std::io::NewLine::getUnixNewLine();
+  newLine = NewLine::getUnixNewLine();
 #endif
 #ifdef _WIN32
-  newLine = ls::std::io::NewLine::getWindowsNewLine();
+  newLine = NewLine::getWindowsNewLine();
 #endif
 
   return newLine;
 }
 
-::std::string ls::std::io::NewLine::getUnixNewLine()
+string NewLine::getUnixNewLine()
 {
   return "\n";
 }
 
-::std::string ls::std::io::NewLine::getWindowsNewLine()
+string NewLine::getWindowsNewLine()
 {
   return "\r\n";
 }

source/ls-std/io/StandardOutputWriter.cpp

@@ -3,19 +3,23 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-06
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
 #include <iostream>
 #include <ls-std/io/StandardOutputWriter.hpp>
 
-ls::std::io::StandardOutputWriter::StandardOutputWriter() = default;
+using ls::std::core::type::byte_field;
+using ls::std::io::StandardOutputWriter;
+using std::cout;
 
-ls::std::io::StandardOutputWriter::~StandardOutputWriter() noexcept = default;
+StandardOutputWriter::StandardOutputWriter() = default;
 
-bool ls::std::io::StandardOutputWriter::write(const ls::std::core::type::byte_field &_data)
+StandardOutputWriter::~StandardOutputWriter() noexcept = default;
+
+bool StandardOutputWriter::write(const byte_field &_data)
 {
-  ::std::cout << _data;
-  return !::std::cout.fail();
+  cout << _data;
+  return !cout.fail();
 }

source/ls-std/io/StorableFile.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
@@ -11,40 +11,49 @@
 #include <ls-std/io/FileWriter.hpp>
 #include <ls-std/io/StorableFile.hpp>
 
-ls::std::io::StorableFile::StorableFile(const ::std::string &_path)
+using ls::std::core::type::byte_field;
+using ls::std::io::File;
+using ls::std::io::FileReader;
+using ls::std::io::FileWriter;
+using ls::std::io::StorableFile;
+using std::make_shared;
+using std::shared_ptr;
+using std::string;
+
+StorableFile::StorableFile(const string &_path)
 {
   this->_init(_path);
 }
 
-ls::std::io::StorableFile::~StorableFile() noexcept = default;
+StorableFile::~StorableFile() noexcept = default;
 
-::std::shared_ptr<ls::std::io::File> ls::std::io::StorableFile::getFile()
+shared_ptr<File> StorableFile::getFile()
 {
   return this->file;
 }
 
-ls::std::core::type::byte_field ls::std::io::StorableFile::load()
+byte_field StorableFile::load()
 {
-  ls::std::io::FileReader reader{*this->file};
+  FileReader reader{*this->file};
   return reader.read();
 }
 
-void ls::std::io::StorableFile::reset(const ::std::string &_path)
+void StorableFile::reset(const string &_path)
 {
   this->_init(_path);
 }
 
-void ls::std::io::StorableFile::save(const ls::std::core::type::byte_field &_data)
+void StorableFile::save(const byte_field &_data)
 {
-  ls::std::io::FileWriter writer{*this->file};
+  FileWriter writer{*this->file};
   writer.write(_data);
 }
 
-void ls::std::io::StorableFile::_init(const ::std::string &_path)
+void StorableFile::_init(const string &_path)
 {
   if (this->file == nullptr)
   {
-    this->file = ::std::make_shared<ls::std::io::File>(_path);
+    this->file = make_shared<File>(_path);
   }
   else
   {

source/ls-std/io/evaluator/FileExistenceEvaluator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -12,16 +12,23 @@
 #include <ls-std/io/evaluator/FileExistenceEvaluator.hpp>
 #include <string>
 
-ls::std::io::FileExistenceEvaluator::FileExistenceEvaluator(::std::string _filePath) : ls::std::core::Class("FileExistenceEvaluator"), filePath(::std::move(_filePath))
+using ls::std::core::Class;
+using ls::std::core::FileNotFoundException;
+using ls::std::io::File;
+using ls::std::io::FileExistenceEvaluator;
+using std::move;
+using std::string;
+
+FileExistenceEvaluator::FileExistenceEvaluator(string _filePath) : Class("FileExistenceEvaluator"), filePath(::move(_filePath))
 {}
 
-ls::std::io::FileExistenceEvaluator::~FileExistenceEvaluator() noexcept = default;
+FileExistenceEvaluator::~FileExistenceEvaluator() noexcept = default;
 
-void ls::std::io::FileExistenceEvaluator::evaluate()
+void FileExistenceEvaluator::evaluate()
 {
-  if (!ls::std::io::File{this->filePath}.exists())
+  if (!File{this->filePath}.exists())
   {
-    ::std::string message = "\"" + this->filePath + "\" does not exist!";
-    throw ls::std::core::FileNotFoundException{message};
+    string message = "\"" + this->filePath + "\" does not exist!";
+    throw FileNotFoundException{message};
   }
 }

source/ls-std/io/logging/LogLevel.cpp

@@ -3,67 +3,73 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/exception/IllegalArgumentException.hpp>
 #include <ls-std/io/logging/LogLevel.hpp>
 
-ls::std::io::LogLevel::LogLevel(const ls::std::io::LogLevelValue &_value) : ls::std::core::Class("LogLevel"), value(_value)
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using ls::std::io::LogLevel;
+using ls::std::io::LogLevelValue;
+using std::string;
+
+LogLevel::LogLevel(const LogLevelValue &_value) : Class("LogLevel"), value(_value)
 {
   this->_init();
 }
 
-ls::std::io::LogLevel::LogLevel() : ls::std::core::Class("LogLevel")
+LogLevel::LogLevel() : Class("LogLevel")
 {
   this->_init();
 }
 
-ls::std::io::LogLevel::~LogLevel() noexcept = default;
+LogLevel::~LogLevel() noexcept = default;
 
-ls::std::io::LogLevel &ls::std::io::LogLevel::operator=(const ls::std::io::LogLevelValue &_value)
+LogLevel &LogLevel::operator=(const LogLevelValue &_value)
 {
   this->value = _value;
   return *this;
 }
 
-bool ls::std::io::LogLevel::operator<(const ls::std::io::LogLevelValue &_value)
+bool LogLevel::operator<(const LogLevelValue &_value)
 {
   return this->value < _value;
 }
 
-bool ls::std::io::LogLevel::operator<=(const ls::std::io::LogLevelValue &_value)
+bool LogLevel::operator<=(const LogLevelValue &_value)
 {
   return this->value <= _value;
 }
 
-bool ls::std::io::LogLevel::operator>(const ls::std::io::LogLevelValue &_value)
+bool LogLevel::operator>(const LogLevelValue &_value)
 {
   return this->value > _value;
 }
 
-bool ls::std::io::LogLevel::operator>=(const ls::std::io::LogLevelValue &_value)
+bool LogLevel::operator>=(const LogLevelValue &_value)
 {
   return this->value >= _value;
 }
 
-bool ls::std::io::LogLevel::operator==(const ls::std::io::LogLevelValue &_value)
+bool LogLevel::operator==(const LogLevelValue &_value)
 {
   return this->value == _value;
 }
 
-ls::std::io::LogLevelValue ls::std::io::LogLevel::getValue()
+LogLevelValue LogLevel::getValue()
 {
   return this->value;
 }
 
-void ls::std::io::LogLevel::setLogLevel(const ls::std::io::LogLevelValue &_value)
+void LogLevel::setLogLevel(const LogLevelValue &_value)
 {
   this->value = _value;
 }
 
-void ls::std::io::LogLevel::setLogLevel(const ::std::string &_value)
+void LogLevel::setLogLevel(const string &_value)
 {
   if (this->_isValidLogLevelString(_value))
   {
@@ -71,24 +77,24 @@ void ls::std::io::LogLevel::setLogLevel(const ::std::string &_value)
   }
   else
   {
-    throw ls::std::core::IllegalArgumentException{_value + " is not a valid log level string"};
+    throw IllegalArgumentException{_value + " is not a valid log level string"};
   }
 }
 
-::std::string ls::std::io::LogLevel::toString() const
+string LogLevel::toString() const
 {
   return this->level.at(this->value);
 }
 
-ls::std::io::LogLevelValue ls::std::io::LogLevel::_getValueFromString(const ::std::string &_value)
+LogLevelValue LogLevel::_getValueFromString(const string &_value)
 {
-  ls::std::io::LogLevelValue logLevelValue{};
+  LogLevelValue logLevelValue{};
 
   for (const auto &logLevelString : this->level)
   {
     if (logLevelString.second == _value)
     {
-      logLevelValue = (ls::std::io::LogLevelValue) logLevelString.first;
+      logLevelValue = (LogLevelValue) logLevelString.first;
       break;
     }
   }
@@ -96,17 +102,17 @@ ls::std::io::LogLevelValue ls::std::io::LogLevel::_getValueFromString(const ::st
   return logLevelValue;
 }
 
-void ls::std::io::LogLevel::_init()
+void LogLevel::_init()
 {
-  this->level.insert({ls::std::io::LogLevelValue::FATAL, "FATAL"});
-  this->level.insert({ls::std::io::LogLevelValue::ERR, "ERROR"});
-  this->level.insert({ls::std::io::LogLevelValue::WARN, "WARN"});
-  this->level.insert({ls::std::io::LogLevelValue::INFO, "INFO"});
-  this->level.insert({ls::std::io::LogLevelValue::DEBUG, "DEBUG"});
-  this->level.insert({ls::std::io::LogLevelValue::TRACE, "TRACE"});
+  this->level.insert({LogLevelValue::FATAL, "FATAL"});
+  this->level.insert({LogLevelValue::ERR, "ERROR"});
+  this->level.insert({LogLevelValue::WARN, "WARN"});
+  this->level.insert({LogLevelValue::INFO, "INFO"});
+  this->level.insert({LogLevelValue::DEBUG, "DEBUG"});
+  this->level.insert({LogLevelValue::TRACE, "TRACE"});
 }
 
-bool ls::std::io::LogLevel::_isValidLogLevelString(const ::std::string &_value)
+bool LogLevel::_isValidLogLevelString(const string &_value)
 {
   bool isValidString{};
 

source/ls-std/io/logging/Logger.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
@@ -16,80 +16,95 @@
   #include <sstream>
 #endif
 
-ls::std::io::Logger::Logger(const ::std::shared_ptr<ls::std::core::interface_type::IWriter> &_writer) : ls::std::core::Class("Logger"), logLevel(ls::std::io::LogLevelValue::INFO)
+using ls::std::core::Class;
+using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::core::interface_type::IWriter;
+using ls::std::core::type::byte;
+using ls::std::io::Logger;
+using ls::std::io::LogLevel;
+using ls::std::io::LogLevelValue;
+using ls::std::io::NewLine;
+using std::localtime;
+using std::put_time;
+using std::shared_ptr;
+using std::string;
+using std::stringstream;
+using std::time;
+
+Logger::Logger(const shared_ptr<IWriter> &_writer) : Class("Logger"), logLevel(LogLevelValue::INFO)
 {
   this->_assignWriter(_writer);
 }
 
-ls::std::io::Logger::~Logger() noexcept = default;
+Logger::~Logger() noexcept = default;
 
-void ls::std::io::Logger::debug(const ls::std::core::type::byte *_data)
+void Logger::debug(const byte *_data)
 {
-  if (this->logLevel >= ls::std::io::LogLevelValue::DEBUG)
+  if (this->logLevel >= LogLevelValue::DEBUG)
   {
-    this->_log(_data, ls::std::io::LogLevel(ls::std::io::LogLevelValue::DEBUG));
+    this->_log(_data, LogLevel(LogLevelValue::DEBUG));
   }
 }
 
-void ls::std::io::Logger::error(const ls::std::core::type::byte *_data)
+void Logger::error(const byte *_data)
 {
-  if (this->logLevel >= ls::std::io::LogLevelValue::ERR)
+  if (this->logLevel >= LogLevelValue::ERR)
   {
-    this->_log(_data, ls::std::io::LogLevel(ls::std::io::LogLevelValue::ERR));
+    this->_log(_data, LogLevel(LogLevelValue::ERR));
   }
 }
 
-void ls::std::io::Logger::fatal(const ls::std::core::type::byte *_data)
+void Logger::fatal(const byte *_data)
 {
-  if (this->logLevel >= ls::std::io::LogLevelValue::FATAL)
+  if (this->logLevel >= LogLevelValue::FATAL)
   {
-    this->_log(_data, ls::std::io::LogLevel(ls::std::io::LogLevelValue::FATAL));
+    this->_log(_data, LogLevel(LogLevelValue::FATAL));
   }
 }
 
-ls::std::io::LogLevel ls::std::io::Logger::getLogLevel()
+LogLevel Logger::getLogLevel()
 {
   return this->logLevel;
 }
 
-void ls::std::io::Logger::info(const ls::std::core::type::byte *_data)
+void Logger::info(const byte *_data)
 {
-  if (this->logLevel >= ls::std::io::LogLevelValue::INFO)
+  if (this->logLevel >= LogLevelValue::INFO)
   {
-    this->_log(_data, ls::std::io::LogLevel(ls::std::io::LogLevelValue::INFO));
+    this->_log(_data, LogLevel(LogLevelValue::INFO));
   }
 }
 
-void ls::std::io::Logger::setLogLevel(const ls::std::io::LogLevelValue &_logLevelValue)
+void Logger::setLogLevel(const LogLevelValue &_logLevelValue)
 {
   this->logLevel = _logLevelValue;
 }
 
-void ls::std::io::Logger::trace(const ls::std::core::type::byte *_data)
+void Logger::trace(const byte *_data)
 {
-  if (this->logLevel >= ls::std::io::LogLevelValue::TRACE)
+  if (this->logLevel >= LogLevelValue::TRACE)
   {
-    this->_log(_data, ls::std::io::LogLevel(ls::std::io::LogLevelValue::TRACE));
+    this->_log(_data, LogLevel(LogLevelValue::TRACE));
   }
 }
 
-void ls::std::io::Logger::warn(const ls::std::core::type::byte *_data)
+void Logger::warn(const byte *_data)
 {
-  if (this->logLevel >= ls::std::io::LogLevelValue::WARN)
+  if (this->logLevel >= LogLevelValue::WARN)
   {
-    this->_log(_data, ls::std::io::LogLevel(ls::std::io::LogLevelValue::WARN));
+    this->_log(_data, LogLevel(LogLevelValue::WARN));
   }
 }
 
-void ls::std::io::Logger::_assignWriter(const ::std::shared_ptr<ls::std::core::interface_type::IWriter> &_writer)
+void Logger::_assignWriter(const shared_ptr<IWriter> &_writer)
 {
-  ls::std::core::NullPointerArgumentEvaluator{_writer, "writer reference is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_writer, "writer reference is null!"}.evaluate();
   this->writer = _writer;
 }
 
-::std::string ls::std::io::Logger::_buildCharacterChain(size_t _amount)
+string Logger::_buildCharacterChain(size_t _amount)
 {
-  ::std::string fillContent{};
+  string fillContent{};
 
   for (size_t iteration{}; iteration < _amount; iteration++)
   {
@@ -99,39 +114,39 @@ void ls::std::io::Logger::_assignWriter(const ::std::shared_ptr<ls::std::core::i
   return fillContent;
 }
 
-::std::string ls::std::io::Logger::_createFillContent(const ::std::string &_text)
+string Logger::_createFillContent(const string &_text)
 {
   size_t padSize = 10;
   size_t fillSize = _text.size() > padSize ? 0 : padSize - _text.size();
-  ::std::string fillContent{};
+  string fillContent{};
 
   if (fillSize > 0)
   {
-    fillContent = ls::std::io::Logger::_buildCharacterChain(fillSize);
+    fillContent = Logger::_buildCharacterChain(fillSize);
   }
 
   return fillContent;
 }
 
-::std::string ls::std::io::Logger::_generateTimeString(tm *_localTime)
+string Logger::_generateTimeString(tm *_localTime)
 {
-  ::std::stringstream _stream{};
-  _stream << ::std::put_time(_localTime, "%Y-%m-%d %H:%M:%S");
+  stringstream _stream{};
+  _stream << put_time(_localTime, "%Y-%m-%d %H:%M:%S");
 
   return _stream.str();
 }
 
-void ls::std::io::Logger::_log(const ls::std::core::type::byte *_data, const ls::std::io::LogLevel &_logLevel)
+void Logger::_log(const byte *_data, const LogLevel &_logLevel)
 {
-  time_t timestamp = ::std::time(nullptr);
-  tm *localTime = ::std::localtime(&timestamp);
+  time_t timestamp = ::time(nullptr);
+  tm *localTime = localtime(&timestamp);
 
-  ::std::string logLevelString = ls::std::io::Logger::_padRight(::std::string{_logLevel.toString() + ":"});
-  ::std::string message = "[" + ls::std::io::Logger::_generateTimeString(localTime) + "] " + logLevelString + ::std::string(_data) + ls::std::io::NewLine::getUnixNewLine();
+  string logLevelString = Logger::_padRight(string{_logLevel.toString() + ":"});
+  string message = "[" + Logger::_generateTimeString(localTime) + "] " + logLevelString + string(_data) + NewLine::getUnixNewLine();
   this->writer->write(message);
 }
 
-::std::string ls::std::io::Logger::_padRight(const ::std::string &_text)
+string Logger::_padRight(const string &_text)
 {
-  return _text + ls::std::io::Logger::_createFillContent(_text);
+  return _text + Logger::_createFillContent(_text);
 }

source/ls-std/io/section-pair/SectionPairMessageFormatter.cpp

@@ -3,22 +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/io/section-pair/SectionPairMessageFormatter.hpp>
 #include <regex>
 
-ls::std::io::SectionPairMessageFormatter::SectionPairMessageFormatter() = default;
+using ls::std::io::SectionPairMessageFormatter;
+using std::regex;
+using std::regex_replace;
+using std::string;
 
-ls::std::io::SectionPairMessageFormatter::~SectionPairMessageFormatter() = default;
+SectionPairMessageFormatter::SectionPairMessageFormatter() = default;
 
-::std::string ls::std::io::SectionPairMessageFormatter::getFormattedMessage(const ::std::string &_message)
+SectionPairMessageFormatter::~SectionPairMessageFormatter() = default;
+
+string SectionPairMessageFormatter::getFormattedMessage(const string &_message)
 {
-  ::std::string formattedMessage = _message;
-  formattedMessage = ::std::regex_replace(formattedMessage, ::std::regex(R"(\r{1}\n{1})"), "{WINDOWS_LINE_BREAK}");
-  formattedMessage = ::std::regex_replace(formattedMessage, ::std::regex(R"(\n{1})"), "{UNIX_LINE_BREAK}");
+  string formattedMessage = _message;
+  formattedMessage = regex_replace(formattedMessage, regex(R"(\r{1}\n{1})"), "{WINDOWS_LINE_BREAK}");
+  formattedMessage = regex_replace(formattedMessage, regex(R"(\n{1})"), "{UNIX_LINE_BREAK}");
 
   return formattedMessage;
 }

source/ls-std/io/section-pair/evaluator/SectionPairIdentifierArgumentEvaluator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-09
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -13,16 +13,25 @@
 #include <ls-std/io/section-pair/validator/SectionPairIdentifierValidator.hpp>
 #include <string>
 
-ls::std::io::SectionPairIdentifierArgumentEvaluator::SectionPairIdentifierArgumentEvaluator(ls::std::io::section_pair_identifier _identifier) : ls::std::core::Class("SectionPairIdentifierArgumentEvaluator"), identifier(::std::move(_identifier))
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using ls::std::io::section_pair_identifier;
+using ls::std::io::SectionPairIdentifierArgumentEvaluator;
+using ls::std::io::SectionPairIdentifierValidator;
+using ls::std::io::SectionPairMessageFormatter;
+using std::move;
+using std::string;
+
+SectionPairIdentifierArgumentEvaluator::SectionPairIdentifierArgumentEvaluator(section_pair_identifier _identifier) : Class("SectionPairIdentifierArgumentEvaluator"), identifier(::move(_identifier))
 {}
 
-ls::std::io::SectionPairIdentifierArgumentEvaluator::~SectionPairIdentifierArgumentEvaluator() noexcept = default;
+SectionPairIdentifierArgumentEvaluator::~SectionPairIdentifierArgumentEvaluator() noexcept = default;
 
-void ls::std::io::SectionPairIdentifierArgumentEvaluator::evaluate()
+void SectionPairIdentifierArgumentEvaluator::evaluate()
 {
-  if (!ls::std::io::SectionPairIdentifierValidator{this->identifier}.isValid())
+  if (!SectionPairIdentifierValidator{this->identifier}.isValid())
   {
-    ::std::string message = "\"" + this->identifier + "\" is not a valid identifier!";
-    throw ls::std::core::IllegalArgumentException{ls::std::io::SectionPairMessageFormatter::getFormattedMessage(message)};
+    string message = "\"" + this->identifier + "\" is not a valid identifier!";
+    throw IllegalArgumentException{SectionPairMessageFormatter::getFormattedMessage(message)};
   }
 }

source/ls-std/io/section-pair/evaluator/SectionPairRowArgumentEvaluator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -13,16 +13,24 @@
 #include <ls-std/io/section-pair/validator/SectionPairRowValidator.hpp>
 #include <string>
 
-ls::std::io::SectionPairRowArgumentEvaluator::SectionPairRowArgumentEvaluator(::std::string _sectionPairRow) : ls::std::core::Class("SectionPairRowArgumentEvaluator"), sectionPairRow(::std::move(_sectionPairRow))
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using ls::std::io::SectionPairMessageFormatter;
+using ls::std::io::SectionPairRowArgumentEvaluator;
+using ls::std::io::SectionPairRowValidator;
+using std::move;
+using std::string;
+
+SectionPairRowArgumentEvaluator::SectionPairRowArgumentEvaluator(string _sectionPairRow) : Class("SectionPairRowArgumentEvaluator"), sectionPairRow(::move(_sectionPairRow))
 {}
 
-ls::std::io::SectionPairRowArgumentEvaluator::~SectionPairRowArgumentEvaluator() noexcept = default;
+SectionPairRowArgumentEvaluator::~SectionPairRowArgumentEvaluator() noexcept = default;
 
-void ls::std::io::SectionPairRowArgumentEvaluator::evaluate()
+void SectionPairRowArgumentEvaluator::evaluate()
 {
-  if (!ls::std::io::SectionPairRowValidator{this->sectionPairRow}.isValid())
+  if (!SectionPairRowValidator{this->sectionPairRow}.isValid())
   {
-    ::std::string message = "\"" + this->sectionPairRow + "\" is not a valid section pair row!";
-    throw ls::std::core::IllegalArgumentException{ls::std::io::SectionPairMessageFormatter::getFormattedMessage(message)};
+    string message = "\"" + this->sectionPairRow + "\" is not a valid section pair row!";
+    throw IllegalArgumentException{SectionPairMessageFormatter::getFormattedMessage(message)};
   }
 }

source/ls-std/io/section-pair/evaluator/SectionPairRowListValueArgumentEvaluator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -12,16 +12,24 @@
 #include <ls-std/io/section-pair/evaluator/SectionPairRowListValueArgumentEvaluator.hpp>
 #include <ls-std/io/section-pair/validator/SectionPairRowListValueValidator.hpp>
 
-ls::std::io::SectionPairRowListValueArgumentEvaluator::SectionPairRowListValueArgumentEvaluator(::std::string _listValueRow) : ls::std::core::Class("SectionPairRowListValueArgumentEvaluator"), listValueRow(::std::move(_listValueRow))
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using ls::std::io::SectionPairMessageFormatter;
+using ls::std::io::SectionPairRowListValueArgumentEvaluator;
+using ls::std::io::SectionPairRowListValueValidator;
+using std::move;
+using std::string;
+
+SectionPairRowListValueArgumentEvaluator::SectionPairRowListValueArgumentEvaluator(string _listValueRow) : Class("SectionPairRowListValueArgumentEvaluator"), listValueRow(::move(_listValueRow))
 {}
 
-ls::std::io::SectionPairRowListValueArgumentEvaluator::~SectionPairRowListValueArgumentEvaluator() noexcept = default;
+SectionPairRowListValueArgumentEvaluator::~SectionPairRowListValueArgumentEvaluator() noexcept = default;
 
-void ls::std::io::SectionPairRowListValueArgumentEvaluator::evaluate()
+void SectionPairRowListValueArgumentEvaluator::evaluate()
 {
-  if (!ls::std::io::SectionPairRowListValueValidator{this->listValueRow}.isValid())
+  if (!SectionPairRowListValueValidator{this->listValueRow}.isValid())
   {
-    ::std::string message = "\"" + this->listValueRow + "\" is not a valid section pair list value row!";
-    throw ls::std::core::IllegalArgumentException{ls::std::io::SectionPairMessageFormatter::getFormattedMessage(message)};
+    string message = "\"" + this->listValueRow + "\" is not a valid section pair list value row!";
+    throw IllegalArgumentException{SectionPairMessageFormatter::getFormattedMessage(message)};
   }
 }

source/ls-std/io/section-pair/evaluator/SectionPairRowSingleValueArgumentEvaluator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-19
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -12,16 +12,24 @@
 #include <ls-std/io/section-pair/evaluator/SectionPairRowSingleValueArgumentEvaluator.hpp>
 #include <ls-std/io/section-pair/validator/SectionPairRowSingleValueValidator.hpp>
 
-ls::std::io::SectionPairRowSingleValueArgumentEvaluator::SectionPairRowSingleValueArgumentEvaluator(::std::string _singleValueRow) : ls::std::core::Class("SectionPairRowSingleValueArgumentEvaluator"), singleValueRow(::std::move(_singleValueRow))
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using ls::std::io::SectionPairMessageFormatter;
+using ls::std::io::SectionPairRowSingleValueArgumentEvaluator;
+using ls::std::io::SectionPairRowSingleValueValidator;
+using std::move;
+using std::string;
+
+SectionPairRowSingleValueArgumentEvaluator::SectionPairRowSingleValueArgumentEvaluator(string _singleValueRow) : Class("SectionPairRowSingleValueArgumentEvaluator"), singleValueRow(::move(_singleValueRow))
 {}
 
-ls::std::io::SectionPairRowSingleValueArgumentEvaluator::~SectionPairRowSingleValueArgumentEvaluator() noexcept = default;
+SectionPairRowSingleValueArgumentEvaluator::~SectionPairRowSingleValueArgumentEvaluator() noexcept = default;
 
-void ls::std::io::SectionPairRowSingleValueArgumentEvaluator::evaluate()
+void SectionPairRowSingleValueArgumentEvaluator::evaluate()
 {
-  if (!ls::std::io::SectionPairRowSingleValueValidator{this->singleValueRow}.isValid())
+  if (!SectionPairRowSingleValueValidator{this->singleValueRow}.isValid())
   {
-    ::std::string message = "\"" + this->singleValueRow + "\" is not a valid section pair single value row!";
-    throw ls::std::core::IllegalArgumentException{ls::std::io::SectionPairMessageFormatter::getFormattedMessage(message)};
+    string message = "\"" + this->singleValueRow + "\" is not a valid section pair single value row!";
+    throw IllegalArgumentException{SectionPairMessageFormatter::getFormattedMessage(message)};
   }
 }

source/ls-std/io/section-pair/evaluator/SectionPairSectionArgumentEvaluator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -12,16 +12,24 @@
 #include <ls-std/io/section-pair/evaluator/SectionPairSectionArgumentEvaluator.hpp>
 #include <ls-std/io/section-pair/validator/SectionPairSectionValidator.hpp>
 
-ls::std::io::SectionPairSectionArgumentEvaluator::SectionPairSectionArgumentEvaluator(::std::string _section) : ls::std::core::Class("SectionPairSectionArgumentEvaluator"), section(::std::move(_section))
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using ls::std::io::SectionPairMessageFormatter;
+using ls::std::io::SectionPairSectionArgumentEvaluator;
+using ls::std::io::SectionPairSectionValidator;
+using std::move;
+using std::string;
+
+SectionPairSectionArgumentEvaluator::SectionPairSectionArgumentEvaluator(string _section) : Class("SectionPairSectionArgumentEvaluator"), section(::move(_section))
 {}
 
-ls::std::io::SectionPairSectionArgumentEvaluator::~SectionPairSectionArgumentEvaluator() noexcept = default;
+SectionPairSectionArgumentEvaluator::~SectionPairSectionArgumentEvaluator() noexcept = default;
 
-void ls::std::io::SectionPairSectionArgumentEvaluator::evaluate()
+void SectionPairSectionArgumentEvaluator::evaluate()
 {
-  if (!ls::std::io::SectionPairSectionValidator{this->section}.isValid())
+  if (!SectionPairSectionValidator{this->section}.isValid())
   {
-    ::std::string message = "\"" + this->section + "\" is not a valid section!";
-    throw ls::std::core::IllegalArgumentException{ls::std::io::SectionPairMessageFormatter::getFormattedMessage(message)};
+    string message = "\"" + this->section + "\" is not a valid section!";
+    throw IllegalArgumentException{SectionPairMessageFormatter::getFormattedMessage(message)};
   }
 }

source/ls-std/io/section-pair/evaluator/SectionPairValueArgumentEvaluator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -12,16 +12,25 @@
 #include <ls-std/io/section-pair/evaluator/SectionPairValueArgumentEvaluator.hpp>
 #include <ls-std/io/section-pair/validator/SectionPairValueValidator.hpp>
 
-ls::std::io::SectionPairValueArgumentEvaluator::SectionPairValueArgumentEvaluator(ls::std::io::section_pair_row_value _value) : ls::std::core::Class("SectionPairValueArgumentEvaluator"), value(::std::move(_value))
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using ls::std::io::section_pair_row_value;
+using ls::std::io::SectionPairMessageFormatter;
+using ls::std::io::SectionPairValueArgumentEvaluator;
+using ls::std::io::SectionPairValueValidator;
+using std::move;
+using std::string;
+
+SectionPairValueArgumentEvaluator::SectionPairValueArgumentEvaluator(section_pair_row_value _value) : Class("SectionPairValueArgumentEvaluator"), value(::move(_value))
 {}
 
-ls::std::io::SectionPairValueArgumentEvaluator::~SectionPairValueArgumentEvaluator() noexcept = default;
+SectionPairValueArgumentEvaluator::~SectionPairValueArgumentEvaluator() noexcept = default;
 
-void ls::std::io::SectionPairValueArgumentEvaluator::evaluate()
+void SectionPairValueArgumentEvaluator::evaluate()
 {
-  if (!ls::std::io::SectionPairValueValidator(this->value).isValid())
+  if (!SectionPairValueValidator(this->value).isValid())
   {
-    ::std::string message = "\"" + this->value + "\" is not a valid value!";
-    throw ls::std::core::IllegalArgumentException{ls::std::io::SectionPairMessageFormatter::getFormattedMessage(message)};
+    string message = "\"" + this->value + "\" is not a valid value!";
+    throw IllegalArgumentException{SectionPairMessageFormatter::getFormattedMessage(message)};
   }
 }

source/ls-std/io/section-pair/model/SectionPairDocument.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-15
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -15,28 +15,45 @@
 #include <ls-std/io/section-pair/model/SectionPairDocument.hpp>
 #include <ls-std/io/section-pair/serialization/SerializableSectionPairDocument.hpp>
 
-ls::std::io::SectionPairDocument::SectionPairDocument() : ls::std::core::Class("SectionPairDocument")
+using ls::std::core::Class;
+using ls::std::core::ConditionalFunctionExecutor;
+using ls::std::core::IllegalArgumentException;
+using ls::std::core::IndexOutOfBoundsEvaluator;
+using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::core::type::byte_field;
+using ls::std::io::section_pair_document_section_list;
+using ls::std::io::section_pair_document_section_list_element;
+using ls::std::io::section_pair_identifier;
+using ls::std::io::SectionPairDocument;
+using ls::std::io::SectionPairMessageFormatter;
+using ls::std::io::SerializableSectionPairDocument;
+using ls::std::io::SerializableSectionPairParameter;
+using std::make_shared;
+using std::reinterpret_pointer_cast;
+using std::string;
+
+SectionPairDocument::SectionPairDocument() : Class("SectionPairDocument")
 {}
 
-ls::std::io::SectionPairDocument::~SectionPairDocument() noexcept = default;
+SectionPairDocument::~SectionPairDocument() noexcept = default;
 
-void ls::std::io::SectionPairDocument::add(const section_pair_document_section_list_element &_section)
+void SectionPairDocument::add(const section_pair_document_section_list_element &_section)
 {
-  ::std::string message = this->getClassName() + ": add section attempt failed, since \"_section\" argument is null!";
-  ls::std::core::NullPointerArgumentEvaluator(::std::reinterpret_pointer_cast<void>(_section), message).evaluate();
+  string message = this->getClassName() + ": add section attempt failed, since \"_section\" argument is null!";
+  NullPointerArgumentEvaluator(reinterpret_pointer_cast<void>(_section), message).evaluate();
   this->_checkSectionExistence(_section->getSectionId());
   this->sections.push_back(_section);
 }
 
-void ls::std::io::SectionPairDocument::clear()
+void SectionPairDocument::clear()
 {
   this->sections.clear();
 }
 
-ls::std::io::section_pair_document_section_list_element ls::std::io::SectionPairDocument::get(size_t _index)
+section_pair_document_section_list_element SectionPairDocument::get(size_t _index)
 {
-  ls::std::io::section_pair_document_section_list_element element{};
-  ls::std::core::IndexOutOfBoundsEvaluator{_index, this->sections.size()}.evaluate();
+  section_pair_document_section_list_element element{};
+  IndexOutOfBoundsEvaluator{_index, this->sections.size()}.evaluate();
   size_t index{};
 
   for (const auto &_element : this->sections)
@@ -53,50 +70,50 @@ ls::std::io::section_pair_document_section_list_element ls::std::io::SectionPair
   return element;
 }
 
-size_t ls::std::io::SectionPairDocument::getAmountOfSections()
+size_t SectionPairDocument::getAmountOfSections()
 {
   return this->sections.size();
 }
 
-::std::string ls::std::io::SectionPairDocument::getHeader()
+string SectionPairDocument::getHeader()
 {
   return this->header;
 }
 
-ls::std::io::section_pair_document_section_list ls::std::io::SectionPairDocument::getSectionList()
+section_pair_document_section_list SectionPairDocument::getSectionList()
 {
   return this->sections;
 }
 
-ls::std::core::type::byte_field ls::std::io::SectionPairDocument::marshal()
+byte_field SectionPairDocument::marshal()
 {
-  ls::std::core::ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
+  ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
   return this->serializable->marshal();
 }
 
-void ls::std::io::SectionPairDocument::reserveNewLine(const ::std::string &_reservedNewLine)
+void SectionPairDocument::reserveNewLine(const string &_reservedNewLine)
 {
   this->reservedNewLine = _reservedNewLine;
 }
 
-void ls::std::io::SectionPairDocument::unmarshal(const ls::std::core::type::byte_field &_data)
+void SectionPairDocument::unmarshal(const byte_field &_data)
 {
-  ls::std::core::ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
+  ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
   this->serializable->unmarshal(_data);
 }
 
-void ls::std::io::SectionPairDocument::_checkSectionExistence(const ls::std::io::section_pair_identifier &_sectionId)
+void SectionPairDocument::_checkSectionExistence(const section_pair_identifier &_sectionId)
 {
   if (this->_hasSection(_sectionId))
   {
-    ::std::string message = this->getClassName() + "section ID \"" + _sectionId + "\" already exists in document!";
-    throw ls::std::core::IllegalArgumentException{ls::std::io::SectionPairMessageFormatter::getFormattedMessage(message)};
+    string message = this->getClassName() + "section ID \"" + _sectionId + "\" already exists in document!";
+    throw IllegalArgumentException{SectionPairMessageFormatter::getFormattedMessage(message)};
   }
 }
 
-void ls::std::io::SectionPairDocument::_createSerializable()
+void SectionPairDocument::_createSerializable()
 {
-  ls::std::io::SerializableSectionPairParameter parameter{};
+  SerializableSectionPairParameter parameter{};
   parameter.setValue(shared_from_this());
 
   if (!this->reservedNewLine.empty())
@@ -104,10 +121,10 @@ void ls::std::io::SectionPairDocument::_createSerializable()
     parameter.setNewLine(this->reservedNewLine);
   }
 
-  this->serializable = ::std::make_shared<ls::std::io::SerializableSectionPairDocument>(parameter);
+  this->serializable = make_shared<SerializableSectionPairDocument>(parameter);
 }
 
-bool ls::std::io::SectionPairDocument::_hasSection(const ls::std::io::section_pair_identifier &_identifier)
+bool SectionPairDocument::_hasSection(const section_pair_identifier &_identifier)
 {
   bool sectionExists{};
 

source/ls-std/io/section-pair/model/SectionPairRow.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -16,59 +16,78 @@
 #include <ls-std/io/section-pair/model/SectionPairRowSingleValue.hpp>
 #include <ls-std/io/section-pair/serialization/SerializableSectionPairRow.hpp>
 
-ls::std::io::SectionPairRow::SectionPairRow(const ls::std::io::section_pair_identifier &_key, const ls::std::io::SectionPairRowEnumType &_type) : ls::std::core::Class("SectionPairRow")
+using ls::std::core::Class;
+using ls::std::core::ConditionalFunctionExecutor;
+using ls::std::core::EmptyStringArgumentEvaluator;
+using ls::std::core::IllegalArgumentException;
+using ls::std::core::type::byte_field;
+using ls::std::io::section_pair_identifier;
+using ls::std::io::section_pair_row_value;
+using ls::std::io::SectionPairIdentifierArgumentEvaluator;
+using ls::std::io::SectionPairRow;
+using ls::std::io::SectionPairRowEnumType;
+using ls::std::io::SectionPairRowListValue;
+using ls::std::io::SectionPairRowSingleValue;
+using ls::std::io::SectionPairRowValue;
+using ls::std::io::SerializableSectionPairParameter;
+using ls::std::io::SerializableSectionPairRow;
+using std::make_shared;
+using std::shared_ptr;
+using std::string;
+
+SectionPairRow::SectionPairRow(const section_pair_identifier &_key, const SectionPairRowEnumType &_type) : Class("SectionPairRow")
 {
   this->_setKey(_key);
   this->_initValue(_type);
 }
 
-ls::std::io::SectionPairRow::~SectionPairRow() noexcept = default;
+SectionPairRow::~SectionPairRow() noexcept = default;
 
-ls::std::io::section_pair_row_value ls::std::io::SectionPairRow::getKey()
+section_pair_row_value SectionPairRow::getKey()
 {
   return this->key;
 }
 
-::std::shared_ptr<ls::std::io::SectionPairRowValue> ls::std::io::SectionPairRow::getValue()
+shared_ptr<SectionPairRowValue> SectionPairRow::getValue()
 {
   return this->value;
 }
 
-bool ls::std::io::SectionPairRow::isList()
+bool SectionPairRow::isList()
 {
-  return this->value->getType() == ls::std::io::SectionPairRowEnumType::SECTION_PAIR_ROW_LIST_VALUE;
+  return this->value->getType() == SectionPairRowEnumType::SECTION_PAIR_ROW_LIST_VALUE;
 }
 
-bool ls::std::io::SectionPairRow::isSingleValue()
+bool SectionPairRow::isSingleValue()
 {
-  return this->value->getType() == ls::std::io::SectionPairRowEnumType::SECTION_PAIR_ROW_SINGLE_VALUE;
+  return this->value->getType() == SectionPairRowEnumType::SECTION_PAIR_ROW_SINGLE_VALUE;
 }
 
-ls::std::core::type::byte_field ls::std::io::SectionPairRow::marshal()
+byte_field SectionPairRow::marshal()
 {
-  ls::std::core::ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
+  ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
   return this->serializable->marshal();
 }
 
-void ls::std::io::SectionPairRow::reserveNewLine(const ::std::string &_reservedNewLine)
+void SectionPairRow::reserveNewLine(const string &_reservedNewLine)
 {
   this->reservedNewLine = _reservedNewLine;
 }
 
-void ls::std::io::SectionPairRow::setKey(const ls::std::io::section_pair_identifier &_key)
+void SectionPairRow::setKey(const section_pair_identifier &_key)
 {
   this->_setKey(_key);
 }
 
-void ls::std::io::SectionPairRow::unmarshal(const ls::std::core::type::byte_field &_data)
+void SectionPairRow::unmarshal(const byte_field &_data)
 {
-  ls::std::core::ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
+  ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
   this->serializable->unmarshal(_data);
 }
 
-void ls::std::io::SectionPairRow::_createSerializable()
+void SectionPairRow::_createSerializable()
 {
-  ls::std::io::SerializableSectionPairParameter parameter{};
+  SerializableSectionPairParameter parameter{};
   parameter.setValue(shared_from_this());
 
   if (!this->reservedNewLine.empty())
@@ -76,33 +95,33 @@ void ls::std::io::SectionPairRow::_createSerializable()
     parameter.setNewLine(this->reservedNewLine);
   }
 
-  this->serializable = ::std::make_shared<ls::std::io::SerializableSectionPairRow>(parameter);
+  this->serializable = make_shared<SerializableSectionPairRow>(parameter);
 }
 
-void ls::std::io::SectionPairRow::_initValue(const ls::std::io::SectionPairRowEnumType &_type)
+void SectionPairRow::_initValue(const SectionPairRowEnumType &_type)
 {
   switch (_type)
   {
     case SECTION_PAIR_ROW_NOT_IMPLEMENTED:
     {
-      throw ls::std::core::IllegalArgumentException{this->getClassName() + ": default row enum type can not be set!"};
+      throw IllegalArgumentException{this->getClassName() + ": default row enum type can not be set!"};
     }
     case SECTION_PAIR_ROW_LIST_VALUE:
     {
-      this->value = ::std::make_shared<ls::std::io::SectionPairRowListValue>();
+      this->value = make_shared<SectionPairRowListValue>();
     }
     break;
     case SECTION_PAIR_ROW_SINGLE_VALUE:
     {
-      this->value = ::std::make_shared<ls::std::io::SectionPairRowSingleValue>("empty");
+      this->value = make_shared<SectionPairRowSingleValue>("empty");
     }
     break;
   }
 }
 
-void ls::std::io::SectionPairRow::_setKey(const ls::std::io::section_pair_identifier &_key)
+void SectionPairRow::_setKey(const section_pair_identifier &_key)
 {
-  ls::std::core::EmptyStringArgumentEvaluator{_key, this->getClassName() + ": passed key identifier is empty!"}.evaluate();
-  ls::std::io::SectionPairIdentifierArgumentEvaluator(_key).evaluate();
+  EmptyStringArgumentEvaluator{_key, this->getClassName() + ": passed key identifier is empty!"}.evaluate();
+  SectionPairIdentifierArgumentEvaluator(_key).evaluate();
   this->key = _key;
 }

source/ls-std/io/section-pair/model/SectionPairRowListValue.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -14,27 +14,42 @@
 #include <ls-std/io/section-pair/model/SectionPairRowListValue.hpp>
 #include <ls-std/io/section-pair/serialization/SerializableSectionPairRowListValue.hpp>
 
-ls::std::io::SectionPairRowListValue::SectionPairRowListValue() : ls::std::core::Class("SectionPairRowListValue"), ls::std::io::SectionPairRowValue(ls::std::io::SectionPairRowEnumType::SECTION_PAIR_ROW_LIST_VALUE)
+using ls::std::core::Class;
+using ls::std::core::ConditionalFunctionExecutor;
+using ls::std::core::EmptyStringArgumentEvaluator;
+using ls::std::core::IndexOutOfBoundsEvaluator;
+using ls::std::core::type::byte_field;
+using ls::std::io::section_pair_row_value;
+using ls::std::io::SectionPairRowEnumType;
+using ls::std::io::SectionPairRowListValue;
+using ls::std::io::SectionPairRowValue;
+using ls::std::io::SectionPairValueArgumentEvaluator;
+using ls::std::io::SerializableSectionPairParameter;
+using ls::std::io::SerializableSectionPairRowListValue;
+using std::list;
+using std::make_shared;
+
+SectionPairRowListValue::SectionPairRowListValue() : Class("SectionPairRowListValue"), SectionPairRowValue(SectionPairRowEnumType::SECTION_PAIR_ROW_LIST_VALUE)
 {}
 
-ls::std::io::SectionPairRowListValue::~SectionPairRowListValue() noexcept = default;
+SectionPairRowListValue::~SectionPairRowListValue() noexcept = default;
 
-void ls::std::io::SectionPairRowListValue::add(const ls::std::io::section_pair_row_value &_value)
+void SectionPairRowListValue::add(const section_pair_row_value &_value)
 {
-  ls::std::core::EmptyStringArgumentEvaluator{_value}.evaluate();
-  ls::std::io::SectionPairValueArgumentEvaluator{_value}.evaluate();
+  EmptyStringArgumentEvaluator{_value}.evaluate();
+  SectionPairValueArgumentEvaluator{_value}.evaluate();
   this->values.push_back(_value);
 }
 
-void ls::std::io::SectionPairRowListValue::clear()
+void SectionPairRowListValue::clear()
 {
   this->values.clear();
 }
 
-ls::std::io::section_pair_row_value ls::std::io::SectionPairRowListValue::get(size_t _index)
+section_pair_row_value SectionPairRowListValue::get(size_t _index)
 {
-  ls::std::core::IndexOutOfBoundsEvaluator(_index, this->values.size()).evaluate();
-  ls::std::io::section_pair_row_value value{};
+  IndexOutOfBoundsEvaluator(_index, this->values.size()).evaluate();
+  section_pair_row_value value{};
   size_t index{};
 
   for (const auto &_value : this->values)
@@ -51,36 +66,36 @@ ls::std::io::section_pair_row_value ls::std::io::SectionPairRowListValue::get(si
   return value;
 }
 
-::std::list<ls::std::io::section_pair_row_value> ls::std::io::SectionPairRowListValue::getList()
+list<section_pair_row_value> SectionPairRowListValue::getList()
 {
   return this->values;
 }
 
-size_t ls::std::io::SectionPairRowListValue::getSize()
+size_t SectionPairRowListValue::getSize()
 {
   return this->values.size();
 }
 
-ls::std::io::SectionPairRowEnumType ls::std::io::SectionPairRowListValue::getType()
+SectionPairRowEnumType SectionPairRowListValue::getType()
 {
   return this->type;
 }
 
-ls::std::core::type::byte_field ls::std::io::SectionPairRowListValue::marshal()
+byte_field SectionPairRowListValue::marshal()
 {
-  ls::std::core::ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
+  ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
   return this->serializable->marshal();
 }
 
-void ls::std::io::SectionPairRowListValue::unmarshal(const ls::std::core::type::byte_field &_data)
+void SectionPairRowListValue::unmarshal(const byte_field &_data)
 {
-  ls::std::core::ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
+  ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
   this->serializable->unmarshal(_data);
 }
 
-void ls::std::io::SectionPairRowListValue::_createSerializable()
+void SectionPairRowListValue::_createSerializable()
 {
-  ls::std::io::SerializableSectionPairParameter parameter{};
+  SerializableSectionPairParameter parameter{};
   parameter.setValue(shared_from_this());
 
   if (!this->reservedNewLine.empty())
@@ -88,5 +103,5 @@ void ls::std::io::SectionPairRowListValue::_createSerializable()
     parameter.setNewLine(this->reservedNewLine);
   }
 
-  this->serializable = ::std::make_shared<ls::std::io::SerializableSectionPairRowListValue>(parameter);
+  this->serializable = make_shared<SerializableSectionPairRowListValue>(parameter);
 }

source/ls-std/io/section-pair/model/SectionPairRowSingleValue.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-10
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -14,41 +14,55 @@
 #include <ls-std/io/section-pair/model/SectionPairRowSingleValue.hpp>
 #include <ls-std/io/section-pair/serialization/SerializableSectionPairRowSingleValue.hpp>
 
-ls::std::io::SectionPairRowSingleValue::SectionPairRowSingleValue(const ls::std::io::section_pair_row_value &_value) : ls::std::core::Class("SectionPairRowSingleValue"), ls::std::io::SectionPairRowValue(ls::std::io::SECTION_PAIR_ROW_SINGLE_VALUE)
+using ls::std::core::Class;
+using ls::std::core::ConditionalFunctionExecutor;
+using ls::std::core::EmptyStringArgumentEvaluator;
+using ls::std::core::type::byte_field;
+using ls::std::io::NewLine;
+using ls::std::io::section_pair_row_value;
+using ls::std::io::SectionPairRowEnumType;
+using ls::std::io::SectionPairRowSingleValue;
+using ls::std::io::SectionPairRowValue;
+using ls::std::io::SectionPairValueArgumentEvaluator;
+using ls::std::io::SerializableSectionPairRowSingleValue;
+using std::make_shared;
+using std::string;
+
+SectionPairRowSingleValue::SectionPairRowSingleValue(const section_pair_row_value &_value) : Class("SectionPairRowSingleValue"), SectionPairRowValue(SectionPairRowEnumType::SECTION_PAIR_ROW_SINGLE_VALUE)
 {
   this->_set(_value);
 }
 
-ls::std::io::SectionPairRowSingleValue::~SectionPairRowSingleValue() noexcept = default;
+SectionPairRowSingleValue::~SectionPairRowSingleValue() noexcept = default;
 
-ls::std::io::section_pair_row_value ls::std::io::SectionPairRowSingleValue::get()
+section_pair_row_value SectionPairRowSingleValue::get()
 {
   return this->value;
 }
 
-ls::std::io::SectionPairRowEnumType ls::std::io::SectionPairRowSingleValue::getType()
+SectionPairRowEnumType SectionPairRowSingleValue::getType()
 {
   return this->type;
 }
 
-ls::std::core::type::byte_field ls::std::io::SectionPairRowSingleValue::marshal()
+byte_field SectionPairRowSingleValue::marshal()
 {
-  ls::std::core::ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
+  ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
   return this->serializable->marshal();
 }
 
-void ls::std::io::SectionPairRowSingleValue::set(const ls::std::io::section_pair_row_value &_value)
+void SectionPairRowSingleValue::set(const section_pair_row_value &_value)
 {
   this->_set(_value);
 }
 
-void ls::std::io::SectionPairRowSingleValue::unmarshal(const ls::std::core::type::byte_field &_data)
+void SectionPairRowSingleValue::unmarshal(const byte_field &_data)
 {
-  ls::std::core::ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
+  ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
   this->serializable->unmarshal(_data);
 }
 
-void ls::std::io::SectionPairRowSingleValue::_createSerializable()
+void SectionPairRowSingleValue::_createSerializable()
 {
   SerializableSectionPairParameter parameter{};
   parameter.setValue(shared_from_this());
@@ -58,17 +72,17 @@ void ls::std::io::SectionPairRowSingleValue::_createSerializable()
     parameter.setNewLine(this->reservedNewLine);
   }
 
-  this->serializable = ::std::make_shared<ls::std::io::SerializableSectionPairRowSingleValue>(parameter);
+  this->serializable = make_shared<SerializableSectionPairRowSingleValue>(parameter);
 }
 
-void ls::std::io::SectionPairRowSingleValue::_set(const ls::std::io::section_pair_row_value &_value)
+void SectionPairRowSingleValue::_set(const section_pair_row_value &_value)
 {
-  ls::std::core::EmptyStringArgumentEvaluator{_value}.evaluate();
-  ls::std::io::SectionPairValueArgumentEvaluator(_value).evaluate();
-  ::std::string newLine = this->reservedNewLine.empty() ? NewLine::get() : this->reservedNewLine;
+  EmptyStringArgumentEvaluator{_value}.evaluate();
+  SectionPairValueArgumentEvaluator(_value).evaluate();
+  string newLine = this->reservedNewLine.empty() ? NewLine::get() : this->reservedNewLine;
   this->value = _value;
 
-  if (this->value.find(newLine) != ::std::string::npos)
+  if (this->value.find(newLine) != string::npos)
   {
     this->value.replace(this->value.find(newLine), newLine.size(), "");
   }

source/ls-std/io/section-pair/model/SectionPairRowValue.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/io/section-pair/model/SectionPairRowValue.hpp>
 
-ls::std::io::SectionPairRowValue::SectionPairRowValue(const ls::std::io::SectionPairRowEnumType &_type) : type(_type)
+using ls::std::core::type::byte_field;
+using ls::std::io::SectionPairRowEnumType;
+using ls::std::io::SectionPairRowValue;
+using std::string;
+
+SectionPairRowValue::SectionPairRowValue(const SectionPairRowEnumType &_type) : type(_type)
 {}
 
-ls::std::io::SectionPairRowValue::~SectionPairRowValue() noexcept = default;
+SectionPairRowValue::~SectionPairRowValue() noexcept = default;
 
-ls::std::core::type::byte_field ls::std::io::SectionPairRowValue::marshal()
+byte_field SectionPairRowValue::marshal()
 {
-  return ls::std::core::type::byte_field{};
+  return byte_field{};
 }
 
-void ls::std::io::SectionPairRowValue::reserveNewLine(const ::std::string &_reservedNewLine)
+void SectionPairRowValue::reserveNewLine(const string &_reservedNewLine)
 {
   this->reservedNewLine = _reservedNewLine;
 }
 
-void ls::std::io::SectionPairRowValue::unmarshal(const ls::std::core::type::byte_field &_data)
+void SectionPairRowValue::unmarshal(const byte_field &_data)
 {}

source/ls-std/io/section-pair/model/SectionPairSection.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-13
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -17,29 +17,48 @@
 #include <ls-std/io/section-pair/model/SectionPairSection.hpp>
 #include <ls-std/io/section-pair/serialization/SerializableSectionPairSection.hpp>
 
-ls::std::io::SectionPairSection::SectionPairSection(const ls::std::io::section_pair_identifier &_sectionId) : ls::std::core::Class("SectionPairSection")
+using ls::std::core::Class;
+using ls::std::core::ConditionalFunctionExecutor;
+using ls::std::core::EmptyStringArgumentEvaluator;
+using ls::std::core::IllegalArgumentException;
+using ls::std::core::IndexOutOfBoundsEvaluator;
+using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::core::type::byte_field;
+using ls::std::io::section_pair_identifier;
+using ls::std::io::section_pair_row_list;
+using ls::std::io::section_pair_row_list_element;
+using ls::std::io::SectionPairIdentifierArgumentEvaluator;
+using ls::std::io::SectionPairMessageFormatter;
+using ls::std::io::SectionPairSection;
+using ls::std::io::SerializableSectionPairParameter;
+using ls::std::io::SerializableSectionPairSection;
+using std::make_shared;
+using std::reinterpret_pointer_cast;
+using std::string;
+
+SectionPairSection::SectionPairSection(const section_pair_identifier &_sectionId) : Class("SectionPairSection")
 {
   this->_setSectionId(_sectionId);
 }
 
-ls::std::io::SectionPairSection::~SectionPairSection() noexcept = default;
+SectionPairSection::~SectionPairSection() noexcept = default;
 
-void ls::std::io::SectionPairSection::add(const section_pair_row_list_element &_row)
+void SectionPairSection::add(const section_pair_row_list_element &_row)
 {
-  ls::std::core::NullPointerArgumentEvaluator{::std::reinterpret_pointer_cast<void>(_row)}.evaluate();
+  NullPointerArgumentEvaluator{reinterpret_pointer_cast<void>(_row)}.evaluate();
   this->_rowExistenceCheck(_row->getKey());
   this->rows.push_back(_row);
 }
 
-void ls::std::io::SectionPairSection::clear()
+void SectionPairSection::clear()
 {
   this->rows.clear();
 }
 
-ls::std::io::section_pair_row_list_element ls::std::io::SectionPairSection::get(size_t _index)
+section_pair_row_list_element SectionPairSection::get(size_t _index)
 {
-  ls::std::core::IndexOutOfBoundsEvaluator{_index, this->rows.size()}.evaluate();
-  ls::std::io::section_pair_row_list_element element{};
+  IndexOutOfBoundsEvaluator{_index, this->rows.size()}.evaluate();
+  section_pair_row_list_element element{};
   size_t index{};
 
   for (const auto &_element : this->rows)
@@ -56,46 +75,46 @@ ls::std::io::section_pair_row_list_element ls::std::io::SectionPairSection::get(
   return element;
 }
 
-ls::std::io::section_pair_row_list ls::std::io::SectionPairSection::getList()
+section_pair_row_list SectionPairSection::getList()
 {
   return this->rows;
 }
 
-size_t ls::std::io::SectionPairSection::getRowAmount()
+size_t SectionPairSection::getRowAmount()
 {
   return this->rows.size();
 }
 
-ls::std::io::section_pair_identifier ls::std::io::SectionPairSection::getSectionId()
+section_pair_identifier SectionPairSection::getSectionId()
 {
   return this->sectionId;
 }
 
-ls::std::core::type::byte_field ls::std::io::SectionPairSection::marshal()
+byte_field SectionPairSection::marshal()
 {
-  ls::std::core::ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
+  ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
   return this->serializable->marshal();
 }
 
-void ls::std::io::SectionPairSection::reserveNewLine(const ::std::string &_reservedNewLine)
+void SectionPairSection::reserveNewLine(const string &_reservedNewLine)
 {
   this->reservedNewLine = _reservedNewLine;
 }
 
-void ls::std::io::SectionPairSection::setSectionId(const ls::std::io::section_pair_identifier &_sectionId)
+void SectionPairSection::setSectionId(const section_pair_identifier &_sectionId)
 {
   this->_setSectionId(_sectionId);
 }
 
-void ls::std::io::SectionPairSection::unmarshal(const ls::std::core::type::byte_field &_data)
+void SectionPairSection::unmarshal(const byte_field &_data)
 {
-  ls::std::core::ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
+  ConditionalFunctionExecutor{this->serializable == nullptr}.execute([this] { _createSerializable(); });
   this->serializable->unmarshal(_data);
 }
 
-void ls::std::io::SectionPairSection::_createSerializable()
+void SectionPairSection::_createSerializable()
 {
-  ls::std::io::SerializableSectionPairParameter parameter{};
+  SerializableSectionPairParameter parameter{};
   parameter.setValue(shared_from_this());
 
   if (!this->reservedNewLine.empty())
@@ -103,10 +122,10 @@ void ls::std::io::SectionPairSection::_createSerializable()
     parameter.setNewLine(this->reservedNewLine);
   }
 
-  this->serializable = ::std::make_shared<ls::std::io::SerializableSectionPairSection>(parameter);
+  this->serializable = make_shared<SerializableSectionPairSection>(parameter);
 }
 
-bool ls::std::io::SectionPairSection::_hasRow(const ls::std::io::section_pair_identifier &_key)
+bool SectionPairSection::_hasRow(const section_pair_identifier &_key)
 {
   bool rowExists{};
 
@@ -122,17 +141,17 @@ bool ls::std::io::SectionPairSection::_hasRow(const ls::std::io::section_pair_id
   return rowExists;
 }
 
-void ls::std::io::SectionPairSection::_rowExistenceCheck(const ls::std::io::section_pair_identifier &_key)
+void SectionPairSection::_rowExistenceCheck(const section_pair_identifier &_key)
 {
   if (this->_hasRow(_key))
   {
-    ::std::string message = this->getClassName() + ": row key \"" + _key + "\" already exists in section \"" + this->sectionId + "\"!";
-    throw ls::std::core::IllegalArgumentException{ls::std::io::SectionPairMessageFormatter::getFormattedMessage(message)};
+    string message = this->getClassName() + ": row key \"" + _key + "\" already exists in section \"" + this->sectionId + "\"!";
+    throw IllegalArgumentException{SectionPairMessageFormatter::getFormattedMessage(message)};
   }
 }
-void ls::std::io::SectionPairSection::_setSectionId(const ls::std::io::section_pair_identifier &_sectionId)
+void SectionPairSection::_setSectionId(const section_pair_identifier &_sectionId)
 {
-  ls::std::core::EmptyStringArgumentEvaluator{_sectionId}.evaluate();
-  ls::std::io::SectionPairIdentifierArgumentEvaluator(_sectionId).evaluate();
+  EmptyStringArgumentEvaluator{_sectionId}.evaluate();
+  SectionPairIdentifierArgumentEvaluator(_sectionId).evaluate();
   this->sectionId = _sectionId;
 }

source/ls-std/io/section-pair/reader/SectionPairFileReader.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -16,53 +16,68 @@
 #include <ls-std/io/section-pair/validator/SectionPairFileExtensionValidator.hpp>
 #include <memory>
 
-ls::std::io::SectionPairFileReader::SectionPairFileReader(const ls::std::io::SectionPairFileReaderParameter &_parameter) : ls::std::core::Class("SectionPairFileReader")
+using ls::std::core::Class;
+using ls::std::core::ConditionalFunctionExecutor;
+using ls::std::core::IllegalArgumentException;
+using ls::std::core::type::byte_field;
+using ls::std::io::File;
+using ls::std::io::FileExistenceEvaluator;
+using ls::std::io::FileReader;
+using ls::std::io::SectionPairDocument;
+using ls::std::io::SectionPairFileExtensionValidator;
+using ls::std::io::SectionPairFileReader;
+using ls::std::io::SectionPairFileReaderParameter;
+using std::make_shared;
+using std::shared_ptr;
+using std::string;
+
+SectionPairFileReader::SectionPairFileReader(const SectionPairFileReaderParameter &_parameter) : Class("SectionPairFileReader")
 {
   this->parameter = _parameter;
-  ls::std::core::ConditionalFunctionExecutor{this->parameter.getFileExistenceEvaluator() == nullptr}.execute([this] { _createFileExistenceEvaluator(); });
+  ConditionalFunctionExecutor{this->parameter.getFileExistenceEvaluator() == nullptr}.execute([this] { _createFileExistenceEvaluator(); });
   this->parameter.getFileExistenceEvaluator()->evaluate();
   this->_checkFileExtension();
-  ls::std::core::ConditionalFunctionExecutor{this->parameter.getReader() == nullptr}.execute([this] { _createReader(); });
-  ls::std::core::ConditionalFunctionExecutor{this->parameter.getDocument() == nullptr}.execute([this] { _createDocument(); });
+  ConditionalFunctionExecutor{this->parameter.getReader() == nullptr}.execute([this] { _createReader(); });
+  ConditionalFunctionExecutor{this->parameter.getDocument() == nullptr}.execute([this] { _createDocument(); });
 }
 
-ls::std::io::SectionPairFileReader::~SectionPairFileReader() noexcept = default;
+SectionPairFileReader::~SectionPairFileReader() noexcept = default;
 
-::std::shared_ptr<ls::std::io::SectionPairDocument> ls::std::io::SectionPairFileReader::getDocument()
+shared_ptr<SectionPairDocument> SectionPairFileReader::getDocument()
 {
   return this->parameter.getDocument();
 }
 
-ls::std::core::type::byte_field ls::std::io::SectionPairFileReader::read()
+byte_field SectionPairFileReader::read()
 {
   this->parameter.getDocument()->clear();
-  ls::std::core::type::byte_field data = this->parameter.getReader()->read();
+  byte_field data = this->parameter.getReader()->read();
   this->parameter.getDocument()->unmarshal(data);
 
   return data;
 }
 
-void ls::std::io::SectionPairFileReader::_checkFileExtension()
+void SectionPairFileReader::_checkFileExtension()
 {
-  if (!ls::std::io::SectionPairFileExtensionValidator{this->parameter.getFilePath()}.isValid())
+  if (!SectionPairFileExtensionValidator{this->parameter.getFilePath()}.isValid())
   {
-    ::std::string message = "\"" + this->parameter.getFilePath() + "\" does not have a valid section pair file extension (.txt or .sp)!";
-    throw ls::std::core::IllegalArgumentException{message};
+    string message = "\"" + this->parameter.getFilePath() + "\" does not have a valid section pair file extension (.txt or .sp)!";
+    throw IllegalArgumentException{message};
   }
 }
 
-void ls::std::io::SectionPairFileReader::_createDocument()
+void SectionPairFileReader::_createDocument()
 {
-  this->parameter.setDocument(::std::make_shared<ls::std::io::SectionPairDocument>());
+  this->parameter.setDocument(make_shared<SectionPairDocument>());
 }
 
-void ls::std::io::SectionPairFileReader::_createFileExistenceEvaluator()
+void SectionPairFileReader::_createFileExistenceEvaluator()
 {
-  this->parameter.setFileExistenceEvaluator(::std::make_shared<ls::std::io::FileExistenceEvaluator>(this->parameter.getFilePath()));
+  this->parameter.setFileExistenceEvaluator(make_shared<FileExistenceEvaluator>(this->parameter.getFilePath()));
 }
 
-void ls::std::io::SectionPairFileReader::_createReader()
+void SectionPairFileReader::_createReader()
 {
-  ls::std::io::File file{this->parameter.getFilePath()};
-  this->parameter.setReader(::std::make_shared<ls::std::io::FileReader>(file));
+  File file{this->parameter.getFilePath()};
+  this->parameter.setReader(make_shared<FileReader>(file));
 }

source/ls-std/io/section-pair/reader/SectionPairFileReaderParameter.cpp

@@ -3,52 +3,59 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2023-02-21
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/io/section-pair/reader/SectionPairFileReaderParameter.hpp>
 
-ls::std::io::SectionPairFileReaderParameter::SectionPairFileReaderParameter() = default;
+using ls::std::core::interface_type::IEvaluator;
+using ls::std::core::interface_type::IReader;
+using ls::std::io::SectionPairDocument;
+using ls::std::io::SectionPairFileReaderParameter;
+using std::shared_ptr;
+using std::string;
 
-ls::std::io::SectionPairFileReaderParameter::~SectionPairFileReaderParameter() = default;
+SectionPairFileReaderParameter::SectionPairFileReaderParameter() = default;
 
-::std::shared_ptr<ls::std::io::SectionPairDocument> ls::std::io::SectionPairFileReaderParameter::getDocument()
+SectionPairFileReaderParameter::~SectionPairFileReaderParameter() = default;
+
+shared_ptr<SectionPairDocument> SectionPairFileReaderParameter::getDocument()
 {
   return this->document;
 }
 
-::std::shared_ptr<ls::std::core::interface_type::IEvaluator> ls::std::io::SectionPairFileReaderParameter::getFileExistenceEvaluator()
+shared_ptr<IEvaluator> SectionPairFileReaderParameter::getFileExistenceEvaluator()
 {
   return this->fileExistenceEvaluator;
 }
 
-::std::string ls::std::io::SectionPairFileReaderParameter::getFilePath()
+string SectionPairFileReaderParameter::getFilePath()
 {
   return this->filePath;
 }
 
-::std::shared_ptr<ls::std::core::interface_type::IReader> ls::std::io::SectionPairFileReaderParameter::getReader()
+shared_ptr<IReader> SectionPairFileReaderParameter::getReader()
 {
   return this->reader;
 }
 
-void ls::std::io::SectionPairFileReaderParameter::setDocument(const ::std::shared_ptr<ls::std::io::SectionPairDocument> &_document)
+void SectionPairFileReaderParameter::setDocument(const shared_ptr<SectionPairDocument> &_document)
 {
   this->document = _document;
 }
 
-void ls::std::io::SectionPairFileReaderParameter::setFileExistenceEvaluator(const ::std::shared_ptr<ls::std::core::interface_type::IEvaluator> &_fileExistenceEvaluator)
+void SectionPairFileReaderParameter::setFileExistenceEvaluator(const shared_ptr<IEvaluator> &_fileExistenceEvaluator)
 {
   this->fileExistenceEvaluator = _fileExistenceEvaluator;
 }
 
-void ls::std::io::SectionPairFileReaderParameter::setFilePath(const ::std::string &_filePath)
+void SectionPairFileReaderParameter::setFilePath(const string &_filePath)
 {
   this->filePath = _filePath;
 }
 
-void ls::std::io::SectionPairFileReaderParameter::setReader(const ::std::shared_ptr<ls::std::core::interface_type::IReader> &_reader)
+void SectionPairFileReaderParameter::setReader(const shared_ptr<IReader> &_reader)
 {
   this->reader = _reader;
 }

source/ls-std/io/section-pair/serialization/SerializableSectionPairDocument.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-16
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -12,25 +12,37 @@
 #include <ls-std/io/section-pair/serialization/SerializableSectionPairDocument.hpp>
 #include <string>
 
-ls::std::io::SerializableSectionPairDocument::SerializableSectionPairDocument(const ls::std::io::SerializableSectionPairParameter &_parameter) : ls::std::core::Class("SerializableSectionPairDocument")
+using ls::std::core::Class;
+using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::core::type::byte_field;
+using ls::std::io::SectionPairDocument;
+using ls::std::io::SectionPairSection;
+using ls::std::io::SerializableSectionPairDocument;
+using ls::std::io::SerializableSectionPairParameter;
+using std::dynamic_pointer_cast;
+using std::make_shared;
+using std::shared_ptr;
+using std::string;
+
+SerializableSectionPairDocument::SerializableSectionPairDocument(const SerializableSectionPairParameter &_parameter) : Class("SerializableSectionPairDocument")
 {
-  ::std::string message = this->getClassName() + ": model reference is null!";
-  ls::std::core::NullPointerArgumentEvaluator{_parameter.getValue(), message}.evaluate();
+  string message = this->getClassName() + ": model reference is null!";
+  NullPointerArgumentEvaluator{_parameter.getValue(), message}.evaluate();
   this->parameter = _parameter;
 }
 
-ls::std::io::SerializableSectionPairDocument::~SerializableSectionPairDocument() noexcept = default;
+SerializableSectionPairDocument::~SerializableSectionPairDocument() noexcept = default;
 
-::std::shared_ptr<ls::std::core::Class> ls::std::io::SerializableSectionPairDocument::getValue()
+shared_ptr<Class> SerializableSectionPairDocument::getValue()
 {
   return this->parameter.getValue();
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairDocument::marshal()
+byte_field SerializableSectionPairDocument::marshal()
 {
-  ::std::shared_ptr<ls::std::io::SectionPairDocument> document = ::std::dynamic_pointer_cast<ls::std::io::SectionPairDocument>(this->parameter.getValue());
-  ::std::string newLine = this->parameter.getNewLine();
-  ls::std::core::type::byte_field serializedDocument = document->getHeader() + newLine;
+  shared_ptr<SectionPairDocument> document = dynamic_pointer_cast<SectionPairDocument>(this->parameter.getValue());
+  string newLine = this->parameter.getNewLine();
+  byte_field serializedDocument = document->getHeader() + newLine;
 
   for (const auto &_section : document->getSectionList())
   {
@@ -41,12 +53,12 @@ ls::std::core::type::byte_field ls::std::io::SerializableSectionPairDocument::ma
   return serializedDocument;
 }
 
-void ls::std::io::SerializableSectionPairDocument::unmarshal(const ls::std::core::type::byte_field &_data)
+void SerializableSectionPairDocument::unmarshal(const byte_field &_data)
 {
-  ls::std::core::type::byte_field serializedDocument = _data;
-  size_t headerSize = ::std::dynamic_pointer_cast<ls::std::io::SectionPairDocument>(this->parameter.getValue())->getHeader().size() + this->parameter.getNewLine().size();
+  byte_field serializedDocument = _data;
+  size_t headerSize = dynamic_pointer_cast<SectionPairDocument>(this->parameter.getValue())->getHeader().size() + this->parameter.getNewLine().size();
   serializedDocument = serializedDocument.substr(headerSize);
-  ls::std::core::type::byte_field serializedSection{};
+  byte_field serializedSection{};
 
   do
   {
@@ -56,20 +68,20 @@ void ls::std::io::SerializableSectionPairDocument::unmarshal(const ls::std::core
   } while (!serializedDocument.empty());
 }
 
-void ls::std::io::SerializableSectionPairDocument::_addSection(const ls::std::core::type::byte_field &_serializedSection)
+void SerializableSectionPairDocument::_addSection(const byte_field &_serializedSection)
 {
-  ::std::shared_ptr<ls::std::io::SectionPairSection> section = ::std::make_shared<ls::std::io::SectionPairSection>("tmp-id");
+  shared_ptr<SectionPairSection> section = make_shared<SectionPairSection>("tmp-id");
   section->reserveNewLine(this->parameter.getNewLine());
   section->unmarshal(_serializedSection);
-  ::std::dynamic_pointer_cast<ls::std::io::SectionPairDocument>(this->parameter.getValue())->add(section);
+  dynamic_pointer_cast<SectionPairDocument>(this->parameter.getValue())->add(section);
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairDocument::_getCurrentRow(size_t _iterations, const ls::std::core::type::byte_field &_serializedDocument)
+byte_field SerializableSectionPairDocument::_getCurrentRow(size_t _iterations, const byte_field &_serializedDocument)
 {
-  ::std::string newLine = this->parameter.getNewLine();
-  ::std::string currentRow{};
+  string newLine = this->parameter.getNewLine();
+  string currentRow{};
 
-  if (_iterations == 1 || _serializedDocument.find('[') != ::std::string::npos)
+  if (_iterations == 1 || _serializedDocument.find('[') != string::npos)
   {
     currentRow = _serializedDocument.substr(0, _serializedDocument.find(newLine + newLine) + 2 * newLine.size());
   }
@@ -81,13 +93,13 @@ ls::std::core::type::byte_field ls::std::io::SerializableSectionPairDocument::_g
   return currentRow;
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairDocument::_getNextSerializedSection(const ls::std::core::type::byte_field &_serializedDocument)
+byte_field SerializableSectionPairDocument::_getNextSerializedSection(const byte_field &_serializedDocument)
 {
-  ls::std::core::type::byte_field serializedSection{}, currentRow{};
+  byte_field serializedSection{}, currentRow{};
   size_t iterations{};
-  ls::std::core::type::byte_field serializedDocument = _serializedDocument;
+  byte_field serializedDocument = _serializedDocument;
   bool isNotNewSection{};
-  ::std::string newLine = this->parameter.getNewLine();
+  string newLine = this->parameter.getNewLine();
 
   do
   {
@@ -101,8 +113,8 @@ ls::std::core::type::byte_field ls::std::io::SerializableSectionPairDocument::_g
   return serializedDocument.empty() ? serializedSection : serializedSection.substr(0, serializedSection.size() - newLine.size());
 }
 
-bool ls::std::io::SerializableSectionPairDocument::_isNotNewSection(const ls::std::core::type::byte_field &_currentRow)
+bool SerializableSectionPairDocument::_isNotNewSection(const byte_field &_currentRow)
 {
-  ::std::string newLine = this->parameter.getNewLine();
-  return _currentRow.find(newLine + newLine) == ::std::string::npos;
+  string newLine = this->parameter.getNewLine();
+  return _currentRow.find(newLine + newLine) == string::npos;
 }

source/ls-std/io/section-pair/serialization/SerializableSectionPairParameter.cpp

@@ -3,34 +3,40 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-17
-* Changed:         2023-02-17
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/io/NewLine.hpp>
 #include <ls-std/io/section-pair/serialization/SerializableSectionPairParameter.hpp>
 
-ls::std::io::SerializableSectionPairParameter::SerializableSectionPairParameter() : parseNewLine(ls::std::io::NewLine::get())
+using ls::std::core::Class;
+using ls::std::io::NewLine;
+using ls::std::io::SerializableSectionPairParameter;
+using std::shared_ptr;
+using std::string;
+
+SerializableSectionPairParameter::SerializableSectionPairParameter() : parseNewLine(NewLine::get())
 {}
 
-ls::std::io::SerializableSectionPairParameter::~SerializableSectionPairParameter() = default;
+SerializableSectionPairParameter::~SerializableSectionPairParameter() = default;
 
-::std::string ls::std::io::SerializableSectionPairParameter::getNewLine()
+string SerializableSectionPairParameter::getNewLine()
 {
   return this->parseNewLine;
 }
 
-::std::shared_ptr<ls::std::core::Class> ls::std::io::SerializableSectionPairParameter::getValue() const
+shared_ptr<Class> SerializableSectionPairParameter::getValue() const
 {
   return this->value;
 }
 
-void ls::std::io::SerializableSectionPairParameter::setNewLine(const ::std::string &_newLine)
+void SerializableSectionPairParameter::setNewLine(const string &_newLine)
 {
   this->parseNewLine = _newLine;
 }
 
-void ls::std::io::SerializableSectionPairParameter::setValue(const ::std::shared_ptr<ls::std::core::Class> &_value)
+void SerializableSectionPairParameter::setValue(const shared_ptr<Class> &_value)
 {
   this->value = _value;
 }

source/ls-std/io/section-pair/serialization/SerializableSectionPairRow.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-11
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -15,31 +15,45 @@
 #include <ls-std/io/section-pair/model/SectionPairRowSingleValue.hpp>
 #include <ls-std/io/section-pair/serialization/SerializableSectionPairRow.hpp>
 
-ls::std::io::SerializableSectionPairRow::SerializableSectionPairRow(const ls::std::io::SerializableSectionPairParameter &_parameter) : ls::std::core::Class("SerializableSectionPairRow")
+using ls::std::core::Class;
+using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::core::type::byte_field;
+using ls::std::io::SectionPairRow;
+using ls::std::io::SectionPairRowListValue;
+using ls::std::io::SectionPairRowListValueArgumentEvaluator;
+using ls::std::io::SectionPairRowSingleValue;
+using ls::std::io::SectionPairRowSingleValueArgumentEvaluator;
+using ls::std::io::SerializableSectionPairParameter;
+using ls::std::io::SerializableSectionPairRow;
+using std::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::string;
+
+SerializableSectionPairRow::SerializableSectionPairRow(const SerializableSectionPairParameter &_parameter) : Class("SerializableSectionPairRow")
 {
-  ::std::string message = this->getClassName() + ": model reference is null!";
-  ls::std::core::NullPointerArgumentEvaluator{_parameter.getValue(), message}.evaluate();
+  string message = this->getClassName() + ": model reference is null!";
+  NullPointerArgumentEvaluator{_parameter.getValue(), message}.evaluate();
   this->parameter = _parameter;
 }
 
-ls::std::io::SerializableSectionPairRow::~SerializableSectionPairRow() noexcept = default;
+SerializableSectionPairRow::~SerializableSectionPairRow() noexcept = default;
 
-::std::shared_ptr<ls::std::core::Class> ls::std::io::SerializableSectionPairRow::getValue()
+shared_ptr<Class> SerializableSectionPairRow::getValue()
 {
   return this->parameter.getValue();
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairRow::marshal()
+byte_field SerializableSectionPairRow::marshal()
 {
-  ls::std::core::type::byte_field data = this->_marshalKey();
-  ::std::shared_ptr<SectionPairRow> row = ::std::dynamic_pointer_cast<ls::std::io::SectionPairRow>(this->parameter.getValue());
+  byte_field data = this->_marshalKey();
+  shared_ptr<SectionPairRow> row = dynamic_pointer_cast<SectionPairRow>(this->parameter.getValue());
   row->getValue()->reserveNewLine(this->parameter.getNewLine());
   return data + row->getValue()->marshal();
 }
 
-void ls::std::io::SerializableSectionPairRow::unmarshal(const ls::std::core::type::byte_field &_data)
+void SerializableSectionPairRow::unmarshal(const byte_field &_data)
 {
-  ::std::shared_ptr<ls::std::io::SectionPairRow> row = ::std::dynamic_pointer_cast<ls::std::io::SectionPairRow>(this->parameter.getValue());
+  shared_ptr<SectionPairRow> row = dynamic_pointer_cast<SectionPairRow>(this->parameter.getValue());
   row->getValue()->reserveNewLine(this->parameter.getNewLine());
 
   if (row->isSingleValue())
@@ -53,10 +67,10 @@ void ls::std::io::SerializableSectionPairRow::unmarshal(const ls::std::core::typ
   }
 }
 
-::std::string ls::std::io::SerializableSectionPairRow::_marshalKey()
+string SerializableSectionPairRow::_marshalKey()
 {
-  ::std::string serializedKey{};
-  ::std::shared_ptr<ls::std::io::SectionPairRow> row = ::std::dynamic_pointer_cast<ls::std::io::SectionPairRow>(this->parameter.getValue());
+  string serializedKey{};
+  shared_ptr<SectionPairRow> row = dynamic_pointer_cast<SectionPairRow>(this->parameter.getValue());
 
   if (row->isSingleValue())
   {
@@ -71,30 +85,30 @@ void ls::std::io::SerializableSectionPairRow::unmarshal(const ls::std::core::typ
   return serializedKey;
 }
 
-void ls::std::io::SerializableSectionPairRow::_unmarshalListValue(const ls::std::core::type::byte_field &_data)
+void SerializableSectionPairRow::_unmarshalListValue(const byte_field &_data)
 {
-  ls::std::io::SectionPairRowListValueArgumentEvaluator{_data}.evaluate();
-  ::std::string::size_type separatorPosition = _data.find(':');
-  ::std::string newLine = this->parameter.getNewLine();
+  SectionPairRowListValueArgumentEvaluator{_data}.evaluate();
+  string::size_type separatorPosition = _data.find(':');
+  string newLine = this->parameter.getNewLine();
 
-  if (separatorPosition != ::std::string::npos)
+  if (separatorPosition != string::npos)
   {
-    ::std::shared_ptr<ls::std::io::SectionPairRow> row = ::std::dynamic_pointer_cast<ls::std::io::SectionPairRow>(this->parameter.getValue());
+    shared_ptr<SectionPairRow> row = dynamic_pointer_cast<SectionPairRow>(this->parameter.getValue());
     row->setKey(_data.substr(0, separatorPosition));
-    ::std::string::size_type newLinePosition = _data.find(newLine) + (newLine.size() - 1);
-    ::std::dynamic_pointer_cast<ls::std::io::SectionPairRowListValue>(row->getValue())->unmarshal(_data.substr(newLinePosition + 1));
+    string::size_type newLinePosition = _data.find(newLine) + (newLine.size() - 1);
+    dynamic_pointer_cast<SectionPairRowListValue>(row->getValue())->unmarshal(_data.substr(newLinePosition + 1));
   }
 }
 
-void ls::std::io::SerializableSectionPairRow::_unmarshalSingleValue(const ls::std::core::type::byte_field &_data)
+void SerializableSectionPairRow::_unmarshalSingleValue(const byte_field &_data)
 {
-  ls::std::io::SectionPairRowSingleValueArgumentEvaluator{_data}.evaluate();
-  ::std::string::size_type position = _data.find('=');
+  SectionPairRowSingleValueArgumentEvaluator{_data}.evaluate();
+  string::size_type position = _data.find('=');
 
-  if (position != ::std::string::npos)
+  if (position != string::npos)
   {
-    ::std::shared_ptr<ls::std::io::SectionPairRow> row = ::std::dynamic_pointer_cast<ls::std::io::SectionPairRow>(this->parameter.getValue());
+    shared_ptr<SectionPairRow> row = dynamic_pointer_cast<SectionPairRow>(this->parameter.getValue());
     row->setKey(_data.substr(0, position));
-    ::std::dynamic_pointer_cast<ls::std::io::SectionPairRowSingleValue>(row->getValue())->unmarshal(_data.substr(position + 1));
+    dynamic_pointer_cast<SectionPairRowSingleValue>(row->getValue())->unmarshal(_data.substr(position + 1));
   }
 }

source/ls-std/io/section-pair/serialization/SerializableSectionPairRowListValue.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-11
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -12,25 +12,36 @@
 #include <ls-std/io/section-pair/model/SectionPairRowListValue.hpp>
 #include <ls-std/io/section-pair/serialization/SerializableSectionPairRowListValue.hpp>
 
-ls::std::io::SerializableSectionPairRowListValue::SerializableSectionPairRowListValue(const ls::std::io::SerializableSectionPairParameter &_parameter) : ls::std::core::Class("SerializableSectionPairRowListValue")
+using ls::std::core::Class;
+using ls::std::core::EmptyStringArgumentEvaluator;
+using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::core::type::byte_field;
+using ls::std::io::SectionPairRowListValue;
+using ls::std::io::SerializableSectionPairParameter;
+using ls::std::io::SerializableSectionPairRowListValue;
+using std::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::string;
+
+SerializableSectionPairRowListValue::SerializableSectionPairRowListValue(const SerializableSectionPairParameter &_parameter) : Class("SerializableSectionPairRowListValue")
 {
-  ::std::string message = this->getClassName() + ": model reference is null!";
-  ls::std::core::NullPointerArgumentEvaluator{_parameter.getValue(), message}.evaluate();
+  string message = this->getClassName() + ": model reference is null!";
+  NullPointerArgumentEvaluator{_parameter.getValue(), message}.evaluate();
   this->parameter = _parameter;
 }
 
-ls::std::io::SerializableSectionPairRowListValue::~SerializableSectionPairRowListValue() noexcept = default;
+SerializableSectionPairRowListValue::~SerializableSectionPairRowListValue() noexcept = default;
 
-::std::shared_ptr<ls::std::core::Class> ls::std::io::SerializableSectionPairRowListValue::getValue()
+shared_ptr<Class> SerializableSectionPairRowListValue::getValue()
 {
   return this->parameter.getValue();
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairRowListValue::marshal()
+byte_field SerializableSectionPairRowListValue::marshal()
 {
-  ls::std::core::type::byte_field data{};
+  byte_field data{};
 
-  for (const auto &_value : ::std::dynamic_pointer_cast<ls::std::io::SectionPairRowListValue>(this->getValue())->getList())
+  for (const auto &_value : dynamic_pointer_cast<SectionPairRowListValue>(this->getValue())->getList())
   {
     data += "  " + _value + this->parameter.getNewLine();
   }
@@ -38,27 +49,27 @@ ls::std::core::type::byte_field ls::std::io::SerializableSectionPairRowListValue
   return data;
 }
 
-void ls::std::io::SerializableSectionPairRowListValue::unmarshal(const ls::std::core::type::byte_field &_data)
+void SerializableSectionPairRowListValue::unmarshal(const byte_field &_data)
 {
-  ls::std::core::EmptyStringArgumentEvaluator{_data}.evaluate();
-  ls::std::core::type::byte_field searchText = _data;
-  ::std::string newLine = this->parameter.getNewLine();
+  EmptyStringArgumentEvaluator{_data}.evaluate();
+  byte_field searchText = _data;
+  string newLine = this->parameter.getNewLine();
 
   while (!searchText.empty() && searchText != newLine)
   {
-    ::std::string::size_type positionOfNewLine = searchText.find(newLine);
-    ::std::string line = ls::std::io::SerializableSectionPairRowListValue::_getLine(positionOfNewLine, searchText);
+    string::size_type positionOfNewLine = searchText.find(newLine);
+    string line = SerializableSectionPairRowListValue::_getLine(positionOfNewLine, searchText);
     line = line.substr(2);
-    ::std::dynamic_pointer_cast<ls::std::io::SectionPairRowListValue>(this->getValue())->add(line);
+    dynamic_pointer_cast<SectionPairRowListValue>(this->getValue())->add(line);
     this->_updateSearchText(positionOfNewLine, searchText);
   }
 }
 
-::std::string ls::std::io::SerializableSectionPairRowListValue::_getLine(::std::string::size_type _position, const ls::std::core::type::byte_field &_searchText)
+string SerializableSectionPairRowListValue::_getLine(string::size_type _position, const byte_field &_searchText)
 {
-  ::std::string line{};
+  string line{};
 
-  if (_position != ::std::string::npos)
+  if (_position != string::npos)
   {
     line = _searchText.substr(0, _position);
   }
@@ -70,9 +81,9 @@ void ls::std::io::SerializableSectionPairRowListValue::unmarshal(const ls::std::
   return line;
 }
 
-void ls::std::io::SerializableSectionPairRowListValue::_updateSearchText(::std::string::size_type _position, ls::std::core::type::byte_field &_searchText)
+void SerializableSectionPairRowListValue::_updateSearchText(string::size_type _position, byte_field &_searchText)
 {
-  if (_position != ::std::string::npos)
+  if (_position != string::npos)
   {
     _searchText = _searchText.substr(_position + this->parameter.getNewLine().size());
   }

source/ls-std/io/section-pair/serialization/SerializableSectionPairRowSingleValue.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-11
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -12,27 +12,38 @@
 #include <ls-std/io/section-pair/model/SectionPairRowSingleValue.hpp>
 #include <ls-std/io/section-pair/serialization/SerializableSectionPairRowSingleValue.hpp>
 
-ls::std::io::SerializableSectionPairRowSingleValue::SerializableSectionPairRowSingleValue(const ls::std::io::SerializableSectionPairParameter &_parameter) : ls::std::core::Class("SerializableSectionPairRowSingleValue")
+using ls::std::core::Class;
+using ls::std::core::EmptyStringArgumentEvaluator;
+using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::core::type::byte_field;
+using ls::std::io::SectionPairRowSingleValue;
+using ls::std::io::SerializableSectionPairParameter;
+using ls::std::io::SerializableSectionPairRowSingleValue;
+using std::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::string;
+
+SerializableSectionPairRowSingleValue::SerializableSectionPairRowSingleValue(const SerializableSectionPairParameter &_parameter) : Class("SerializableSectionPairRowSingleValue")
 {
-  ::std::string message = this->getClassName() + ": model reference is null!";
-  ls::std::core::NullPointerArgumentEvaluator{_parameter.getValue(), message}.evaluate();
+  string message = this->getClassName() + ": model reference is null!";
+  NullPointerArgumentEvaluator{_parameter.getValue(), message}.evaluate();
   this->parameter = _parameter;
 }
 
-ls::std::io::SerializableSectionPairRowSingleValue::~SerializableSectionPairRowSingleValue() noexcept = default;
+SerializableSectionPairRowSingleValue::~SerializableSectionPairRowSingleValue() noexcept = default;
 
-::std::shared_ptr<ls::std::core::Class> ls::std::io::SerializableSectionPairRowSingleValue::getValue()
+shared_ptr<Class> SerializableSectionPairRowSingleValue::getValue()
 {
   return this->parameter.getValue();
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairRowSingleValue::marshal()
+byte_field SerializableSectionPairRowSingleValue::marshal()
 {
-  return ::std::dynamic_pointer_cast<ls::std::io::SectionPairRowSingleValue>(this->parameter.getValue())->get() + this->parameter.getNewLine();
+  return dynamic_pointer_cast<SectionPairRowSingleValue>(this->parameter.getValue())->get() + this->parameter.getNewLine();
 }
 
-void ls::std::io::SerializableSectionPairRowSingleValue::unmarshal(const ls::std::core::type::byte_field &_data)
+void SerializableSectionPairRowSingleValue::unmarshal(const byte_field &_data)
 {
-  ls::std::core::EmptyStringArgumentEvaluator{_data}.evaluate();
-  ::std::dynamic_pointer_cast<ls::std::io::SectionPairRowSingleValue>(this->parameter.getValue())->set(_data);
+  EmptyStringArgumentEvaluator{_data}.evaluate();
+  dynamic_pointer_cast<SectionPairRowSingleValue>(this->parameter.getValue())->set(_data);
 }

source/ls-std/io/section-pair/serialization/SerializableSectionPairSection.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-14
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -13,23 +13,38 @@
 #include <ls-std/io/section-pair/model/SectionPairSection.hpp>
 #include <ls-std/io/section-pair/serialization/SerializableSectionPairSection.hpp>
 
-ls::std::io::SerializableSectionPairSection::SerializableSectionPairSection(const ls::std::io::SerializableSectionPairParameter &_parameter) : ls::std::core::Class("SerializableSectionPairSection")
-{
-  ::std::string message = this->getClassName() + ": model reference is null!";
-  ls::std::core::NullPointerArgumentEvaluator(_parameter.getValue(), message).evaluate();
+using ls::std::core::Class;
+using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::core::type::byte_field;
+using ls::std::io::section_pair_row_list_element;
+using ls::std::io::SectionPairRow;
+using ls::std::io::SectionPairRowEnumType;
+using ls::std::io::SectionPairSection;
+using ls::std::io::SectionPairSectionArgumentEvaluator;
+using ls::std::io::SerializableSectionPairParameter;
+using ls::std::io::SerializableSectionPairSection;
+using std::dynamic_pointer_cast;
+using std::make_shared;
+using std::shared_ptr;
+using std::string;
+
+SerializableSectionPairSection::SerializableSectionPairSection(const SerializableSectionPairParameter &_parameter) : Class("SerializableSectionPairSection")
+{
+  string message = this->getClassName() + ": model reference is null!";
+  NullPointerArgumentEvaluator(_parameter.getValue(), message).evaluate();
   this->parameter = _parameter;
 }
 
-ls::std::io::SerializableSectionPairSection::~SerializableSectionPairSection() noexcept = default;
+SerializableSectionPairSection::~SerializableSectionPairSection() noexcept = default;
 
-::std::shared_ptr<ls::std::core::Class> ls::std::io::SerializableSectionPairSection::getValue()
+shared_ptr<Class> SerializableSectionPairSection::getValue()
 {
   return this->parameter.getValue();
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::marshal()
+byte_field SerializableSectionPairSection::marshal()
 {
-  ls::std::core::type::byte_field serializedSection{};
+  byte_field serializedSection{};
 
   serializedSection += this->_marshalSectionId();
   serializedSection += this->_marshalRows();
@@ -37,25 +52,25 @@ ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::mar
   return serializedSection;
 }
 
-void ls::std::io::SerializableSectionPairSection::unmarshal(const ls::std::core::type::byte_field &_data)
+void SerializableSectionPairSection::unmarshal(const byte_field &_data)
 {
-  ls::std::io::SectionPairSectionArgumentEvaluator{_data}.evaluate();
+  SectionPairSectionArgumentEvaluator{_data}.evaluate();
   size_t sectionHeaderSize = this->_unmarshalSectionHeader(_data);
   this->_unmarshalRows(_data.substr(sectionHeaderSize));
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::_collectSectionRow(const ls::std::core::type::byte_field &_currentRows, ls::std::io::SectionPairRowEnumType &_type)
+byte_field SerializableSectionPairSection::_collectSectionRow(const byte_field &_currentRows, SectionPairRowEnumType &_type)
 {
-  ::std::string row{};
-  ::std::string newLine = this->parameter.getNewLine();
-  ::std::string firstRow = _currentRows.substr(0, _currentRows.find(newLine) + newLine.size());
+  string row{};
+  string newLine = this->parameter.getNewLine();
+  string firstRow = _currentRows.substr(0, _currentRows.find(newLine) + newLine.size());
 
-  if (ls::std::io::SerializableSectionPairSection::_isSingleValueRow(firstRow))
+  if (SerializableSectionPairSection::_isSingleValueRow(firstRow))
   {
-    row = ls::std::io::SerializableSectionPairSection::_collectSectionSingleValueRow(firstRow, _type);
+    row = SerializableSectionPairSection::_collectSectionSingleValueRow(firstRow, _type);
   }
 
-  if (ls::std::io::SerializableSectionPairSection::_isListValueRow(firstRow))
+  if (SerializableSectionPairSection::_isListValueRow(firstRow))
   {
     row = this->_collectSectionListValueRow(_currentRows, _type);
   }
@@ -63,12 +78,12 @@ ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::_co
   return row;
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::_collectSectionListValueRow(const ls::std::core::type::byte_field &_currentRows, ls::std::io::SectionPairRowEnumType &_type)
+byte_field SerializableSectionPairSection::_collectSectionListValueRow(const byte_field &_currentRows, SectionPairRowEnumType &_type)
 {
-  ls::std::core::type::byte_field currentRows = _currentRows;
-  ls::std::core::type::byte_field currentRow{}, row{};
-  ::std::string newLine = this->parameter.getNewLine();
-  _type = ls::std::io::SectionPairRowEnumType::SECTION_PAIR_ROW_LIST_VALUE;
+  byte_field currentRows = _currentRows;
+  byte_field currentRow{}, row{};
+  string newLine = this->parameter.getNewLine();
+  _type = SectionPairRowEnumType::SECTION_PAIR_ROW_LIST_VALUE;
   size_t iterations{};
   bool isStillListRow{};
 
@@ -82,7 +97,7 @@ ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::_co
     ++iterations;
     currentRow = currentRows.substr(0, currentRows.find(newLine) + newLine.size());
     currentRows = currentRows.substr(currentRow.size());
-    isStillListRow = !ls::std::io::SerializableSectionPairSection::_isStartingValueRow(currentRow) || iterations == 1;
+    isStillListRow = !SerializableSectionPairSection::_isStartingValueRow(currentRow) || iterations == 1;
 
     if (isStillListRow)
     {
@@ -93,13 +108,13 @@ ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::_co
   return row;
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::_collectSectionSingleValueRow(const ls::std::core::type::byte_field &_firstRow, ls::std::io::SectionPairRowEnumType &_type)
+byte_field SerializableSectionPairSection::_collectSectionSingleValueRow(const byte_field &_firstRow, SectionPairRowEnumType &_type)
 {
-  _type = ls::std::io::SectionPairRowEnumType::SECTION_PAIR_ROW_SINGLE_VALUE;
+  _type = SectionPairRowEnumType::SECTION_PAIR_ROW_SINGLE_VALUE;
   return _firstRow;
 }
 
-size_t ls::std::io::SerializableSectionPairSection::_getNthSubStringPosition(const ls::std::core::type::byte_field &_text, const ls::std::core::type::byte_field &_subText)
+size_t SerializableSectionPairSection::_getNthSubStringPosition(const byte_field &_text, const byte_field &_subText)
 {
   size_t position = -1;
   size_t amount{};
@@ -121,11 +136,11 @@ size_t ls::std::io::SerializableSectionPairSection::_getNthSubStringPosition(con
   return position;
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::_getSectionHeader(const ls::std::core::type::byte_field &_data)
+byte_field SerializableSectionPairSection::_getSectionHeader(const byte_field &_data)
 {
-  ls::std::core::type::byte_field sectionHeader{};
-  ::std::string newLine = this->parameter.getNewLine();
-  size_t position = ls::std::io::SerializableSectionPairSection::_getNthSubStringPosition(_data, newLine);
+  byte_field sectionHeader{};
+  string newLine = this->parameter.getNewLine();
+  size_t position = SerializableSectionPairSection::_getNthSubStringPosition(_data, newLine);
 
   if (position != -1)
   {
@@ -135,35 +150,35 @@ ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::_ge
   return sectionHeader;
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::_getSectionId(const ls::std::core::type::byte_field &_sectionHeader)
+byte_field SerializableSectionPairSection::_getSectionId(const byte_field &_sectionHeader)
 {
-  ls::std::core::type::byte_field sectionId = _sectionHeader.substr(_sectionHeader.find('[') + 1);
+  byte_field sectionId = _sectionHeader.substr(_sectionHeader.find('[') + 1);
   return sectionId.substr(0, sectionId.find(']'));
 }
 
-bool ls::std::io::SerializableSectionPairSection::_isListValueRow(const ::std::string &_currentRow)
+bool SerializableSectionPairSection::_isListValueRow(const string &_currentRow)
 {
-  return _currentRow.find(':') != ::std::string::npos;
+  return _currentRow.find(':') != string::npos;
 }
 
-bool ls::std::io::SerializableSectionPairSection::_isStartingValueRow(const ::std::string &_currentRow)
+bool SerializableSectionPairSection::_isStartingValueRow(const string &_currentRow)
 {
-  bool isSingleValue = ls::std::io::SerializableSectionPairSection::_isSingleValueRow(_currentRow);
-  bool isListValue = ls::std::io::SerializableSectionPairSection::_isListValueRow(_currentRow);
+  bool isSingleValue = SerializableSectionPairSection::_isSingleValueRow(_currentRow);
+  bool isListValue = SerializableSectionPairSection::_isListValueRow(_currentRow);
 
   return isSingleValue || isListValue;
 }
 
-bool ls::std::io::SerializableSectionPairSection::_isSingleValueRow(const ::std::string &_currentRow)
+bool SerializableSectionPairSection::_isSingleValueRow(const string &_currentRow)
 {
-  return _currentRow.find('=') != ::std::string::npos;
+  return _currentRow.find('=') != string::npos;
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::_marshalRows()
+byte_field SerializableSectionPairSection::_marshalRows()
 {
-  ls::std::core::type::byte_field serializedSectionRows{};
+  byte_field serializedSectionRows{};
 
-  for (const auto &_row : ::std::dynamic_pointer_cast<ls::std::io::SectionPairSection>(this->parameter.getValue())->getList())
+  for (const auto &_row : dynamic_pointer_cast<SectionPairSection>(this->parameter.getValue())->getList())
   {
     _row->reserveNewLine(this->parameter.getNewLine());
     serializedSectionRows += _row->marshal();
@@ -172,37 +187,37 @@ ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::_ma
   return serializedSectionRows;
 }
 
-ls::std::core::type::byte_field ls::std::io::SerializableSectionPairSection::_marshalSectionId()
+byte_field SerializableSectionPairSection::_marshalSectionId()
 {
-  ::std::string newLine = this->parameter.getNewLine();
-  return newLine + "[" + ::std::dynamic_pointer_cast<ls::std::io::SectionPairSection>(this->parameter.getValue())->getSectionId() + "]" + newLine + newLine;
+  string newLine = this->parameter.getNewLine();
+  return newLine + "[" + dynamic_pointer_cast<SectionPairSection>(this->parameter.getValue())->getSectionId() + "]" + newLine + newLine;
 }
 
-void ls::std::io::SerializableSectionPairSection::_unmarshalRow(const ::std::string &_sectionRow, ls::std::io::SectionPairRowEnumType _type)
+void SerializableSectionPairSection::_unmarshalRow(const string &_sectionRow, SectionPairRowEnumType _type)
 {
-  ls::std::io::section_pair_row_list_element row = ::std::make_shared<ls::std::io::SectionPairRow>("tmp-dir", _type);
+  section_pair_row_list_element row = make_shared<SectionPairRow>("tmp-dir", _type);
   row->reserveNewLine(this->parameter.getNewLine());
   row->unmarshal(_sectionRow);
-  ::std::dynamic_pointer_cast<ls::std::io::SectionPairSection>(this->parameter.getValue())->add(row);
+  dynamic_pointer_cast<SectionPairSection>(this->parameter.getValue())->add(row);
 }
 
-void ls::std::io::SerializableSectionPairSection::_unmarshalRows(const ls::std::core::type::byte_field &_serializedRows)
+void SerializableSectionPairSection::_unmarshalRows(const byte_field &_serializedRows)
 {
-  ::std::string currentRows = _serializedRows;
-  ls::std::io::SectionPairRowEnumType type{};
+  string currentRows = _serializedRows;
+  SectionPairRowEnumType type{};
 
   while (!currentRows.empty())
   {
-    ::std::string sectionRow = this->_collectSectionRow(currentRows, type);
+    string sectionRow = this->_collectSectionRow(currentRows, type);
     this->_unmarshalRow(sectionRow, type);
     currentRows = currentRows.substr(sectionRow.size());
   }
 }
 
-size_t ls::std::io::SerializableSectionPairSection::_unmarshalSectionHeader(const ls::std::core::type::byte_field &_data)
+size_t SerializableSectionPairSection::_unmarshalSectionHeader(const byte_field &_data)
 {
-  ls::std::core::type::byte_field sectionHeader = this->_getSectionHeader(_data);
-  ::std::dynamic_pointer_cast<ls::std::io::SectionPairSection>(this->parameter.getValue())->setSectionId(ls::std::io::SerializableSectionPairSection::_getSectionId(sectionHeader));
+  byte_field sectionHeader = this->_getSectionHeader(_data);
+  dynamic_pointer_cast<SectionPairSection>(this->parameter.getValue())->setSectionId(SerializableSectionPairSection::_getSectionId(sectionHeader));
 
   return sectionHeader.size();
 }

source/ls-std/io/section-pair/validator/SectionPairDocumentValidator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -11,26 +11,34 @@
 #include <ls-std/io/section-pair/validator/SectionPairSectionValidator.hpp>
 #include <regex>
 
-ls::std::io::SectionPairDocumentValidator::SectionPairDocumentValidator(::std::string _document) : ls::std::core::Class("SectionPairDocumentValidator"), document(::std::move(_document))
+using ls::std::core::Class;
+using ls::std::io::SectionPairDocumentValidator;
+using ls::std::io::SectionPairSectionValidator;
+using std::move;
+using std::regex;
+using std::regex_match;
+using std::string;
+
+SectionPairDocumentValidator::SectionPairDocumentValidator(string _document) : Class("SectionPairDocumentValidator"), document(::move(_document))
 {}
 
-ls::std::io::SectionPairDocumentValidator::~SectionPairDocumentValidator() noexcept = default;
+SectionPairDocumentValidator::~SectionPairDocumentValidator() noexcept = default;
 
-bool ls::std::io::SectionPairDocumentValidator::isValid()
+bool SectionPairDocumentValidator::isValid()
 {
-  ::std::string validationRegex = ls::std::io::SectionPairDocumentValidator::_getValidationRegex();
-  static ::std::regex documentRegex = ::std::regex{"^" + validationRegex + "$"};
+  string validationRegex = SectionPairDocumentValidator::_getValidationRegex();
+  static regex documentRegex = regex{"^" + validationRegex + "$"};
 
-  return ::std::regex_match(this->document, documentRegex);
+  return regex_match(this->document, documentRegex);
 }
 
-::std::string ls::std::io::SectionPairDocumentValidator::_getValidationRegex()
+string SectionPairDocumentValidator::_getValidationRegex()
 {
-  ::std::string newLine = R"(((\n)|(\r\n)))";
-  ::std::string documentHeader = R"((# {1}(section\-pair document))" + newLine + R"())";
-  ::std::string section = ls::std::io::SectionPairSectionValidator::getValidationRegex();
-  ::std::string atLeastOneSection = R"(()" + section + R"())";
-  ::std::string optionalSections = R"(()" + section + R"()*)";
+  string newLine = R"(((\n)|(\r\n)))";
+  string documentHeader = R"((# {1}(section\-pair document))" + newLine + R"())";
+  string section = SectionPairSectionValidator::getValidationRegex();
+  string atLeastOneSection = R"(()" + section + R"())";
+  string optionalSections = R"(()" + section + R"()*)";
 
   return documentHeader + atLeastOneSection + optionalSections;
 }

source/ls-std/io/section-pair/validator/SectionPairFileExtensionValidator.cpp

@@ -3,21 +3,26 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-21
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/io/section-pair/validator/SectionPairFileExtensionValidator.hpp>
 
-ls::std::io::SectionPairFileExtensionValidator::SectionPairFileExtensionValidator(::std::string _fileName) : ls::std::core::Class("SectionPairFileExtensionValidator"), fileName(::std::move(_fileName))
+using ls::std::core::Class;
+using ls::std::io::SectionPairFileExtensionValidator;
+using std::move;
+using std::string;
+
+SectionPairFileExtensionValidator::SectionPairFileExtensionValidator(string _fileName) : Class("SectionPairFileExtensionValidator"), fileName(::move(_fileName))
 {}
 
-ls::std::io::SectionPairFileExtensionValidator::~SectionPairFileExtensionValidator() noexcept = default;
+SectionPairFileExtensionValidator::~SectionPairFileExtensionValidator() noexcept = default;
 
-bool ls::std::io::SectionPairFileExtensionValidator::isValid()
+bool SectionPairFileExtensionValidator::isValid()
 {
-  ::std::string textFileExtension = ".txt";
-  ::std::string sectionPairFileExtension = ".sp";
+  string textFileExtension = ".txt";
+  string sectionPairFileExtension = ".sp";
   bool endsWithTextFileExtension = this->fileName.rfind(textFileExtension) == (this->fileName.size() - textFileExtension.size());
   bool endsWithSectionPairFileExtension = this->fileName.rfind(sectionPairFileExtension) == (this->fileName.size() - sectionPairFileExtension.size());
 

source/ls-std/io/section-pair/validator/SectionPairIdentifierValidator.cpp

@@ -3,30 +3,38 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-09
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/io/section-pair/validator/SectionPairIdentifierValidator.hpp>
 #include <regex>
 
-ls::std::io::SectionPairIdentifierValidator::SectionPairIdentifierValidator(ls::std::io::section_pair_identifier _identifier) : ls::std::core::Class("SectionPairIdentifierValidator"), identifier(::std::move(_identifier))
+using ls::std::core::Class;
+using ls::std::io::section_pair_identifier;
+using ls::std::io::SectionPairIdentifierValidator;
+using std::move;
+using std::regex;
+using std::regex_match;
+using std::string;
+
+SectionPairIdentifierValidator::SectionPairIdentifierValidator(section_pair_identifier _identifier) : Class("SectionPairIdentifierValidator"), identifier(::move(_identifier))
 {}
 
-ls::std::io::SectionPairIdentifierValidator::~SectionPairIdentifierValidator() noexcept = default;
+SectionPairIdentifierValidator::~SectionPairIdentifierValidator() noexcept = default;
 
-::std::string ls::std::io::SectionPairIdentifierValidator::getValidationRegex()
+string SectionPairIdentifierValidator::getValidationRegex()
 {
-  return ls::std::io::SectionPairIdentifierValidator::_getValidationRegex();
+  return SectionPairIdentifierValidator::_getValidationRegex();
 }
 
-bool ls::std::io::SectionPairIdentifierValidator::isValid()
+bool SectionPairIdentifierValidator::isValid()
 {
-  static ::std::regex identifierRegex("^" + ls::std::io::SectionPairIdentifierValidator::_getValidationRegex());
-  return ::std::regex_match(this->identifier, identifierRegex);
+  static regex identifierRegex("^" + SectionPairIdentifierValidator::_getValidationRegex());
+  return regex_match(this->identifier, identifierRegex);
 }
 
-::std::string ls::std::io::SectionPairIdentifierValidator::_getValidationRegex()
+string SectionPairIdentifierValidator::_getValidationRegex()
 {
   return R"([a-z]([a-z0-9-]){1,31})";
 }

source/ls-std/io/section-pair/validator/SectionPairRowListValueValidator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-19
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -12,30 +12,39 @@
 #include <ls-std/io/section-pair/validator/SectionPairValueValidator.hpp>
 #include <regex>
 
-ls::std::io::SectionPairRowListValueValidator::SectionPairRowListValueValidator(::std::string _listValueRow) : ls::std::core::Class("SectionPairRowListValueValidator"), listValueRow(::std::move(_listValueRow))
+using ls::std::core::Class;
+using ls::std::io::SectionPairIdentifierValidator;
+using ls::std::io::SectionPairRowListValueValidator;
+using ls::std::io::SectionPairValueValidator;
+using std::move;
+using std::regex;
+using std::regex_match;
+using std::string;
+
+SectionPairRowListValueValidator::SectionPairRowListValueValidator(string _listValueRow) : Class("SectionPairRowListValueValidator"), listValueRow(::move(_listValueRow))
 {}
 
-ls::std::io::SectionPairRowListValueValidator::~SectionPairRowListValueValidator() noexcept = default;
+SectionPairRowListValueValidator::~SectionPairRowListValueValidator() noexcept = default;
 
-::std::string ls::std::io::SectionPairRowListValueValidator::getValidationRegex()
+string SectionPairRowListValueValidator::getValidationRegex()
 {
-  return ls::std::io::SectionPairRowListValueValidator::_getValidationRegex();
+  return SectionPairRowListValueValidator::_getValidationRegex();
 }
 
-bool ls::std::io::SectionPairRowListValueValidator::isValid()
+bool SectionPairRowListValueValidator::isValid()
 {
-  ::std::string validationRegex = ls::std::io::SectionPairRowListValueValidator::_getValidationRegex();
-  static ::std::regex listValueRowRegex = ::std::regex{"^" + validationRegex};
+  string validationRegex = SectionPairRowListValueValidator::_getValidationRegex();
+  static regex listValueRowRegex = regex{"^" + validationRegex};
 
-  return ::std::regex_match(this->listValueRow, listValueRowRegex);
+  return regex_match(this->listValueRow, listValueRowRegex);
 }
 
-::std::string ls::std::io::SectionPairRowListValueValidator::_getValidationRegex()
+string SectionPairRowListValueValidator::_getValidationRegex()
 {
-  ::std::string identifierRegex = ls::std::io::SectionPairIdentifierValidator::getValidationRegex();
-  ::std::string valueRegex = ls::std::io::SectionPairValueValidator::getValidationRegex();
-  ::std::string lineBreak = R"(((\n{1})|(\r{1}\n{1})))";
-  ::std::string firstLine = R"(((()" + identifierRegex + R"():{1}))" + lineBreak + R"())";
+  string identifierRegex = SectionPairIdentifierValidator::getValidationRegex();
+  string valueRegex = SectionPairValueValidator::getValidationRegex();
+  string lineBreak = R"(((\n{1})|(\r{1}\n{1})))";
+  string firstLine = R"(((()" + identifierRegex + R"():{1}))" + lineBreak + R"())";
 
   return R"((()" + firstLine + R"(( {2})" + valueRegex + R"()" + lineBreak + R"()){1}(( {2})" + valueRegex + R"()" + lineBreak + R"()*)))";
 }

source/ls-std/io/section-pair/validator/SectionPairRowSingleValueValidator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-19
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -12,28 +12,37 @@
 #include <ls-std/io/section-pair/validator/SectionPairValueValidator.hpp>
 #include <regex>
 
-ls::std::io::SectionPairRowSingleValueValidator::SectionPairRowSingleValueValidator(::std::string _singleValueRow) : ls::std::core::Class("SectionPairRowSingleValueValidator"), singleValueRow(::std::move(_singleValueRow))
+using ls::std::core::Class;
+using ls::std::io::SectionPairIdentifierValidator;
+using ls::std::io::SectionPairRowSingleValueValidator;
+using ls::std::io::SectionPairValueValidator;
+using std::move;
+using std::regex;
+using std::regex_match;
+using std::string;
+
+SectionPairRowSingleValueValidator::SectionPairRowSingleValueValidator(string _singleValueRow) : Class("SectionPairRowSingleValueValidator"), singleValueRow(::move(_singleValueRow))
 {}
 
-ls::std::io::SectionPairRowSingleValueValidator::~SectionPairRowSingleValueValidator() noexcept = default;
+SectionPairRowSingleValueValidator::~SectionPairRowSingleValueValidator() noexcept = default;
 
-::std::string ls::std::io::SectionPairRowSingleValueValidator::getValidationRegex()
+string SectionPairRowSingleValueValidator::getValidationRegex()
 {
-  return ls::std::io::SectionPairRowSingleValueValidator::_getValidationRegex();
+  return SectionPairRowSingleValueValidator::_getValidationRegex();
 }
 
-bool ls::std::io::SectionPairRowSingleValueValidator::isValid()
+bool SectionPairRowSingleValueValidator::isValid()
 {
-  ::std::string validationRegex = ls::std::io::SectionPairRowSingleValueValidator::_getValidationRegex();
-  static ::std::regex singleValueRowRegex = ::std::regex{"^" + validationRegex};
+  string validationRegex = SectionPairRowSingleValueValidator::_getValidationRegex();
+  static regex singleValueRowRegex = regex{"^" + validationRegex};
 
-  return ::std::regex_match(this->singleValueRow, singleValueRowRegex);
+  return regex_match(this->singleValueRow, singleValueRowRegex);
 }
 
-::std::string ls::std::io::SectionPairRowSingleValueValidator::_getValidationRegex()
+string SectionPairRowSingleValueValidator::_getValidationRegex()
 {
-  ::std::string identifierRegex = ls::std::io::SectionPairIdentifierValidator::getValidationRegex();
-  ::std::string valueRegex = ls::std::io::SectionPairValueValidator::getValidationRegex();
+  string identifierRegex = SectionPairIdentifierValidator::getValidationRegex();
+  string valueRegex = SectionPairValueValidator::getValidationRegex();
 
   return R"(()" + identifierRegex + R"()={1}()" + valueRegex + R"(){1}($|\n{1}|\r{1}\n{1}))";
 }

source/ls-std/io/section-pair/validator/SectionPairRowValidator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -12,28 +12,36 @@
 #include <ls-std/io/section-pair/validator/SectionPairRowValidator.hpp>
 #include <regex>
 
-ls::std::io::SectionPairRowValidator::SectionPairRowValidator(::std::string _row) : ls::std::core::Class("SectionPairRowValidator"), row(::std::move(_row))
+using ls::std::core::Class;
+using ls::std::io::SectionPairRowListValueValidator;
+using ls::std::io::SectionPairRowValidator;
+using std::move;
+using std::regex;
+using std::regex_match;
+using std::string;
+
+SectionPairRowValidator::SectionPairRowValidator(string _row) : Class("SectionPairRowValidator"), row(::move(_row))
 {}
 
-ls::std::io::SectionPairRowValidator::~SectionPairRowValidator() noexcept = default;
+SectionPairRowValidator::~SectionPairRowValidator() noexcept = default;
 
-::std::string ls::std::io::SectionPairRowValidator::getValidationRegex()
+string SectionPairRowValidator::getValidationRegex()
 {
-  return ls::std::io::SectionPairRowValidator::_getValidationRegex();
+  return SectionPairRowValidator::_getValidationRegex();
 }
 
-bool ls::std::io::SectionPairRowValidator::isValid()
+bool SectionPairRowValidator::isValid()
 {
-  ::std::string validationRegex = ls::std::io::SectionPairRowValidator::_getValidationRegex();
-  static ::std::regex sectionPairRowRegex = ::std::regex{R"(^()" + validationRegex + R"())"};
+  string validationRegex = SectionPairRowValidator::_getValidationRegex();
+  static regex sectionPairRowRegex = regex{R"(^()" + validationRegex + R"())"};
 
-  return ::std::regex_match(this->row, sectionPairRowRegex);
+  return regex_match(this->row, sectionPairRowRegex);
 }
 
-::std::string ls::std::io::SectionPairRowValidator::_getValidationRegex()
+string SectionPairRowValidator::_getValidationRegex()
 {
-  ::std::string listValueRowRegex = ls::std::io::SectionPairRowListValueValidator::getValidationRegex();
-  ::std::string singleValueRowRegex = ls::std::io::SectionPairRowSingleValueValidator::getValidationRegex();
+  string listValueRowRegex = SectionPairRowListValueValidator::getValidationRegex();
+  string singleValueRowRegex = SectionPairRowSingleValueValidator::getValidationRegex();
 
   return R"(()" + singleValueRowRegex + R"()|()" + listValueRowRegex + R"())";
 }

source/ls-std/io/section-pair/validator/SectionPairSectionValidator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-20
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -13,32 +13,41 @@
 #include <regex>
 #include <string>
 
-ls::std::io::SectionPairSectionValidator::SectionPairSectionValidator(::std::string _section) : ls::std::core::Class("SectionPairSectionValidator"), section(::std::move(_section))
+using ls::std::core::Class;
+using ls::std::io::SectionPairIdentifierValidator;
+using ls::std::io::SectionPairRowValidator;
+using ls::std::io::SectionPairSectionValidator;
+using std::move;
+using std::regex;
+using std::regex_match;
+using std::string;
+
+SectionPairSectionValidator::SectionPairSectionValidator(string _section) : Class("SectionPairSectionValidator"), section(::move(_section))
 {}
 
-ls::std::io::SectionPairSectionValidator::~SectionPairSectionValidator() noexcept = default;
+SectionPairSectionValidator::~SectionPairSectionValidator() noexcept = default;
 
-::std::string ls::std::io::SectionPairSectionValidator::getValidationRegex()
+string SectionPairSectionValidator::getValidationRegex()
 {
-  return ls::std::io::SectionPairSectionValidator::_getValidationRegex();
+  return SectionPairSectionValidator::_getValidationRegex();
 }
 
-bool ls::std::io::SectionPairSectionValidator::isValid()
+bool SectionPairSectionValidator::isValid()
 {
-  ::std::string validationRegex = ls::std::io::SectionPairSectionValidator::_getValidationRegex();
-  static ::std::regex sectionRegex = ::std::regex{"^" + validationRegex};
+  string validationRegex = SectionPairSectionValidator::_getValidationRegex();
+  static regex sectionRegex = regex{"^" + validationRegex};
 
-  return ::std::regex_match(this->section, sectionRegex);
+  return regex_match(this->section, sectionRegex);
 }
 
-::std::string ls::std::io::SectionPairSectionValidator::_getValidationRegex()
+string SectionPairSectionValidator::_getValidationRegex()
 {
-  ::std::string newLine = R"(((\n)|(\r\n)))";
-  ::std::string identifier = ls::std::io::SectionPairIdentifierValidator::getValidationRegex();
-  ::std::string sectionHeader = newLine + R"(\[{1}()" + identifier + R"()\]{1}()" + newLine + R"({2}))";
-  ::std::string row = ls::std::io::SectionPairRowValidator::getValidationRegex();
-  ::std::string atLeastOneRow = R"((()" + row + R"(){1}))";
-  ::std::string optionalRows = R"((()" + row + R"()*))";
+  string newLine = R"(((\n)|(\r\n)))";
+  string identifier = SectionPairIdentifierValidator::getValidationRegex();
+  string sectionHeader = newLine + R"(\[{1}()" + identifier + R"()\]{1}()" + newLine + R"({2}))";
+  string row = SectionPairRowValidator::getValidationRegex();
+  string atLeastOneRow = R"((()" + row + R"(){1}))";
+  string optionalRows = R"((()" + row + R"()*))";
 
   return sectionHeader + atLeastOneRow + optionalRows;
 }

source/ls-std/io/section-pair/validator/SectionPairValueValidator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-09
-* Changed:         2023-02-22
+* Changed:         2023-02-23
 *
 * */
 
@@ -11,27 +11,35 @@
 #include <ls-std/io/section-pair/validator/SectionPairValueValidator.hpp>
 #include <regex>
 
-ls::std::io::SectionPairValueValidator::SectionPairValueValidator(ls::std::io::section_pair_row_value _value) : ls::std::core::Class("SectionPairValueValidator"), value(::std::move(_value))
+using ls::std::core::Class;
+using ls::std::io::section_pair_row_value;
+using ls::std::io::SectionPairValueValidator;
+using std::move;
+using std::regex;
+using std::regex_match;
+using std::string;
+
+SectionPairValueValidator::SectionPairValueValidator(section_pair_row_value _value) : Class("SectionPairValueValidator"), value(::move(_value))
 {}
 
-ls::std::io::SectionPairValueValidator::~SectionPairValueValidator() noexcept = default;
+SectionPairValueValidator::~SectionPairValueValidator() noexcept = default;
 
-::std::string ls::std::io::SectionPairValueValidator::getValidationRegex()
+string SectionPairValueValidator::getValidationRegex()
 {
-  return ls::std::io::SectionPairValueValidator::_getValidationRegex();
+  return SectionPairValueValidator::_getValidationRegex();
 }
 
-bool ls::std::io::SectionPairValueValidator::isValid()
+bool SectionPairValueValidator::isValid()
 {
-  ::std::string validationRegex = ls::std::io::SectionPairValueValidator::_getValidationRegex();
-  ::std::string concatenation = "(^" + validationRegex + ")|(^" + validationRegex + R"(\n{1})|(^)" + validationRegex + R"(\r{1}\n{1}))";
-  static ::std::regex valueRegex{concatenation};
+  string validationRegex = SectionPairValueValidator::_getValidationRegex();
+  string concatenation = "(^" + validationRegex + ")|(^" + validationRegex + R"(\n{1})|(^)" + validationRegex + R"(\r{1}\n{1}))";
+  static regex valueRegex{concatenation};
 
-  return ::std::regex_match(this->value, valueRegex);
+  return regex_match(this->value, valueRegex);
 }
 
-::std::string ls::std::io::SectionPairValueValidator::_getValidationRegex()
+string SectionPairValueValidator::_getValidationRegex()
 {
-  ::std::string value = R"([a-zA-Z0-9\-_#!?\[\]\{\}\(\)\$ۤ<>+:;., \*\/"]{1,32})";
+  string value = R"([a-zA-Z0-9\-_#!?\[\]\{\}\(\)\$ۤ<>+:;., \*\/"]{1,32})";
   return value;
 }

source/ls-std/io/xml/XmlAttribute.cpp

@@ -3,53 +3,58 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-23
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/evaluator/EmptyStringArgumentEvaluator.hpp>
 #include <ls-std/io/xml/XmlAttribute.hpp>
 
-ls::std::io::XmlAttribute::XmlAttribute(const ::std::string &_name) : ls::std::core::Class("XmlAttribute")
+using ls::std::core::Class;
+using ls::std::core::EmptyStringArgumentEvaluator;
+using ls::std::io::XmlAttribute;
+using std::string;
+
+XmlAttribute::XmlAttribute(const string &_name) : Class("XmlAttribute")
 {
   this->_assignName(_name);
 }
 
-ls::std::io::XmlAttribute::~XmlAttribute() noexcept = default;
+XmlAttribute::~XmlAttribute() noexcept = default;
 
-::std::string ls::std::io::XmlAttribute::getName()
+string XmlAttribute::getName()
 {
   return this->name;
 }
 
-::std::string ls::std::io::XmlAttribute::getValue()
+string XmlAttribute::getValue()
 {
   return this->value;
 }
 
-void ls::std::io::XmlAttribute::setName(const ::std::string &_name)
+void XmlAttribute::setName(const string &_name)
 {
   this->_assignName(_name);
 }
 
-void ls::std::io::XmlAttribute::setValue(const ::std::string &_value)
+void XmlAttribute::setValue(const string &_value)
 {
   this->_assignValue(_value);
 }
 
-::std::string ls::std::io::XmlAttribute::toXml()
+string XmlAttribute::toXml()
 {
   return this->name + "=\"" + this->value + "\"";
 }
 
-void ls::std::io::XmlAttribute::_assignName(const ::std::string &_name)
+void XmlAttribute::_assignName(const string &_name)
 {
-  ls::std::core::EmptyStringArgumentEvaluator{_name, "xml attribute name is empty!"}.evaluate();
+  EmptyStringArgumentEvaluator{_name, "xml attribute name is empty!"}.evaluate();
   this->name = _name;
 }
 
-void ls::std::io::XmlAttribute::_assignValue(const ::std::string &_value)
+void XmlAttribute::_assignValue(const string &_value)
 {
-  ls::std::core::EmptyStringArgumentEvaluator{_value, "xml attribute value is empty!"}.evaluate();
+  EmptyStringArgumentEvaluator{_value, "xml attribute value is empty!"}.evaluate();
   this->value = _value;
 }

source/ls-std/io/xml/XmlDeclaration.cpp

@@ -3,63 +3,67 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-29
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/io/xml/XmlDeclaration.hpp>
 
-ls::std::io::XmlDeclaration::XmlDeclaration(const ::std::string &_version) : ls::std::core::Class("XmlDeclaration")
+using ls::std::io::XmlAttribute;
+using ls::std::io::XmlDeclaration;
+using std::string;
+
+XmlDeclaration::XmlDeclaration(const string &_version) : ls::std::core::Class("XmlDeclaration")
 {
   this->version.setValue(_version);
 }
 
-ls::std::io::XmlDeclaration::~XmlDeclaration() noexcept = default;
+XmlDeclaration::~XmlDeclaration() noexcept = default;
 
-::std::string ls::std::io::XmlDeclaration::getEncoding()
+string XmlDeclaration::getEncoding()
 {
   return this->encoding.getValue();
 }
 
-::std::string ls::std::io::XmlDeclaration::getStandalone()
+string XmlDeclaration::getStandalone()
 {
   return this->standalone.getValue();
 }
 
-::std::string ls::std::io::XmlDeclaration::getVersion()
+string XmlDeclaration::getVersion()
 {
   return this->version.getValue();
 }
 
-void ls::std::io::XmlDeclaration::setEncoding(const ::std::string &_encoding)
+void XmlDeclaration::setEncoding(const string &_encoding)
 {
   this->encoding.setValue(_encoding);
 }
 
-void ls::std::io::XmlDeclaration::setStandalone(const ::std::string &_standalone)
+void XmlDeclaration::setStandalone(const string &_standalone)
 {
   this->standalone.setValue(_standalone);
 }
 
-void ls::std::io::XmlDeclaration::setVersion(const ::std::string &_version)
+void XmlDeclaration::setVersion(const string &_version)
 {
   this->version.setValue(_version);
 }
 
-::std::string ls::std::io::XmlDeclaration::toXml()
+string XmlDeclaration::toXml()
 {
-  ::std::string declaration = "<?xml";
+  string declaration = "<?xml";
 
-  declaration += ls::std::io::XmlDeclaration::_toXmlAttribute(this->version);
-  declaration += ls::std::io::XmlDeclaration::_toXmlAttribute(this->encoding);
-  declaration += ls::std::io::XmlDeclaration::_toXmlAttribute(this->standalone);
+  declaration += XmlDeclaration::_toXmlAttribute(this->version);
+  declaration += XmlDeclaration::_toXmlAttribute(this->encoding);
+  declaration += XmlDeclaration::_toXmlAttribute(this->standalone);
 
   return declaration + " ?>";
 }
 
-::std::string ls::std::io::XmlDeclaration::_toXmlAttribute(ls::std::io::XmlAttribute _attribute)
+string XmlDeclaration::_toXmlAttribute(XmlAttribute _attribute)
 {
-  ::std::string xmlString{};
+  string xmlString{};
 
   if (!_attribute.getValue().empty())
   {

source/ls-std/io/xml/XmlDocument.cpp

@@ -3,41 +3,49 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-30
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp>
 #include <ls-std/io/xml/XmlDocument.hpp>
 
-ls::std::io::XmlDocument::XmlDocument() : ls::std::core::Class("XmlDocument")
+using ls::std::core::Class;
+using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::io::XmlDeclaration;
+using ls::std::io::XmlDocument;
+using ls::std::io::XmlNode;
+using std::shared_ptr;
+using std::string;
+
+XmlDocument::XmlDocument() : Class("XmlDocument")
 {}
 
-ls::std::io::XmlDocument::~XmlDocument() noexcept = default;
+XmlDocument::~XmlDocument() noexcept = default;
 
-::std::shared_ptr<ls::std::io::XmlDeclaration> ls::std::io::XmlDocument::getDeclaration()
+shared_ptr<XmlDeclaration> XmlDocument::getDeclaration()
 {
   return this->declaration;
 }
 
-::std::shared_ptr<ls::std::io::XmlNode> ls::std::io::XmlDocument::getRootElement()
+shared_ptr<XmlNode> XmlDocument::getRootElement()
 {
   return this->rootElement;
 }
 
-void ls::std::io::XmlDocument::setDeclaration(const ::std::shared_ptr<ls::std::io::XmlDeclaration> &_declaration)
+void XmlDocument::setDeclaration(const shared_ptr<XmlDeclaration> &_declaration)
 {
   this->_assignDeclaration(_declaration);
 }
 
-void ls::std::io::XmlDocument::setRootElement(const ::std::shared_ptr<ls::std::io::XmlNode> &_rootElement)
+void XmlDocument::setRootElement(const shared_ptr<XmlNode> &_rootElement)
 {
   this->_assignRootElement(_rootElement);
 }
 
-::std::string ls::std::io::XmlDocument::toXml()
+string XmlDocument::toXml()
 {
-  ::std::string xmlString{};
+  string xmlString{};
 
   if (this->declaration != nullptr)
   {
@@ -52,14 +60,14 @@ void ls::std::io::XmlDocument::setRootElement(const ::std::shared_ptr<ls::std::i
   return xmlString + this->rootElement->toXml();
 }
 
-void ls::std::io::XmlDocument::_assignDeclaration(const ::std::shared_ptr<ls::std::io::XmlDeclaration> &_declaration)
+void XmlDocument::_assignDeclaration(const shared_ptr<XmlDeclaration> &_declaration)
 {
-  ls::std::core::NullPointerArgumentEvaluator{_declaration, "xml declaration reference is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_declaration, "xml declaration reference is null!"}.evaluate();
   this->declaration = _declaration;
 }
 
-void ls::std::io::XmlDocument::_assignRootElement(const ::std::shared_ptr<ls::std::io::XmlNode> &_rootElement)
+void XmlDocument::_assignRootElement(const shared_ptr<XmlNode> &_rootElement)
 {
-  ls::std::core::NullPointerArgumentEvaluator{_rootElement, "xml root node reference is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_rootElement, "xml root node reference is null!"}.evaluate();
   this->rootElement = _rootElement;
 }

source/ls-std/io/xml/XmlNode.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-24
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
@@ -12,17 +12,28 @@
 #include <ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp>
 #include <ls-std/io/xml/XmlNode.hpp>
 
-ls::std::io::XmlNode::XmlNode(::std::string _name) : ls::std::core::Class("XmlNode"), name(::std::move(_name))
+using ls::std::core::Class;
+using ls::std::core::EmptyStringArgumentEvaluator;
+using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::io::XmlAttribute;
+using ls::std::io::XmlNode;
+using std::find;
+using std::list;
+using std::move;
+using std::shared_ptr;
+using std::string;
+
+XmlNode::XmlNode(string _name) : Class("XmlNode"), name(::move(_name))
 {}
 
-ls::std::io::XmlNode::~XmlNode() noexcept = default;
+XmlNode::~XmlNode() noexcept = default;
 
-bool ls::std::io::XmlNode::addAttributeAfter(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute, const ::std::string &_name)
+bool XmlNode::addAttributeAfter(const shared_ptr<XmlAttribute> &_attribute, const string &_name)
 {
   bool added{};
   auto iterator = this->attributes.begin();
-  ls::std::core::NullPointerArgumentEvaluator{_attribute, "passed attribute reference for add attempt is null!"}.evaluate();
-  ls::std::core::EmptyStringArgumentEvaluator{_name, "xml node name is empty!"}.evaluate();
+  NullPointerArgumentEvaluator{_attribute, "passed attribute reference for add attempt is null!"}.evaluate();
+  EmptyStringArgumentEvaluator{_name, "xml node name is empty!"}.evaluate();
 
   if (!this->_hasAttribute(_attribute->getName()))
   {
@@ -43,12 +54,12 @@ bool ls::std::io::XmlNode::addAttributeAfter(const ::std::shared_ptr<ls::std::io
   return added;
 }
 
-bool ls::std::io::XmlNode::addAttributeBefore(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute, const ::std::string &_name)
+bool XmlNode::addAttributeBefore(const shared_ptr<XmlAttribute> &_attribute, const string &_name)
 {
   bool added{};
   auto iterator = this->attributes.begin();
-  ls::std::core::NullPointerArgumentEvaluator{_attribute, "passed attribute reference for add attempt is null!"}.evaluate();
-  ls::std::core::EmptyStringArgumentEvaluator{_name, "xml node name is empty!"}.evaluate();
+  NullPointerArgumentEvaluator{_attribute, "passed attribute reference for add attempt is null!"}.evaluate();
+  EmptyStringArgumentEvaluator{_name, "xml node name is empty!"}.evaluate();
 
   if (!this->_hasAttribute(_attribute->getName()))
   {
@@ -68,10 +79,10 @@ bool ls::std::io::XmlNode::addAttributeBefore(const ::std::shared_ptr<ls::std::i
   return added;
 }
 
-bool ls::std::io::XmlNode::addAttributeToBeginning(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute)
+bool XmlNode::addAttributeToBeginning(const shared_ptr<XmlAttribute> &_attribute)
 {
   bool added{};
-  ls::std::core::NullPointerArgumentEvaluator{_attribute, "passed attribute reference for add attempt is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_attribute, "passed attribute reference for add attempt is null!"}.evaluate();
   ;
 
   if (!_hasAttribute(_attribute->getName()))
@@ -83,10 +94,10 @@ bool ls::std::io::XmlNode::addAttributeToBeginning(const ::std::shared_ptr<ls::s
   return added;
 }
 
-bool ls::std::io::XmlNode::addAttributeToEnd(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute)
+bool XmlNode::addAttributeToEnd(const shared_ptr<XmlAttribute> &_attribute)
 {
   bool added{};
-  ls::std::core::NullPointerArgumentEvaluator{_attribute, "passed attribute reference for add attempt is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_attribute, "passed attribute reference for add attempt is null!"}.evaluate();
 
   if (!_hasAttribute(_attribute->getName()))
   {
@@ -97,12 +108,12 @@ bool ls::std::io::XmlNode::addAttributeToEnd(const ::std::shared_ptr<ls::std::io
   return added;
 }
 
-bool ls::std::io::XmlNode::addChildAfter(const ::std::shared_ptr<ls::std::io::XmlNode> &_child, const ::std::shared_ptr<ls::std::io::XmlNode> &_search)
+bool XmlNode::addChildAfter(const shared_ptr<XmlNode> &_child, const shared_ptr<XmlNode> &_search)
 {
   bool added{};
   auto iterator = this->children.begin();
-  ls::std::core::NullPointerArgumentEvaluator{_child, "passed child node reference for add attempt is null!"}.evaluate();
-  ls::std::core::NullPointerArgumentEvaluator{_search, "passed search node reference for add attempt is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_child, "passed child node reference for add attempt is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_search, "passed search node reference for add attempt is null!"}.evaluate();
 
   if (!this->_hasChild(_child))
   {
@@ -123,12 +134,12 @@ bool ls::std::io::XmlNode::addChildAfter(const ::std::shared_ptr<ls::std::io::Xm
   return added;
 }
 
-bool ls::std::io::XmlNode::addChildBefore(const ::std::shared_ptr<ls::std::io::XmlNode> &_child, const ::std::shared_ptr<ls::std::io::XmlNode> &_search)
+bool XmlNode::addChildBefore(const shared_ptr<XmlNode> &_child, const shared_ptr<XmlNode> &_search)
 {
   bool added{};
   auto iterator = this->children.begin();
-  ls::std::core::NullPointerArgumentEvaluator{_child, "passed child node reference for add attempt is null!"}.evaluate();
-  ls::std::core::NullPointerArgumentEvaluator{_search, "passed search node reference for add attempt is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_child, "passed child node reference for add attempt is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_search, "passed search node reference for add attempt is null!"}.evaluate();
 
   if (!this->_hasChild(_child))
   {
@@ -148,10 +159,10 @@ bool ls::std::io::XmlNode::addChildBefore(const ::std::shared_ptr<ls::std::io::X
   return added;
 }
 
-bool ls::std::io::XmlNode::addChildToBeginning(const ::std::shared_ptr<ls::std::io::XmlNode> &_child)
+bool XmlNode::addChildToBeginning(const shared_ptr<XmlNode> &_child)
 {
   bool added{};
-  ls::std::core::NullPointerArgumentEvaluator{_child, "passed child node reference for add attempt is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_child, "passed child node reference for add attempt is null!"}.evaluate();
 
   if (!this->_hasChild(_child))
   {
@@ -162,10 +173,10 @@ bool ls::std::io::XmlNode::addChildToBeginning(const ::std::shared_ptr<ls::std::
   return added;
 }
 
-bool ls::std::io::XmlNode::addChildToEnd(const ::std::shared_ptr<ls::std::io::XmlNode> &_child)
+bool XmlNode::addChildToEnd(const shared_ptr<XmlNode> &_child)
 {
   bool added{};
-  ls::std::core::NullPointerArgumentEvaluator{_child, "passed child node reference for add attempt is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_child, "passed child node reference for add attempt is null!"}.evaluate();
 
   if (!this->_hasChild(_child))
   {
@@ -176,24 +187,24 @@ bool ls::std::io::XmlNode::addChildToEnd(const ::std::shared_ptr<ls::std::io::Xm
   return added;
 }
 
-void ls::std::io::XmlNode::clearValue()
+void XmlNode::clearValue()
 {
   this->value.clear();
 }
 
-std::list<std::shared_ptr<ls::std::io::XmlAttribute>> ls::std::io::XmlNode::getAttributes()
+list<shared_ptr<XmlAttribute>> XmlNode::getAttributes()
 {
   return this->attributes;
 }
 
-std::list<std::shared_ptr<ls::std::io::XmlNode>> ls::std::io::XmlNode::getChildren()
+list<shared_ptr<XmlNode>> XmlNode::getChildren()
 {
   return this->children;
 }
 
-std::list<std::shared_ptr<ls::std::io::XmlNode>> ls::std::io::XmlNode::getChildren(const ::std::string &_name)
+list<shared_ptr<XmlNode>> XmlNode::getChildren(const string &_name)
 {
-  ::std::list<::std::shared_ptr<ls::std::io::XmlNode>> childrenWithName{};
+  list<shared_ptr<XmlNode>> childrenWithName{};
 
   for (const auto &child : this->children)
   {
@@ -206,32 +217,32 @@ std::list<std::shared_ptr<ls::std::io::XmlNode>> ls::std::io::XmlNode::getChildr
   return childrenWithName;
 }
 
-std::string ls::std::io::XmlNode::getName()
+string XmlNode::getName()
 {
   return this->name;
 }
 
-std::string ls::std::io::XmlNode::getValue()
+string XmlNode::getValue()
 {
   return this->value;
 }
 
-bool ls::std::io::XmlNode::hasAttribute(const ::std::string &_name)
+bool XmlNode::hasAttribute(const string &_name)
 {
   return this->_hasAttribute(_name);
 }
 
-bool ls::std::io::XmlNode::hasChild(const ::std::string &_name)
+bool XmlNode::hasChild(const string &_name)
 {
   return this->_hasChild(_name);
 }
 
-bool ls::std::io::XmlNode::hasChild(const ::std::shared_ptr<ls::std::io::XmlNode> &_child)
+bool XmlNode::hasChild(const shared_ptr<XmlNode> &_child)
 {
   return this->_hasChild(_child);
 }
 
-bool ls::std::io::XmlNode::removeFirstAttribute()
+bool XmlNode::removeFirstAttribute()
 {
   bool isValidOperation = !this->attributes.empty();
 
@@ -243,7 +254,7 @@ bool ls::std::io::XmlNode::removeFirstAttribute()
   return isValidOperation;
 }
 
-bool ls::std::io::XmlNode::removeLastAttribute()
+bool XmlNode::removeLastAttribute()
 {
   bool isValidOperation = !this->attributes.empty();
 
@@ -255,7 +266,7 @@ bool ls::std::io::XmlNode::removeLastAttribute()
   return isValidOperation;
 }
 
-bool ls::std::io::XmlNode::removeFirstChild()
+bool XmlNode::removeFirstChild()
 {
   bool isValidOperation = !this->children.empty();
 
@@ -267,7 +278,7 @@ bool ls::std::io::XmlNode::removeFirstChild()
   return isValidOperation;
 }
 
-bool ls::std::io::XmlNode::removeLastChild()
+bool XmlNode::removeLastChild()
 {
   bool isValidOperation = !this->children.empty();
 
@@ -279,52 +290,52 @@ bool ls::std::io::XmlNode::removeLastChild()
   return isValidOperation;
 }
 
-void ls::std::io::XmlNode::setName(const ::std::string &_name)
+void XmlNode::setName(const string &_name)
 {
   this->_assignName(_name);
 }
 
-void ls::std::io::XmlNode::setValue(const ::std::string &_value)
+void XmlNode::setValue(const string &_value)
 {
   this->_assignValue(_value);
 }
 
-std::string ls::std::io::XmlNode::toXml()
+string XmlNode::toXml()
 {
   return this->_toXml_(0);
 }
 
-std::string ls::std::io::XmlNode::_toXml_(uint8_t _tabSize)
+string XmlNode::_toXml_(uint8_t _tabSize)
 {
-  ::std::string xmlStream{};
+  string xmlStream{};
 
-  xmlStream += ls::std::io::XmlNode::_getTab(_tabSize);
+  xmlStream += XmlNode::_getTab(_tabSize);
   xmlStream += this->_toXmlOpenTag();
   xmlStream += this->_toXmlAttributes();
   xmlStream += this->_toXmlOpenTagClose();
   xmlStream += this->_toXmlValue();
   xmlStream += this->_toXmlChildren(_tabSize + TAB_SIZE);
-  xmlStream += this->value.empty() ? ls::std::io::XmlNode::_getTab(_tabSize) : "";
+  xmlStream += this->value.empty() ? XmlNode::_getTab(_tabSize) : "";
   xmlStream += this->_toXmlCloseTag() + "\n";
 
   return xmlStream;
 }
 
-void ls::std::io::XmlNode::_assignName(const ::std::string &_name)
+void XmlNode::_assignName(const string &_name)
 {
-  ls::std::core::EmptyStringArgumentEvaluator{_name, "xml node name is empty!"}.evaluate();
+  EmptyStringArgumentEvaluator{_name, "xml node name is empty!"}.evaluate();
   this->name = _name;
 }
 
-void ls::std::io::XmlNode::_assignValue(const ::std::string &_value)
+void XmlNode::_assignValue(const string &_value)
 {
-  ls::std::core::EmptyStringArgumentEvaluator{_value, "xml node value is empty!"}.evaluate();
+  EmptyStringArgumentEvaluator{_value, "xml node value is empty!"}.evaluate();
   this->value = _value;
 }
 
-std::string ls::std::io::XmlNode::_getTab(uint8_t _tabSize)
+string XmlNode::_getTab(uint8_t _tabSize)
 {
-  ::std::string tab{};
+  string tab{};
 
   for (uint8_t index = 0; index < _tabSize; index++)
   {
@@ -334,10 +345,10 @@ std::string ls::std::io::XmlNode::_getTab(uint8_t _tabSize)
   return tab;
 }
 
-bool ls::std::io::XmlNode::_hasAttribute(const ::std::string &_name)
+bool XmlNode::_hasAttribute(const string &_name)
 {
   bool exists{};
-  ls::std::core::EmptyStringArgumentEvaluator{_name, "xml attribute name is empty!"}.evaluate();
+  EmptyStringArgumentEvaluator{_name, "xml attribute name is empty!"}.evaluate();
 
   for (const auto &attribute : this->attributes)
   {
@@ -351,16 +362,16 @@ bool ls::std::io::XmlNode::_hasAttribute(const ::std::string &_name)
   return exists;
 }
 
-bool ls::std::io::XmlNode::_hasChild(const ::std::shared_ptr<ls::std::io::XmlNode> &_child)
+bool XmlNode::_hasChild(const shared_ptr<XmlNode> &_child)
 {
-  ls::std::core::NullPointerArgumentEvaluator{_child, "passed child node reference for check attempt is null!"}.evaluate();
-  return ::std::find(this->children.begin(), this->children.end(), _child) != this->children.end();
+  NullPointerArgumentEvaluator{_child, "passed child node reference for check attempt is null!"}.evaluate();
+  return find(this->children.begin(), this->children.end(), _child) != this->children.end();
 }
 
-bool ls::std::io::XmlNode::_hasChild(const ::std::string &_name)
+bool XmlNode::_hasChild(const string &_name)
 {
   bool exists{};
-  ls::std::core::EmptyStringArgumentEvaluator{_name, "xml child node name is empty!"}.evaluate();
+  EmptyStringArgumentEvaluator{_name, "xml child node name is empty!"}.evaluate();
 
   for (const auto &attribute : this->children)
   {
@@ -374,9 +385,9 @@ bool ls::std::io::XmlNode::_hasChild(const ::std::string &_name)
   return exists;
 }
 
-std::string ls::std::io::XmlNode::_toXmlAttributes()
+string XmlNode::_toXmlAttributes()
 {
-  ::std::string stream{};
+  string stream{};
 
   for (const auto &_attribute : this->attributes)
   {
@@ -386,9 +397,9 @@ std::string ls::std::io::XmlNode::_toXmlAttributes()
   return stream;
 }
 
-std::string ls::std::io::XmlNode::_toXmlChildren(uint8_t _tabSize)
+string XmlNode::_toXmlChildren(uint8_t _tabSize)
 {
-  ::std::string stream{};
+  string stream{};
 
   if (this->value.empty())
   {
@@ -401,9 +412,9 @@ std::string ls::std::io::XmlNode::_toXmlChildren(uint8_t _tabSize)
   return stream;
 }
 
-std::string ls::std::io::XmlNode::_toXmlCloseTag()
+string XmlNode::_toXmlCloseTag()
 {
-  ::std::string stream{};
+  string stream{};
 
   if (!this->children.empty() || !this->value.empty())
   {
@@ -413,14 +424,14 @@ std::string ls::std::io::XmlNode::_toXmlCloseTag()
   return stream;
 }
 
-std::string ls::std::io::XmlNode::_toXmlOpenTag()
+string XmlNode::_toXmlOpenTag()
 {
   return "<" + this->name;
 }
 
-std::string ls::std::io::XmlNode::_toXmlOpenTagClose()
+string XmlNode::_toXmlOpenTagClose()
 {
-  ::std::string stream{};
+  string stream{};
 
   if (this->children.empty() && this->value.empty())
   {
@@ -434,7 +445,7 @@ std::string ls::std::io::XmlNode::_toXmlOpenTagClose()
   return stream;
 }
 
-std::string ls::std::io::XmlNode::_toXmlValue()
+string XmlNode::_toXmlValue()
 {
   return this->value.empty() ? "\n" : this->value;
 }

source/ls-std/io/xml/XmlParseParameter.cpp

@@ -3,39 +3,44 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-05
-* Changed:         2023-02-08
+* Changed:         2023-02-23
 *
 * */
 
 #include <ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp>
 #include <ls-std/io/xml/XmlParseParameter.hpp>
 
-ls::std::io::XmlParseParameter::XmlParseParameter() = default;
+using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::io::XmlNode;
+using ls::std::io::XmlParseParameter;
+using std::shared_ptr;
 
-ls::std::io::XmlParseParameter::~XmlParseParameter() = default;
+XmlParseParameter::XmlParseParameter() = default;
 
-uint8_t ls::std::io::XmlParseParameter::getLevel() const
+XmlParseParameter::~XmlParseParameter() = default;
+
+uint8_t XmlParseParameter::getLevel() const
 {
   return this->level;
 }
 
-::std::shared_ptr<ls::std::io::XmlNode> ls::std::io::XmlParseParameter::getNode()
+shared_ptr<XmlNode> XmlParseParameter::getNode()
 {
   return this->node;
 }
 
-void ls::std::io::XmlParseParameter::setLevel(const uint8_t &_level)
+void XmlParseParameter::setLevel(const uint8_t &_level)
 {
   this->level = _level;
 }
 
-void ls::std::io::XmlParseParameter::setNode(const ::std::shared_ptr<ls::std::io::XmlNode> &_node)
+void XmlParseParameter::setNode(const shared_ptr<XmlNode> &_node)
 {
   this->_setNode(_node);
 }
 
-void ls::std::io::XmlParseParameter::_setNode(const ::std::shared_ptr<ls::std::io::XmlNode> &_node)
+void XmlParseParameter::_setNode(const shared_ptr<XmlNode> &_node)
 {
-  ls::std::core::NullPointerArgumentEvaluator{_node, "passed node reference is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_node, "passed node reference is null!"}.evaluate();
   this->node = _node;
 }

source/ls-std/io/xml/XmlParser.cpp

@@ -3,49 +3,66 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
 #include <ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp>
 #include <ls-std/io/xml/XmlParser.hpp>
 
-ls::std::io::XmlParser::XmlParser(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document) : ls::std::core::Class("XmlParser")
+using ls::std::core::Class;
+using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::core::type::byte_field;
+using ls::std::io::XmlAttribute;
+using ls::std::io::XmlDeclaration;
+using ls::std::io::XmlDocument;
+using ls::std::io::XmlNode;
+using ls::std::io::XmlParseMode;
+using ls::std::io::XmlParseParameter;
+using ls::std::io::XmlParser;
+using std::list;
+using std::make_shared;
+using std::move;
+using std::pair;
+using std::shared_ptr;
+using std::string;
+
+XmlParser::XmlParser(const shared_ptr<XmlDocument> &_document) : Class("XmlParser")
 {
   this->_assignDocument(_document);
   this->_reset();
 }
 
-ls::std::io::XmlParser::~XmlParser() noexcept = default;
+XmlParser::~XmlParser() noexcept = default;
 
-::std::shared_ptr<ls::std::io::XmlDocument> ls::std::io::XmlParser::getDocument()
+shared_ptr<XmlDocument> XmlParser::getDocument()
 {
   return this->document;
 }
 
-void ls::std::io::XmlParser::parse(const ls::std::core::type::byte_field &_data)
+void XmlParser::parse(const byte_field &_data)
 {
   this->_parse(_data);
   this->_mergeNodes();
   this->_reset();
 }
 
-void ls::std::io::XmlParser::setDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document)
+void XmlParser::setDocument(const shared_ptr<XmlDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-::std::pair<::std::string, ::std::string> ls::std::io::XmlParser::_readAttribute_(const ls::std::core::type::byte_field &_data)
+pair<string, string> XmlParser::_readAttribute_(const byte_field &_data)
 {
-  return ls::std::io::XmlParser::_parseAttribute(_data);
+  return XmlParser::_parseAttribute(_data);
 }
 
-::std::list<::std::pair<::std::string, ::std::string>> ls::std::io::XmlParser::_readAttributes_(ls::std::core::type::byte_field _data)
+list<pair<string, string>> XmlParser::_readAttributes_(byte_field _data)
 {
-  return ls::std::io::XmlParser::_parseAttributes(::std::move(_data));
+  return XmlParser::_parseAttributes(::move(_data));
 }
 
-void ls::std::io::XmlParser::_analyze(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
+void XmlParser::_analyze(const byte_field &_data, string::size_type _index)
 {
   this->_isDeclaration(_data, _index);
   this->_isClosingTag(_data, _index);
@@ -53,35 +70,35 @@ void ls::std::io::XmlParser::_analyze(const ls::std::core::type::byte_field &_da
   this->_isValue(_data, _index);
 }
 
-void ls::std::io::XmlParser::_assignDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document)
+void XmlParser::_assignDocument(const shared_ptr<XmlDocument> &_document)
 {
-  ls::std::core::NullPointerArgumentEvaluator{_document, "passed document reference is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_document, "passed document reference is null!"}.evaluate();
   this->document = _document;
 }
 
-bool ls::std::io::XmlParser::_contains(const ::std::string &_text, const ::std::string &_searchText)
+bool XmlParser::_contains(const string &_text, const string &_searchText)
 {
-  return _text.find(_searchText) != ::std::string::npos;
+  return _text.find(_searchText) != string::npos;
 }
 
-::std::shared_ptr<ls::std::io::XmlDeclaration> ls::std::io::XmlParser::_createDeclaration(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes)
+shared_ptr<XmlDeclaration> XmlParser::_createDeclaration(const list<pair<string, string>> &_attributes)
 {
-  ::std::shared_ptr<ls::std::io::XmlDeclaration> declaration = ::std::make_shared<ls::std::io::XmlDeclaration>("1.0");
-  ::std::pair<::std::string, ::std::string> attribute = ls::std::io::XmlParser::_findAttribute(_attributes, "version");
+  shared_ptr<XmlDeclaration> declaration = make_shared<XmlDeclaration>("1.0");
+  pair<string, string> attribute = XmlParser::_findAttribute(_attributes, "version");
 
   if (!attribute.first.empty())
   {
     declaration->setVersion(attribute.second);
   }
 
-  attribute = ls::std::io::XmlParser::_findAttribute(_attributes, "encoding");
+  attribute = XmlParser::_findAttribute(_attributes, "encoding");
 
   if (!attribute.first.empty())
   {
     declaration->setEncoding(attribute.second);
   }
 
-  attribute = ls::std::io::XmlParser::_findAttribute(_attributes, "standalone");
+  attribute = XmlParser::_findAttribute(_attributes, "standalone");
 
   if (!attribute.first.empty())
   {
@@ -91,14 +108,14 @@ bool ls::std::io::XmlParser::_contains(const ::std::string &_text, const ::std::
   return declaration;
 }
 
-::std::shared_ptr<ls::std::io::XmlNode> ls::std::io::XmlParser::_createNode(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name)
+shared_ptr<XmlNode> XmlParser::_createNode(const list<pair<string, string>> &_attributes, const string &_name)
 {
-  ::std::shared_ptr<ls::std::io::XmlNode> node = ::std::make_shared<ls::std::io::XmlNode>(_name);
-  ::std::shared_ptr<ls::std::io::XmlAttribute> attribute{};
+  shared_ptr<XmlNode> node = make_shared<XmlNode>(_name);
+  shared_ptr<XmlAttribute> attribute{};
 
   for (const auto &parsedAttribute : _attributes)
   {
-    attribute = ::std::make_shared<ls::std::io::XmlAttribute>(parsedAttribute.first);
+    attribute = make_shared<XmlAttribute>(parsedAttribute.first);
     attribute->setValue(parsedAttribute.second);
     node->addAttributeToEnd(attribute);
   }
@@ -106,14 +123,14 @@ bool ls::std::io::XmlParser::_contains(const ::std::string &_text, const ::std::
   return node;
 }
 
-bool ls::std::io::XmlParser::_endsWith(const ::std::string &_text, const ::std::string &_ending)
+bool XmlParser::_endsWith(const string &_text, const string &_ending)
 {
   return _text.rfind(_ending) == (_text.size() - _ending.size());
 }
 
-::std::pair<::std::string, ::std::string> ls::std::io::XmlParser::_findAttribute(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name)
+pair<string, string> XmlParser::_findAttribute(const list<pair<string, string>> &_attributes, const string &_name)
 {
-  ::std::pair<::std::string, ::std::string> attribute{};
+  pair<string, string> attribute{};
 
   for (const auto &currentAttribute : _attributes)
   {
@@ -127,10 +144,10 @@ bool ls::std::io::XmlParser::_endsWith(const ::std::string &_text, const ::std::
   return attribute;
 }
 
-size_t ls::std::io::XmlParser::_findAttributeEndPosition(const ls::std::core::type::byte_field &_data)
+size_t XmlParser::_findAttributeEndPosition(const byte_field &_data)
 {
-  ::std::string::size_type position = ::std::string::npos;
-  ::std::string::size_type counter{};
+  string::size_type position = string::npos;
+  string::size_type counter{};
 
   for (char letter : _data)
   {
@@ -150,12 +167,12 @@ size_t ls::std::io::XmlParser::_findAttributeEndPosition(const ls::std::core::ty
   return position;
 }
 
-ls::std::core::type::byte_field ls::std::io::XmlParser::_getNextTagString(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
+byte_field XmlParser::_getNextTagString(const byte_field &_data, string::size_type _index)
 {
-  ls::std::core::type::byte_field tag{};
+  byte_field tag{};
   size_t closingCharacterPosition = _index + _data.substr(_index).find('>');
 
-  if (closingCharacterPosition != ::std::string::npos)
+  if (closingCharacterPosition != string::npos)
   {
     tag = _data.substr(_index, (closingCharacterPosition - _index) + 1);
   }
@@ -163,50 +180,50 @@ ls::std::core::type::byte_field ls::std::io::XmlParser::_getNextTagString(const
   return tag;
 }
 
-void ls::std::io::XmlParser::_isClosingTag(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
+void XmlParser::_isClosingTag(const byte_field &_data, string::size_type _index)
 {
-  if (this->mode == XML_PARSE_MODE_ANALYZE && _data.substr(_index, 2) == "</")
+  if (this->mode == XmlParseMode::XML_PARSE_MODE_ANALYZE && _data.substr(_index, 2) == "</")
   {
-    this->mode = XML_PARSE_MODE_CLOSING_TAG;
+    this->mode = XmlParseMode::XML_PARSE_MODE_CLOSING_TAG;
   }
 }
 
-void ls::std::io::XmlParser::_isDeclaration(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
+void XmlParser::_isDeclaration(const byte_field &_data, string::size_type _index)
 {
   if (_data.substr(_index, 5) == "<?xml")
   {
-    this->mode = XML_PARSE_MODE_DECLARATION;
+    this->mode = XmlParseMode::XML_PARSE_MODE_DECLARATION;
   }
 }
 
-void ls::std::io::XmlParser::_isOpeningTag(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
+void XmlParser::_isOpeningTag(const byte_field &_data, string::size_type _index)
 {
-  if (this->mode == XML_PARSE_MODE_ANALYZE && _data.substr(_index, 1) == "<")
+  if (this->mode == XmlParseMode::XML_PARSE_MODE_ANALYZE && _data.substr(_index, 1) == "<")
   {
-    this->mode = XML_PARSE_MODE_OPENING_TAG;
+    this->mode = XmlParseMode::XML_PARSE_MODE_OPENING_TAG;
   }
 }
 
-void ls::std::io::XmlParser::_isValue(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
+void XmlParser::_isValue(const byte_field &_data, string::size_type _index)
 {
-  if (this->mode == XML_PARSE_MODE_ANALYZE)
+  if (this->mode == XmlParseMode::XML_PARSE_MODE_ANALYZE)
   {
-    ::std::string::size_type end = _data.substr(_index).find('<');
-    bool isValue = _data[_index - 1] == '>' && end != ::std::string::npos && end > 0;
+    string::size_type end = _data.substr(_index).find('<');
+    bool isValue = _data[_index - 1] == '>' && end != string::npos && end > 0;
 
     if (isValue)
     {
-      ::std::string value{_data.substr(_index, end)};
+      string value{_data.substr(_index, end)};
 
-      if (!ls::std::io::XmlParser::_contains(value, "\n") && !ls::std::io::XmlParser::_contains(value, "\r\n"))
+      if (!XmlParser::_contains(value, "\n") && !XmlParser::_contains(value, "\r\n"))
       {
-        this->mode = XML_PARSE_MODE_VALUE;
+        this->mode = XmlParseMode::XML_PARSE_MODE_VALUE;
       }
     }
   }
 }
 
-void ls::std::io::XmlParser::_mergeNodes()
+void XmlParser::_mergeNodes()
 {
   while (this->maxLevel > 1)
   {
@@ -217,7 +234,7 @@ void ls::std::io::XmlParser::_mergeNodes()
   this->document->setRootElement(this->parseParameters.front().getNode());
 }
 
-void ls::std::io::XmlParser::_mergeChildrenToParentNode(const ::std::shared_ptr<ls::std::io::XmlNode> &_parent, ::std::list<ls::std::io::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel)
+void XmlParser::_mergeChildrenToParentNode(const shared_ptr<XmlNode> &_parent, list<XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel)
 {
   do
   {
@@ -237,7 +254,7 @@ void ls::std::io::XmlParser::_mergeChildrenToParentNode(const ::std::shared_ptr<
   } while (_iterator->getLevel() > _parentLevel);
 }
 
-void ls::std::io::XmlParser::_mergeNodesOnCurrentLevel()
+void XmlParser::_mergeNodesOnCurrentLevel()
 {
   auto iterator = this->parseParameters.begin();
   uint8_t parentLevel = this->maxLevel - 1;
@@ -255,52 +272,52 @@ void ls::std::io::XmlParser::_mergeNodesOnCurrentLevel()
   }
 }
 
-void ls::std::io::XmlParser::_parse(const ls::std::core::type::byte_field &_data)
+void XmlParser::_parse(const byte_field &_data)
 {
-  for (::std::string::size_type index = 0; index < _data.size(); index++)
+  for (string::size_type index = 0; index < _data.size(); index++)
   {
     switch (this->mode)
     {
-      case XML_PARSE_MODE_ANALYZE:
+      case XmlParseMode::XML_PARSE_MODE_ANALYZE:
       {
         this->_analyze(_data, index);
       }
       break;
-      case XML_PARSE_MODE_DECLARATION:
+      case XmlParseMode::XML_PARSE_MODE_DECLARATION:
       {
         --index;
         index = this->_parseDeclaration(_data, index);
-        this->mode = XML_PARSE_MODE_ANALYZE;
+        this->mode = XmlParseMode::XML_PARSE_MODE_ANALYZE;
       }
       break;
-      case XML_PARSE_MODE_OPENING_TAG:
+      case XmlParseMode::XML_PARSE_MODE_OPENING_TAG:
       {
         --index;
-        index = ls::std::io::XmlParser::_parseOpeningTag(_data, index);
-        this->mode = XML_PARSE_MODE_ANALYZE;
+        index = XmlParser::_parseOpeningTag(_data, index);
+        this->mode = XmlParseMode::XML_PARSE_MODE_ANALYZE;
       }
       break;
-      case XML_PARSE_MODE_VALUE:
+      case XmlParseMode::XML_PARSE_MODE_VALUE:
       {
         --index;
-        index = ls::std::io::XmlParser::_parseValue(_data, index);
-        this->mode = XML_PARSE_MODE_ANALYZE;
+        index = XmlParser::_parseValue(_data, index);
+        this->mode = XmlParseMode::XML_PARSE_MODE_ANALYZE;
       }
       break;
-      case XML_PARSE_MODE_CLOSING_TAG:
+      case XmlParseMode::XML_PARSE_MODE_CLOSING_TAG:
       {
         --index;
-        index = ls::std::io::XmlParser::_parseClosingTag(_data, index);
-        this->mode = XML_PARSE_MODE_ANALYZE;
+        index = XmlParser::_parseClosingTag(_data, index);
+        this->mode = XmlParseMode::XML_PARSE_MODE_ANALYZE;
       }
       break;
     }
   }
 }
 
-::std::pair<::std::string, ::std::string> ls::std::io::XmlParser::_parseAttribute(const ls::std::core::type::byte_field &_data)
+pair<string, string> XmlParser::_parseAttribute(const byte_field &_data)
 {
-  ::std::pair<::std::string, ::std::string> parsedAttribute{};
+  pair<string, string> parsedAttribute{};
   parsedAttribute.first = _data.substr(0, _data.find('='));
   parsedAttribute.second = _data.substr(_data.find('"') + 1);
   parsedAttribute.second.pop_back();
@@ -308,11 +325,11 @@ void ls::std::io::XmlParser::_parse(const ls::std::core::type::byte_field &_data
   return parsedAttribute;
 }
 
-::std::list<::std::pair<::std::string, ::std::string>> ls::std::io::XmlParser::_parseAttributes(ls::std::core::type::byte_field _data)
+list<pair<string, string>> XmlParser::_parseAttributes(byte_field _data)
 {
-  ::std::list<::std::pair<::std::string, ::std::string>> attributes{};
+  list<pair<string, string>> attributes{};
   size_t position = _data.find(' ');
-  _data = position == ::std::string::npos ? "" : _data.substr(position);
+  _data = position == string::npos ? "" : _data.substr(position);
 
   while (!_data.empty())
   {
@@ -321,55 +338,55 @@ void ls::std::io::XmlParser::_parse(const ls::std::core::type::byte_field &_data
       position = _data.find(' ') + 1;
     } while (_data[position] == ' ');
 
-    if (_data.size() <= 3 && ls::std::io::XmlParser::_endsWith(::std::string{_data}, ">"))
+    if (_data.size() <= 3 && XmlParser::_endsWith(string{_data}, ">"))
     {
       break;
     }
 
-    ::std::string attributeString = _data.substr(position, ls::std::io::XmlParser::_findAttributeEndPosition(_data) + 1);
-    attributes.push_back(ls::std::io::XmlParser::_parseAttribute(attributeString));
+    string attributeString = _data.substr(position, XmlParser::_findAttributeEndPosition(_data) + 1);
+    attributes.push_back(XmlParser::_parseAttribute(attributeString));
     _data = _data.substr(position + attributeString.size());
   }
 
   return attributes;
 }
 
-size_t ls::std::io::XmlParser::_parseClosingTag(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
+size_t XmlParser::_parseClosingTag(const byte_field &_data, string::size_type _index)
 {
-  ::std::string tagString = ls::std::io::XmlParser::_getNextTagString(_data, _index);
+  string tagString = XmlParser::_getNextTagString(_data, _index);
   this->currentLevel -= 1;
   return tagString.empty() ? _index : _index + (tagString.size() - 1);
 }
 
-size_t ls::std::io::XmlParser::_parseDeclaration(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
+size_t XmlParser::_parseDeclaration(const byte_field &_data, string::size_type _index)
 {
-  ::std::string tagString = ls::std::io::XmlParser::_getNextTagString(_data, _index);
+  string tagString = XmlParser::_getNextTagString(_data, _index);
   bool isValidTagString = !tagString.empty();
 
   if (isValidTagString)
   {
-    ::std::shared_ptr<ls::std::io::XmlDeclaration> declaration = this->_createDeclaration(ls::std::io::XmlParser::_parseAttributes(tagString));
+    shared_ptr<XmlDeclaration> declaration = this->_createDeclaration(XmlParser::_parseAttributes(tagString));
     this->document->setDeclaration(declaration);
   }
 
   return !isValidTagString ? _index : _index + (tagString.size() - 1);
 }
 
-size_t ls::std::io::XmlParser::_parseOpeningTag(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
+size_t XmlParser::_parseOpeningTag(const byte_field &_data, string::size_type _index)
 {
-  ::std::string tagString{ls::std::io::XmlParser::_getNextTagString(_data, _index)};
+  string tagString{XmlParser::_getNextTagString(_data, _index)};
   bool isValidTagString = !tagString.empty();
-  ls::std::io::XmlParseParameter singleParseParameter{};
+  XmlParseParameter singleParseParameter{};
 
   if (isValidTagString)
   {
-    ::std::shared_ptr<ls::std::io::XmlNode> node = ls::std::io::XmlParser::_createNode(ls::std::io::XmlParser::_parseAttributes(tagString), ls::std::io::XmlParser::_parseTagName(tagString));
+    shared_ptr<XmlNode> node = XmlParser::_createNode(XmlParser::_parseAttributes(tagString), XmlParser::_parseTagName(tagString));
 
     singleParseParameter.setLevel(this->currentLevel);
     singleParseParameter.setNode(node);
     this->parseParameters.push_back(singleParseParameter);
 
-    if (!ls::std::io::XmlParser::_endsWith(tagString, "/>"))
+    if (!XmlParser::_endsWith(tagString, "/>"))
     {
       this->currentLevel += 1;
       this->_setMaxLevel();
@@ -379,11 +396,11 @@ size_t ls::std::io::XmlParser::_parseOpeningTag(const ls::std::core::type::byte_
   return !isValidTagString ? _index : _index + (tagString.size() - 1);
 }
 
-ls::std::core::type::byte_field ls::std::io::XmlParser::_parseTagName(const ls::std::core::type::byte_field &_data)
+byte_field XmlParser::_parseTagName(const byte_field &_data)
 {
-  ::std::string::size_type position = _data.find(' ');
+  string::size_type position = _data.find(' ');
 
-  if (position == ::std::string::npos)
+  if (position == string::npos)
   {
     position = _data.find('>');
   }
@@ -391,23 +408,23 @@ ls::std::core::type::byte_field ls::std::io::XmlParser::_parseTagName(const ls::
   return _data.substr(1, position - 1);
 }
 
-size_t ls::std::io::XmlParser::_parseValue(const ls::std::core::type::byte_field &_data, ::std::string::size_type _index)
+size_t XmlParser::_parseValue(const byte_field &_data, string::size_type _index)
 {
-  ls::std::core::type::byte_field value = _data.substr(_index, _data.substr(_index).find('<'));
+  byte_field value = _data.substr(_index, _data.substr(_index).find('<'));
   this->parseParameters.back().getNode()->setValue(value);
 
   return _index + (value.size() - 1);
 }
 
-void ls::std::io::XmlParser::_reset()
+void XmlParser::_reset()
 {
   this->currentLevel = 1;
   this->maxLevel = 1;
-  this->mode = ls::std::io::XML_PARSE_MODE_ANALYZE;
+  this->mode = XmlParseMode::XML_PARSE_MODE_ANALYZE;
   this->parseParameters.clear();
 }
 
-void ls::std::io::XmlParser::_setMaxLevel()
+void XmlParser::_setMaxLevel()
 {
   if (this->currentLevel > this->maxLevel)
   {

source/ls-std/io/xml/XmlReader.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-10
- * Changed:         2023-02-22
+ * Changed:         2023-02-23
  *
  * */
 
@@ -13,48 +13,60 @@
 #include <ls-std/io/xml/XmlParser.hpp>
 #include <ls-std/io/xml/XmlReader.hpp>
 
-ls::std::io::XmlReader::XmlReader(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document, const ::std::string &_absolutePath) : ls::std::core::Class("XmlReader"), xmlFile(ls::std::io::File{""})
+using ls::std::core::Class;
+using ls::std::core::IllegalArgumentException;
+using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::core::type::byte_field;
+using ls::std::io::File;
+using ls::std::io::FileReader;
+using ls::std::io::XmlDocument;
+using ls::std::io::XmlParser;
+using ls::std::io::XmlReader;
+using std::shared_ptr;
+using std::string;
+
+XmlReader::XmlReader(const shared_ptr<XmlDocument> &_document, const string &_absolutePath) : Class("XmlReader"), xmlFile(File{""})
 {
   this->_assignDocument(_document);
-  this->_assignFile(ls::std::io::File{_absolutePath});
+  this->_assignFile(File{_absolutePath});
 }
 
-ls::std::io::XmlReader::~XmlReader() noexcept = default;
+XmlReader::~XmlReader() noexcept = default;
 
-ls::std::core::type::byte_field ls::std::io::XmlReader::read()
+byte_field XmlReader::read()
 {
-  ls::std::core::type::byte_field data = ls::std::io::FileReader{this->xmlFile}.read();
-  ls::std::io::XmlParser{this->document}.parse(data);
+  byte_field data = FileReader{this->xmlFile}.read();
+  XmlParser{this->document}.parse(data);
 
   return data;
 }
 
-::std::shared_ptr<ls::std::io::XmlDocument> ls::std::io::XmlReader::getDocument()
+shared_ptr<XmlDocument> XmlReader::getDocument()
 {
   return this->document;
 }
 
-void ls::std::io::XmlReader::setDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document)
+void XmlReader::setDocument(const shared_ptr<XmlDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-void ls::std::io::XmlReader::setFile(const ls::std::io::File &_xmlFile)
+void XmlReader::setFile(const File &_xmlFile)
 {
   this->_assignFile(_xmlFile);
 }
 
-void ls::std::io::XmlReader::_assignDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document)
+void XmlReader::_assignDocument(const shared_ptr<XmlDocument> &_document)
 {
-  ls::std::core::NullPointerArgumentEvaluator{_document, "xml document reference is null!"}.evaluate();
+  NullPointerArgumentEvaluator{_document, "xml document reference is null!"}.evaluate();
   this->document = _document;
 }
 
-void ls::std::io::XmlReader::_assignFile(ls::std::io::File _xmlFile)
+void XmlReader::_assignFile(File _xmlFile)
 {
   if (!_xmlFile.exists())
   {
-    throw ls::std::core::IllegalArgumentException{"file does not exist: " + _xmlFile.getAbsoluteFilePath()};
+    throw IllegalArgumentException{"file does not exist: " + _xmlFile.getAbsoluteFilePath()};
   }
 
   this->xmlFile = _xmlFile;