Create namespace "io" for io module

include/ls_std/io/File.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -31,93 +31,99 @@
 
 namespace ls
 {
-  class File : public ls::std::core::Class
+  namespace std
   {
-    public:
-
-      explicit File(::std::string _absoluteFilePath);
-      ~File() override = default;
-
-      // comparison operators
-
-      bool operator==(ls::File &_file);
-      bool operator!=(ls::File &_file);
-
-      // additional functionality
-
-      bool canExecute();
-      bool canRead();
-      bool canWrite();
-      void createNewFile();
-      bool exists();
-      ::std::string getAbsoluteFilePath();
-      ::std::string getName();
-      ::std::string getParent();
-      static ::std::string getWorkingDirectory();
-      long getSize();
-      bool isDirectory();
-      bool isFile();
-      time_t lastModified();
-      ::std::list<::std::string> list();
-      ::std::list<::std::string> listFiles();
-      void makeDirectory();
-      void makeDirectories();
-      void remove();
-      bool renameTo(const ::std::string &_newName);
-      void reset(const ::std::string &_newPath);
-
-    private:
-
-      ::std::string absoluteFilePath{};
-
-      #if defined(unix) || defined(__APPLE__)
-      static void _addToFileListUnix(const ::std::string &_path, bool _withDirectories, dirent *directoryEntity, ::std::list<::std::string> &_list);
-      #endif
-      #ifdef _WIN32
-      static void _addToFileListWindows(const ::std::string &_path, bool _withDirectories, WIN32_FIND_DATA _data, ::std::list<::std::string> &_list);
-      #endif
-      static bool _equals(ls::File &_file, ls::File &_foreignFile);
-      static bool _exists(const ::std::string &_path);
-      static ::std::string _getParent(const ::std::string &_path);
-      #if defined(unix) || defined(__APPLE__)
-      static ::std::string _getWorkingDirectoryUnix();
-      #endif
-      #ifdef _WIN32
-      static ::std::string _getWorkingDirectoryWindows();
-      #endif
-      static bool _isDirectory(const ::std::string &_path);
-      static bool _isExecutable(const ::std::string &_path);
-      static bool _isFile(const ::std::string &_path);
-      #if defined(unix) || defined(__APPLE__)
-      static bool _isReadableUnix(const ::std::string &_path);
-      #endif
-      #ifdef _WIN32
-      static bool _isReadableWindows(const ::std::string &_path);
-      #endif
-      static bool _isWritable(const ::std::string &_path);
-      static time_t _lastModified(const ::std::string &_path);
-      static ::std::list<::std::string> _list(const ::std::string &_path);
-      static ::std::list<::std::string> _listFiles(const ::std::string &_path);
-      #if defined(unix) || defined(__APPLE__)
-      static ::std::list<::std::string> _listUnix(const ::std::string &_path, bool withDirectories);
-      #endif
-      #ifdef _WIN32
-      static ::std::list<::std::string> _listWindows(const ::std::string &_path, bool withDirectories);
-      #endif
-      static int _mkdir(const ::std::string &_path);
-      static ::std::string _normalizePath(::std::string _path);
-      static ::std::string _reduceSeparators(const ::std::string &_path);
-      static void _remove(const ::std::string &_path);
-      #if defined(unix) || defined(__APPLE__)
-      static void _removeUnix(const ::std::string &_path);
-      #endif
-      #ifdef _WIN32
-      static void _removeWindows(const ::std::string &_path);
-      #endif
-      static bool _renameTo(const ::std::string &_oldName, const ::std::string &_newName);
-      static ::std::string _replaceWrongSeparator(::std::string _path);
-      static ::std::vector<::std::string> _splitIntoSubDirectoryNames(const ::std::string &_path);
-  };
+    namespace io
+    {
+      class File : public ls::std::core::Class
+      {
+        public:
+
+          explicit File(::std::string _absoluteFilePath);
+          ~File() override = default;
+
+          // comparison operators
+
+          bool operator==(ls::std::io::File &_file);
+          bool operator!=(ls::std::io::File &_file);
+
+          // additional functionality
+
+          bool canExecute();
+          bool canRead();
+          bool canWrite();
+          void createNewFile();
+          bool exists();
+          ::std::string getAbsoluteFilePath();
+          ::std::string getName();
+          ::std::string getParent();
+          static ::std::string getWorkingDirectory();
+          long getSize();
+          bool isDirectory();
+          bool isFile();
+          time_t lastModified();
+          ::std::list<::std::string> list();
+          ::std::list<::std::string> listFiles();
+          void makeDirectory();
+          void makeDirectories();
+          void remove();
+          bool renameTo(const ::std::string &_newName);
+          void reset(const ::std::string &_newPath);
+
+        private:
+
+          ::std::string absoluteFilePath{};
+
+          #if defined(unix) || defined(__APPLE__)
+          static void _addToFileListUnix(const ::std::string &_path, bool _withDirectories, dirent *directoryEntity, ::std::list<::std::string> &_list);
+          #endif
+          #ifdef _WIN32
+          static void _addToFileListWindows(const ::std::string &_path, bool _withDirectories, WIN32_FIND_DATA _data, ::std::list<::std::string> &_list);
+          #endif
+          static bool _equals(ls::std::io::File &_file, ls::std::io::File &_foreignFile);
+          static bool _exists(const ::std::string &_path);
+          static ::std::string _getParent(const ::std::string &_path);
+          #if defined(unix) || defined(__APPLE__)
+          static ::std::string _getWorkingDirectoryUnix();
+          #endif
+          #ifdef _WIN32
+          static ::std::string _getWorkingDirectoryWindows();
+          #endif
+          static bool _isDirectory(const ::std::string &_path);
+          static bool _isExecutable(const ::std::string &_path);
+          static bool _isFile(const ::std::string &_path);
+          #if defined(unix) || defined(__APPLE__)
+          static bool _isReadableUnix(const ::std::string &_path);
+          #endif
+          #ifdef _WIN32
+          static bool _isReadableWindows(const ::std::string &_path);
+          #endif
+          static bool _isWritable(const ::std::string &_path);
+          static time_t _lastModified(const ::std::string &_path);
+          static ::std::list<::std::string> _list(const ::std::string &_path);
+          static ::std::list<::std::string> _listFiles(const ::std::string &_path);
+          #if defined(unix) || defined(__APPLE__)
+          static ::std::list<::std::string> _listUnix(const ::std::string &_path, bool withDirectories);
+          #endif
+          #ifdef _WIN32
+          static ::std::list<::std::string> _listWindows(const ::std::string &_path, bool withDirectories);
+          #endif
+          static int _mkdir(const ::std::string &_path);
+          static ::std::string _normalizePath(::std::string _path);
+          static ::std::string _reduceSeparators(const ::std::string &_path);
+          static void _remove(const ::std::string &_path);
+          #if defined(unix) || defined(__APPLE__)
+          static void _removeUnix(const ::std::string &_path);
+          #endif
+          #ifdef _WIN32
+          static void _removeWindows(const ::std::string &_path);
+          #endif
+          static bool _renameTo(const ::std::string &_oldName, const ::std::string &_newName);
+          static ::std::string _replaceWrongSeparator(::std::string _path);
+          static ::std::vector<::std::string> _splitIntoSubDirectoryNames(const ::std::string &_path);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/FileOutputStream.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -17,26 +17,32 @@
 
 namespace ls
 {
-  class FileOutputStream : public ls::std::core::Class, public ls::IWriter
+  namespace std
   {
-    public:
-
-      explicit FileOutputStream(ls::File &_file);
-      explicit FileOutputStream(ls::File &_file, bool _append);
-      ~FileOutputStream() override;
-
-      void close();
-      bool write(const ls::std::core::byte_field &_data) override;
-
-    private:
-
-      bool append{};
-      ls::File file;
-      ::std::ofstream outputStream{};
-
-      void _close();
-      void _init();
-  };
+    namespace io
+    {
+      class FileOutputStream : public ls::std::core::Class, public ls::std::io::IWriter
+      {
+        public:
+
+          explicit FileOutputStream(ls::std::io::File &_file);
+          explicit FileOutputStream(ls::std::io::File &_file, bool _append);
+          ~FileOutputStream() override;
+
+          void close();
+          bool write(const ls::std::core::byte_field &_data) override;
+
+        private:
+
+          bool append{};
+          ls::std::io::File file;
+          ::std::ofstream outputStream{};
+
+          void _close();
+          void _init();
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/FilePathSeparator.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2022-05-05
+ * Changed:         2022-05-11
  *
  * */
 
@@ -14,37 +14,43 @@
 
 namespace ls
 {
-  class FilePathSeparator
+  namespace std
   {
-    public:
-
-      FilePathSeparator() = default;
-      ~FilePathSeparator() = default;
-
-      static char get()
-      {
-        char separator;
-
-        #ifdef _WIN32
-        separator = ls::FilePathSeparator::getWindowsFilePathSeparator();
-        #endif
-        #if defined(unix) || defined(__APPLE__)
-        separator = ls::FilePathSeparator::getUnixFilePathSeparator();
-        #endif
-
-        return separator;
-      }
-
-      static char getUnixFilePathSeparator()
-      {
-        return '/';
-      }
-
-      static char getWindowsFilePathSeparator()
+    namespace io
+    {
+      class FilePathSeparator
       {
-        return '\\';
-      }
-  };
+        public:
+
+          FilePathSeparator() = default;
+          ~FilePathSeparator() = default;
+
+          static char get()
+          {
+            char separator;
+
+            #ifdef _WIN32
+            separator = ls::std::io::FilePathSeparator::getWindowsFilePathSeparator();
+            #endif
+            #if defined(unix) || defined(__APPLE__)
+            separator = ls::std::io::FilePathSeparator::getUnixFilePathSeparator();
+            #endif
+
+            return separator;
+          }
+
+          static char getUnixFilePathSeparator()
+          {
+            return '/';
+          }
+
+          static char getWindowsFilePathSeparator()
+          {
+            return '\\';
+          }
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/FilePathSeparatorMatch.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2022-05-05
+ * Changed:         2022-05-11
  *
  * */
 
@@ -14,13 +14,19 @@
 
 namespace ls
 {
-  struct FilePathSeparatorMatch
+  namespace std
   {
-    bool operator()(char _char) const
+    namespace io
     {
-      return _char == ls::FilePathSeparator::getWindowsFilePathSeparator() || _char == ls::FilePathSeparator::getUnixFilePathSeparator();
+      struct FilePathSeparatorMatch
+      {
+        bool operator()(char _char) const
+        {
+          return _char == ls::std::io::FilePathSeparator::getWindowsFilePathSeparator() || _char == ls::std::io::FilePathSeparator::getUnixFilePathSeparator();
+        }
+      };
     }
-  };
+  }
 }
 
 #endif

include/ls_std/io/FileReader.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -16,22 +16,28 @@
 
 namespace ls
 {
-  class FileReader : public ls::std::core::Class, public ls::IReader
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class FileReader : public ls::std::core::Class, public ls::std::io::IReader
+      {
+        public:
 
-      explicit FileReader(ls::File &_file);
-      ~FileReader() override = default;
+          explicit FileReader(ls::std::io::File &_file);
+          ~FileReader() override = default;
 
-      ls::std::core::byte_field read() override;
-      void reset(ls::File &_file);
+          ls::std::core::byte_field read() override;
+          void reset(ls::std::io::File &_file);
 
-    private:
+        private:
 
-      ls::File file;
+          ls::std::io::File file;
 
-      static void _init(ls::File &_file);
-  };
+          static void _init(ls::std::io::File &_file);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/FileWriter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -16,22 +16,28 @@
 
 namespace ls
 {
-  class FileWriter : public ls::std::core::Class, public ls::IWriter
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class FileWriter : public ls::std::core::Class, public ls::std::io::IWriter
+      {
+        public:
 
-      explicit FileWriter(ls::File &_file);
-      ~FileWriter() override = default;
+          explicit FileWriter(ls::std::io::File &_file);
+          ~FileWriter() override = default;
 
-      void reset(ls::File &_file);
-      bool write(const ls::std::core::byte_field &_data) override;
+          void reset(ls::std::io::File &_file);
+          bool write(const ls::std::core::byte_field &_data) override;
 
-    private:
+        private:
 
-      ls::File file;
+          ls::std::io::File file;
 
-      static void _init(ls::File &_file);
-  };
+          static void _init(ls::std::io::File &_file);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/IReader.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -14,15 +14,21 @@
 
 namespace ls
 {
-  class IReader
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class IReader
+      {
+        public:
 
-      IReader() = default;
-      ~IReader() = default;
+          IReader() = default;
+          ~IReader() = default;
 
-      virtual ls::std::core::byte_field read() = 0;
-  };
+          virtual ls::std::core::byte_field read() = 0;
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/IStorable.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -14,15 +14,22 @@
 
 namespace ls
 {
-  class IStorable
+  namespace std
   {
-    public:
-      IStorable() = default;
-      ~IStorable() = default;
+    namespace io
+    {
+      class IStorable
+      {
+        public:
 
-      virtual ls::std::core::byte_field load() = 0;
-      virtual void save(const ls::std::core::byte_field &_data) = 0;
-  };
+          IStorable() = default;
+          ~IStorable() = default;
+
+          virtual ls::std::core::byte_field load() = 0;
+          virtual void save(const ls::std::core::byte_field &_data) = 0;
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/IWriter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -15,15 +15,21 @@
 
 namespace ls
 {
-  class IWriter
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class IWriter
+      {
+        public:
 
-      IWriter() = default;
-      ~IWriter() = default;
+          IWriter() = default;
+          ~IWriter() = default;
 
-      virtual bool write(const ls::std::core::byte_field &_data) = 0;
-  };
+          virtual bool write(const ls::std::core::byte_field &_data) = 0;
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/NewLine.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-18
- * Changed:         2022-05-05
+ * Changed:         2022-05-11
  *
  * */
 
@@ -14,37 +14,43 @@
 
 namespace ls
 {
-  class NewLine
+  namespace std
   {
-    public:
-
-      NewLine() = default;
-      ~NewLine() = default;
-
-      static ::std::string get()
-      {
-        ::std::string newLine{};
-
-        #if defined(unix) || defined(__APPLE__)
-        newLine = ls::NewLine::getUnixNewLine();
-        #endif
-        #ifdef _WIN32
-        newLine = ls::NewLine::getWindowsNewLine();
-        #endif
-
-        return newLine;
-      }
-
-      static ::std::string getUnixNewLine()
-      {
-        return "\n";
-      }
-
-      static ::std::string getWindowsNewLine()
+    namespace io
+    {
+      class NewLine
       {
-        return "\r\n";
-      }
-  };
+        public:
+
+          NewLine() = default;
+          ~NewLine() = default;
+
+          static ::std::string get()
+          {
+            ::std::string newLine{};
+
+            #if defined(unix) || defined(__APPLE__)
+            newLine = ls::std::io::NewLine::getUnixNewLine();
+            #endif
+            #ifdef _WIN32
+            newLine = ls::std::io::NewLine::getWindowsNewLine();
+            #endif
+
+            return newLine;
+          }
+
+          static ::std::string getUnixNewLine()
+          {
+            return "\n";
+          }
+
+          static ::std::string getWindowsNewLine()
+          {
+            return "\r\n";
+          }
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/StandardOutputWriter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-06
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -14,15 +14,21 @@
 
 namespace ls
 {
-  class StandardOutputWriter : public ls::IWriter
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class StandardOutputWriter : public ls::std::io::IWriter
+      {
+        public:
 
-      StandardOutputWriter() = default;
-      ~StandardOutputWriter() = default;
+          StandardOutputWriter() = default;
+          ~StandardOutputWriter() = default;
 
-      bool write(const ls::std::core::byte_field &_data) override;
-  };
+          bool write(const ls::std::core::byte_field &_data) override;
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/StorableFile.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -17,24 +17,30 @@
 
 namespace ls
 {
-  class StorableFile : public ls::IStorable
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class StorableFile : public ls::std::io::IStorable
+      {
+        public:
 
-      explicit StorableFile(const ::std::string &_path);
-      ~StorableFile() = default;
+          explicit StorableFile(const ::std::string &_path);
+          ~StorableFile() = default;
 
-      ::std::shared_ptr<ls::File> getFile();
-      ls::std::core::byte_field load() override;
-      void reset(const ::std::string &_path);
-      void save(const ls::std::core::byte_field &_data) override;
+          ::std::shared_ptr<ls::std::io::File> getFile();
+          ls::std::core::byte_field load() override;
+          void reset(const ::std::string &_path);
+          void save(const ls::std::core::byte_field &_data) override;
 
-    private:
+        private:
 
-      ::std::shared_ptr<ls::File> file{};
+          ::std::shared_ptr<ls::std::io::File> file{};
 
-      void _init(const ::std::string &_path);
-  };
+          void _init(const ::std::string &_path);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/kv/KvDocument.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -17,25 +17,31 @@
 
 namespace ls
 {
-  class KvDocument : public ls::std::core::Class
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class KvDocument : public ls::std::core::Class
+      {
+        public:
 
-      KvDocument();
-      ~KvDocument() override = default;
+          KvDocument();
+          ~KvDocument() override = default;
 
-      bool addPair(ls::KvPair _pair);
-      void clear();
-      ::std::map<ls::kv_key, ls::KvPair> getPairs();
-      bool hasPair(const ls::kv_key &_key);
-      bool removePair(const ls::kv_key &_key);
+          bool addPair(ls::std::io::KvPair _pair);
+          void clear();
+          ::std::map<ls::std::io::kv_key, ls::std::io::KvPair> getPairs();
+          bool hasPair(const ls::std::io::kv_key &_key);
+          bool removePair(const ls::std::io::kv_key &_key);
 
-    private:
+        private:
 
-      ::std::map<ls::kv_key, ls::KvPair> pairs{};
+          ::std::map<ls::std::io::kv_key, ls::std::io::KvPair> pairs{};
 
-      bool _hasPair(const ls::kv_key &_key);
-  };
+          bool _hasPair(const ls::std::io::kv_key &_key);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/kv/KvFileReader.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -18,31 +18,37 @@
 
 namespace ls
 {
-  class KvFileReader : public ls::std::core::Class, public ls::IReader
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class KvFileReader : public ls::std::core::Class, public ls::std::io::IReader
+      {
+        public:
 
-      explicit KvFileReader(const ::std::shared_ptr<ls::KvDocument> &_document, const ::std::string &_absolutePath);
-      ~KvFileReader() override = default;
+          explicit KvFileReader(const ::std::shared_ptr<ls::std::io::KvDocument> &_document, const ::std::string &_absolutePath);
+          ~KvFileReader() override = default;
 
-      // implementation
+          // implementation
 
-      ls::std::core::byte_field read() override;
+          ls::std::core::byte_field read() override;
 
-      // additional functionality
+          // additional functionality
 
-      ::std::shared_ptr<ls::KvDocument> getDocument();
-      void setDocument(const ::std::shared_ptr<ls::KvDocument> &_document);
-      void setFile(const ls::File &_kvFile);
+          ::std::shared_ptr<ls::std::io::KvDocument> getDocument();
+          void setDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document);
+          void setFile(const ls::std::io::File &_kvFile);
 
-    private:
+        private:
 
-      ::std::shared_ptr<ls::KvDocument> document{};
-      ls::File kvFile;
+          ::std::shared_ptr<ls::std::io::KvDocument> document{};
+          ls::std::io::File kvFile;
 
-      void _assignDocument(const ::std::shared_ptr<ls::KvDocument> &_document);
-      void _assignFile(ls::File _kvFile);
-  };
+          void _assignDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document);
+          void _assignFile(ls::std::io::File _kvFile);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/kv/KvPair.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -15,24 +15,30 @@
 
 namespace ls
 {
-  class KvPair : public ls::std::core::Class
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class KvPair : public ls::std::core::Class
+      {
+        public:
 
-      explicit KvPair(const ls::kv_key &_key, ls::kv_value _value);
-      ~KvPair() override = default;
+          explicit KvPair(const ls::std::io::kv_key &_key, ls::std::io::kv_value _value);
+          ~KvPair() override = default;
 
-      ls::kv_key getKey();
-      ls::kv_value getValue();
-      void setValue(const ls::kv_value &_value);
+          ls::std::io::kv_key getKey();
+          ls::std::io::kv_value getValue();
+          void setValue(const ls::std::io::kv_value &_value);
 
-    private:
+        private:
 
-      ls::kv_key key{};
-      ls::kv_value value{};
+          ls::std::io::kv_key key{};
+          ls::std::io::kv_value value{};
 
-      void _assignKey(const ls::kv_key &_key);
-  };
+          void _assignKey(const ls::std::io::kv_key &_key);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/kv/KvParseParameter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-06
+ * Changed:         2022-05-11
  *
  * */
 
@@ -15,11 +15,17 @@
 
 namespace ls
 {
-  struct KvParseParameter
+  namespace std
   {
-    ::std::string::size_type index{};
-    ls::std::boxing::String line{};
-  };
+    namespace io
+    {
+      struct KvParseParameter
+      {
+        ::std::string::size_type index{};
+        ls::std::boxing::String line{};
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/kv/KvParser.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -18,29 +18,35 @@
 
 namespace ls
 {
-  class KvParser : public ls::std::core::Class
+  namespace std
   {
-    public:
-
-      explicit KvParser(const ::std::shared_ptr<ls::KvDocument> &_document);
-      ~KvParser() override = default;
-
-      ::std::shared_ptr<ls::KvDocument> getDocument();
-      void parse(const ls::std::core::byte_field &_data);
-      void setDocument(const ::std::shared_ptr<ls::KvDocument> &_document);
-
-    private:
-
-      ::std::shared_ptr<ls::KvDocument> document{};
-
-      void _assignDocument(const ::std::shared_ptr<ls::KvDocument> &_document);
-      static bool _lineHasPair(ls::KvParseParameter _parseParameter);
-      void _parse(const ls::std::core::byte_field &_data);
-      void _parsePair(ls::KvParseParameter _parseParameter);
-      static ls::KvParseParameter _readLine(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-      static void _readLineWithUnixLineBreak(ls::KvParseParameter &_parseParameter);
-      static void _readLineWithWindowsLineBreak(ls::KvParseParameter &_parseParameter);
-  };
+    namespace io
+    {
+      class KvParser : public ls::std::core::Class
+      {
+        public:
+
+          explicit KvParser(const ::std::shared_ptr<ls::std::io::KvDocument> &_document);
+          ~KvParser() override = default;
+
+          ::std::shared_ptr<ls::std::io::KvDocument> getDocument();
+          void parse(const ls::std::core::byte_field &_data);
+          void setDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document);
+
+        private:
+
+          ::std::shared_ptr<ls::std::io::KvDocument> document{};
+
+          void _assignDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document);
+          static bool _lineHasPair(ls::std::io::KvParseParameter _parseParameter);
+          void _parse(const ls::std::core::byte_field &_data);
+          void _parsePair(ls::std::io::KvParseParameter _parseParameter);
+          static ls::std::io::KvParseParameter _readLine(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          static void _readLineWithUnixLineBreak(ls::std::io::KvParseParameter &_parseParameter);
+          static void _readLineWithWindowsLineBreak(ls::std::io::KvParseParameter &_parseParameter);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/kv/KvTypes.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-05
+ * Changed:         2022-05-11
  *
  * */
 
@@ -14,8 +14,14 @@
 
 namespace ls
 {
-  using kv_key = ::std::string;
-  using kv_value = ::std::string;
+  namespace std
+  {
+    namespace io
+    {
+      using kv_key = ::std::string;
+      using kv_value = ::std::string;
+    }
+  }
 }
 
 #endif

include/ls_std/io/logging/LogLevel.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -16,35 +16,41 @@
 
 namespace ls
 {
-  class LogLevel : public ls::std::core::Class
+  namespace std
   {
-    public:
-
-      explicit LogLevel(const ls::LogLevelValue &_value);
-      LogLevel();
-      ~LogLevel() override = default;
-
-      operator unsigned char() const;
-      ls::LogLevel &operator=(const ls::LogLevelValue &_value);
-      bool operator<(const ls::LogLevelValue &_value);
-      bool operator<=(const ls::LogLevelValue &_value);
-      bool operator>(const ls::LogLevelValue &_value);
-      bool operator>=(const ls::LogLevelValue &_value);
-      bool operator==(const ls::LogLevelValue &_value);
-
-      void setLogLevel(const ls::LogLevelValue &_value);
-      void setLogLevel(const ::std::string &_value);
-      ::std::string toString() const;
-
-    private:
-
-      ::std::unordered_map<uint8_t, ::std::string> level{};
-      ls::LogLevelValue value{};
-
-      ls::LogLevelValue _getValueFromString(const ::std::string &_value);
-      void _init();
-      bool _isValidLogLevelString(const ::std::string &_value);
-  };
+    namespace io
+    {
+      class LogLevel : public ls::std::core::Class
+      {
+        public:
+
+          explicit LogLevel(const ls::std::io::LogLevelValue &_value);
+          LogLevel();
+          ~LogLevel() override = default;
+
+          operator unsigned char() const;
+          ls::std::io::LogLevel &operator=(const ls::std::io::LogLevelValue &_value);
+          bool operator<(const ls::std::io::LogLevelValue &_value);
+          bool operator<=(const ls::std::io::LogLevelValue &_value);
+          bool operator>(const ls::std::io::LogLevelValue &_value);
+          bool operator>=(const ls::std::io::LogLevelValue &_value);
+          bool operator==(const ls::std::io::LogLevelValue &_value);
+
+          void setLogLevel(const ls::std::io::LogLevelValue &_value);
+          void setLogLevel(const ::std::string &_value);
+          ::std::string toString() const;
+
+        private:
+
+          ::std::unordered_map<uint8_t, ::std::string> level{};
+          ls::std::io::LogLevelValue value{};
+
+          ls::std::io::LogLevelValue _getValueFromString(const ::std::string &_value);
+          void _init();
+          bool _isValidLogLevelString(const ::std::string &_value);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/logging/LogLevelValue.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-05
+ * Changed:         2022-05-11
  *
  * */
 
@@ -12,10 +12,16 @@
 
 namespace ls
 {
-  enum LogLevelValue
+  namespace std
   {
-    FATAL = 0, ERR, WARN, INFO, DEBUG, TRACE
-  };
+    namespace io
+    {
+      enum LogLevelValue
+      {
+        FATAL = 0, ERR, WARN, INFO, DEBUG, TRACE
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/logging/Logger.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -19,30 +19,36 @@
 
 namespace ls
 {
-  class Logger : public ls::std::core::Class
+  namespace std
   {
-    public:
-
-      explicit Logger(const ::std::shared_ptr<ls::IWriter> &_writer);
-      ~Logger() override = default;
-
-      void debug(const ls::std::core::byte *_data);
-      void error(const ls::std::core::byte *_data);
-      void fatal(const ls::std::core::byte *_data);
-      ls::LogLevel getLogLevel();
-      void info(const ls::std::core::byte *_data);
-      void setLogLevel(const ls::LogLevelValue &_logLevelValue);
-      void trace(const ls::std::core::byte *_data);
-      void warn(const ls::std::core::byte *_data);
-
-    private:
-
-      ls::LogLevel logLevel{};
-      ::std::shared_ptr<ls::IWriter> writer{};
-
-      void _assignWriter(const ::std::shared_ptr<ls::IWriter> &_writer);
-      void _log(const ls::std::core::byte *_data, const ls::LogLevel &_logLevel);
-  };
+    namespace io
+    {
+      class Logger : public ls::std::core::Class
+      {
+        public:
+
+          explicit Logger(const ::std::shared_ptr<ls::std::io::IWriter> &_writer);
+          ~Logger() override = default;
+
+          void debug(const ls::std::core::byte *_data);
+          void error(const ls::std::core::byte *_data);
+          void fatal(const ls::std::core::byte *_data);
+          ls::std::io::LogLevel getLogLevel();
+          void info(const ls::std::core::byte *_data);
+          void setLogLevel(const ls::std::io::LogLevelValue &_logLevelValue);
+          void trace(const ls::std::core::byte *_data);
+          void warn(const ls::std::core::byte *_data);
+
+        private:
+
+          ls::std::io::LogLevel logLevel{};
+          ::std::shared_ptr<ls::std::io::IWriter> writer{};
+
+          void _assignWriter(const ::std::shared_ptr<ls::std::io::IWriter> &_writer);
+          void _log(const ls::std::core::byte *_data, const ls::std::io::LogLevel &_logLevel);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlAttribute.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-23
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -15,27 +15,33 @@
 
 namespace ls
 {
-  class XmlAttribute : public ls::std::core::Class
+  namespace std
   {
-    public:
-
-      explicit XmlAttribute(const ::std::string& _name);
-      ~XmlAttribute() override = default;
-
-      ::std::string getName();
-      ::std::string getValue();
-      void setName(const ::std::string& _name);
-      void setValue(const ::std::string& _value);
-      ::std::string toXml();
-
-    private:
-
-      ::std::string name{};
-      ::std::string value{};
-
-      void _assignName(const ::std::string& _name);
-      void _assignValue(const ::std::string& _value);
-  };
+    namespace io
+    {
+      class XmlAttribute : public ls::std::core::Class
+      {
+        public:
+
+          explicit XmlAttribute(const ::std::string &_name);
+          ~XmlAttribute() override = default;
+
+          ::std::string getName();
+          ::std::string getValue();
+          void setName(const ::std::string &_name);
+          void setValue(const ::std::string &_value);
+          ::std::string toXml();
+
+        private:
+
+          ::std::string name{};
+          ::std::string value{};
+
+          void _assignName(const ::std::string &_name);
+          void _assignValue(const ::std::string &_value);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlDeclaration.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -15,29 +15,35 @@
 
 namespace ls
 {
-  class XmlDeclaration : public ls::std::core::Class
+  namespace std
   {
-    public:
-
-      explicit XmlDeclaration(const ::std::string& _version);
-      ~XmlDeclaration() override = default;
-
-      ::std::string getEncoding();
-      ::std::string getStandalone();
-      ::std::string getVersion();
-      void setEncoding(const ::std::string& _encoding);
-      void setStandalone(const ::std::string& _standalone);
-      void setVersion(const ::std::string& _version);
-      ::std::string toXml();
-
-    private:
-
-      ls::XmlAttribute encoding{"encoding"};
-      ls::XmlAttribute standalone{"standalone"};
-      ls::XmlAttribute version{"version"};
-
-      static ::std::string _toXmlAttribute(ls::XmlAttribute _attribute);
-  };
+    namespace io
+    {
+      class XmlDeclaration : public ls::std::core::Class
+      {
+        public:
+
+          explicit XmlDeclaration(const ::std::string &_version);
+          ~XmlDeclaration() override = default;
+
+          ::std::string getEncoding();
+          ::std::string getStandalone();
+          ::std::string getVersion();
+          void setEncoding(const ::std::string &_encoding);
+          void setStandalone(const ::std::string &_standalone);
+          void setVersion(const ::std::string &_version);
+          ::std::string toXml();
+
+        private:
+
+          ls::std::io::XmlAttribute encoding{"encoding"};
+          ls::std::io::XmlAttribute standalone{"standalone"};
+          ls::std::io::XmlAttribute version{"version"};
+
+          static ::std::string _toXmlAttribute(ls::std::io::XmlAttribute _attribute);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlDocument.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-27
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -17,27 +17,33 @@
 
 namespace ls
 {
-  class XmlDocument : public ls::std::core::Class
+  namespace std
   {
-    public:
-
-      XmlDocument();
-      ~XmlDocument() override = default;
-
-      ::std::shared_ptr<ls::XmlDeclaration> getDeclaration();
-      ::std::shared_ptr<ls::XmlNode> getRootElement();
-      void setDeclaration(const ::std::shared_ptr<ls::XmlDeclaration> &_declaration);
-      void setRootElement(const ::std::shared_ptr<ls::XmlNode> &_rootElement);
-      ::std::string toXml();
-
-    private:
-
-      ::std::shared_ptr<ls::XmlDeclaration> declaration{};
-      ::std::shared_ptr<ls::XmlNode> rootElement{};
-
-      void _assignDeclaration(const ::std::shared_ptr<ls::XmlDeclaration> &_declaration);
-      void _assignRootElement(const ::std::shared_ptr<ls::XmlNode> &_rootElement);
-  };
+    namespace io
+    {
+      class XmlDocument : public ls::std::core::Class
+      {
+        public:
+
+          XmlDocument();
+          ~XmlDocument() override = default;
+
+          ::std::shared_ptr<ls::std::io::XmlDeclaration> getDeclaration();
+          ::std::shared_ptr<ls::std::io::XmlNode> getRootElement();
+          void setDeclaration(const ::std::shared_ptr<ls::std::io::XmlDeclaration> &_declaration);
+          void setRootElement(const ::std::shared_ptr<ls::std::io::XmlNode> &_rootElement);
+          ::std::string toXml();
+
+        private:
+
+          ::std::shared_ptr<ls::std::io::XmlDeclaration> declaration{};
+          ::std::shared_ptr<ls::std::io::XmlNode> rootElement{};
+
+          void _assignDeclaration(const ::std::shared_ptr<ls::std::io::XmlDeclaration> &_declaration);
+          void _assignRootElement(const ::std::shared_ptr<ls::std::io::XmlNode> &_rootElement);
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlNode.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-24
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -17,66 +17,72 @@
 
 namespace ls
 {
-  class XmlNode : public ls::std::core::Class
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class XmlNode : public ls::std::core::Class
+      {
+        public:
 
-      explicit XmlNode(::std::string _name);
-      ~XmlNode() override = default;
+          explicit XmlNode(::std::string _name);
+          ~XmlNode() override = default;
 
-      bool addAttributeAfter(const ::std::shared_ptr<ls::XmlAttribute> &_attribute, const ::std::string &_name);
-      bool addAttributeBefore(const ::std::shared_ptr<ls::XmlAttribute> &_attribute, const ::std::string &_name);
-      bool addAttributeToBeginning(const ::std::shared_ptr<ls::XmlAttribute> &_attribute);
-      bool addAttributeToEnd(const ::std::shared_ptr<ls::XmlAttribute> &_attribute);
-      bool addChildAfter(const ::std::shared_ptr<ls::XmlNode> &_child, const ::std::shared_ptr<ls::XmlNode> &_search);
-      bool addChildBefore(const ::std::shared_ptr<ls::XmlNode> &_child, const ::std::shared_ptr<ls::XmlNode> &_search);
-      bool addChildToBeginning(const ::std::shared_ptr<ls::XmlNode> &_child);
-      bool addChildToEnd(const ::std::shared_ptr<ls::XmlNode> &_child);
-      void clearValue();
-      ::std::list<::std::shared_ptr<ls::XmlAttribute>> getAttributes();
-      ::std::list<::std::shared_ptr<ls::XmlNode>> getChildren();
-      ::std::list<::std::shared_ptr<ls::XmlNode>> getChildren(const ::std::string &_name);
-      ::std::string getName();
-      ::std::string getValue();
-      bool hasAttribute(const ::std::string &_name);
-      bool hasChild(const ::std::string &_name);
-      bool hasChild(const ::std::shared_ptr<ls::XmlNode> &_child);
-      bool removeFirstAttribute();
-      bool removeLastAttribute();
-      bool removeFirstChild();
-      bool removeLastChild();
-      void setName(const ::std::string &_name);
-      void setValue(const ::std::string &_value);
-      ::std::string toXml();
+          bool addAttributeAfter(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute, const ::std::string &_name);
+          bool addAttributeBefore(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute, const ::std::string &_name);
+          bool addAttributeToBeginning(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute);
+          bool addAttributeToEnd(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute);
+          bool addChildAfter(const ::std::shared_ptr<ls::std::io::XmlNode> &_child, const ::std::shared_ptr<ls::std::io::XmlNode> &_search);
+          bool addChildBefore(const ::std::shared_ptr<ls::std::io::XmlNode> &_child, const ::std::shared_ptr<ls::std::io::XmlNode> &_search);
+          bool addChildToBeginning(const ::std::shared_ptr<ls::std::io::XmlNode> &_child);
+          bool addChildToEnd(const ::std::shared_ptr<ls::std::io::XmlNode> &_child);
+          void clearValue();
+          ::std::list<::std::shared_ptr<ls::std::io::XmlAttribute>> getAttributes();
+          ::std::list<::std::shared_ptr<ls::std::io::XmlNode>> getChildren();
+          ::std::list<::std::shared_ptr<ls::std::io::XmlNode>> getChildren(const ::std::string &_name);
+          ::std::string getName();
+          ::std::string getValue();
+          bool hasAttribute(const ::std::string &_name);
+          bool hasChild(const ::std::string &_name);
+          bool hasChild(const ::std::shared_ptr<ls::std::io::XmlNode> &_child);
+          bool removeFirstAttribute();
+          bool removeLastAttribute();
+          bool removeFirstChild();
+          bool removeLastChild();
+          void setName(const ::std::string &_name);
+          void setValue(const ::std::string &_value);
+          ::std::string toXml();
 
-    protected:
+        protected:
 
-      ::std::string _toXml_(uint8_t _tabSize);
+          ::std::string _toXml_(uint8_t _tabSize);
 
-    private:
+        private:
 
-      ::std::list<::std::shared_ptr<ls::XmlAttribute>> attributes{};
-      ::std::list<::std::shared_ptr<ls::XmlNode>> children{};
-      ::std::string name{};
-      const static uint8_t TAB_SIZE{4};
-      ::std::string value{};
+          ::std::list<::std::shared_ptr<ls::std::io::XmlAttribute>> attributes{};
+          ::std::list<::std::shared_ptr<ls::std::io::XmlNode>> children{};
+          ::std::string name{};
+          const static uint8_t TAB_SIZE{4};
+          ::std::string value{};
 
-      void _assignName(const ::std::string &_name);
-      void _assignValue(const ::std::string &_value);
-      static void _checkIfAttributeReferenceIsValid(const ::std::shared_ptr<ls::XmlAttribute> &_attribute);
-      static void _checkIfNameIsNotEmpty(const ::std::string &_name);
-      static void _checkIfNodeReferenceIsValid(const ::std::shared_ptr<ls::XmlNode> &_child);
-      static ::std::string _getTab(uint8_t _tabSize);
-      bool _hasAttribute(const ::std::string &_name);
-      bool _hasChild(const ::std::shared_ptr<ls::XmlNode> &_child);
-      bool _hasChild(const ::std::string &_name);
-      ::std::string _toXmlAttributes();
-      ::std::string _toXmlChildren(uint8_t _tabSize);
-      ::std::string _toXmlCloseTag();
-      ::std::string _toXmlOpenTag();
-      ::std::string _toXmlOpenTagClose();
-      ::std::string _toXmlValue();
-  };
+          void _assignName(const ::std::string &_name);
+          void _assignValue(const ::std::string &_value);
+          static void _checkIfAttributeReferenceIsValid(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute);
+          static void _checkIfNameIsNotEmpty(const ::std::string &_name);
+          static void _checkIfNodeReferenceIsValid(const ::std::shared_ptr<ls::std::io::XmlNode> &_child);
+          static ::std::string _getTab(uint8_t _tabSize);
+          bool _hasAttribute(const ::std::string &_name);
+          bool _hasChild(const ::std::shared_ptr<ls::std::io::XmlNode> &_child);
+          bool _hasChild(const ::std::string &_name);
+          ::std::string _toXmlAttributes();
+          ::std::string _toXmlChildren(uint8_t _tabSize);
+          ::std::string _toXmlCloseTag();
+          ::std::string _toXmlOpenTag();
+          ::std::string _toXmlOpenTagClose();
+          ::std::string _toXmlValue();
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlParseMode.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-13
- * Changed:         2022-05-05
+ * Changed:         2022-05-11
  *
  * */
 
@@ -12,10 +12,16 @@
 
 namespace ls
 {
-  enum XmlParseMode
+  namespace std
   {
-    XML_PARSE_MODE_ANALYZE = 0, XML_PARSE_MODE_DECLARATION, XML_PARSE_MODE_OPENING_TAG, XML_PARSE_MODE_VALUE, XML_PARSE_MODE_CLOSING_TAG
-  };
+    namespace io
+    {
+      enum XmlParseMode
+      {
+        XML_PARSE_MODE_ANALYZE = 0, XML_PARSE_MODE_DECLARATION, XML_PARSE_MODE_OPENING_TAG, XML_PARSE_MODE_VALUE, XML_PARSE_MODE_CLOSING_TAG
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlParseParameter.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-17
- * Changed:         2022-05-05
+ * Changed:         2022-05-11
  *
  * */
 
@@ -16,11 +16,17 @@
 
 namespace ls
 {
-  struct XmlParseParameter
+  namespace std
   {
-    uint8_t level{};
-    ::std::shared_ptr<ls::XmlNode> node{};
-  };
+    namespace io
+    {
+      struct XmlParseParameter
+      {
+        uint8_t level{};
+        ::std::shared_ptr<ls::std::io::XmlNode> node{};
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlParser.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-25
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -19,55 +19,61 @@
 
 namespace ls
 {
-  class XmlParser : public ls::std::core::Class
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class XmlParser : public ls::std::core::Class
+      {
+        public:
 
-      explicit XmlParser(const ::std::shared_ptr<ls::XmlDocument> &_document);
-      ~XmlParser() override = default;
+          explicit XmlParser(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
+          ~XmlParser() override = default;
 
-      ::std::shared_ptr<ls::XmlDocument> getDocument();
-      void parse(const ls::std::core::byte_field &_data);
-      void setDocument(const ::std::shared_ptr<ls::XmlDocument> &_document);
+          ::std::shared_ptr<ls::std::io::XmlDocument> getDocument();
+          void parse(const ls::std::core::byte_field &_data);
+          void setDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
 
-    protected:
+        protected:
 
-      static ::std::pair<::std::string, ::std::string> _readAttribute_(const ls::std::core::byte_field &_data);
-      static ::std::list<::std::pair<::std::string, ::std::string>> _readAttributes_(ls::std::core::byte_field _data);
+          static ::std::pair<::std::string, ::std::string> _readAttribute_(const ls::std::core::byte_field &_data);
+          static ::std::list<::std::pair<::std::string, ::std::string>> _readAttributes_(ls::std::core::byte_field _data);
 
-    private:
+        private:
 
-      uint8_t currentLevel{};
-      ::std::shared_ptr<ls::XmlDocument> document{};
-      uint8_t maxLevel{};
-      ls::XmlParseMode mode{};
-      ::std::list<ls::XmlParseParameter> parseParameters{};
+          uint8_t currentLevel{};
+          ::std::shared_ptr<ls::std::io::XmlDocument> document{};
+          uint8_t maxLevel{};
+          ls::std::io::XmlParseMode mode{};
+          ::std::list<ls::std::io::XmlParseParameter> parseParameters{};
 
-      void _analyze(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-      void _assignDocument(const ::std::shared_ptr<ls::XmlDocument> &_document);
-      static ::std::shared_ptr<ls::XmlDeclaration> _createDeclaration(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes);
-      static ::std::shared_ptr<ls::XmlNode> _createNode(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name);
-      static ::std::pair<::std::string, ::std::string> _findAttribute(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name);
-      static size_t _findAttributeEndPosition(const ls::std::core::byte_field &_data);
-      static ls::std::core::byte_field _getNextTagString(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-      void _isClosingTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-      void _isDeclaration(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-      void _isOpeningTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-      void _isValue(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-      void _mergeNodes();
-      void _mergeChildrenToParentNode(const ::std::shared_ptr<ls::XmlNode> &_parent, ::std::list<ls::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel);
-      void _mergeNodesOnCurrentLevel();
-      void _parse(const ls::std::core::byte_field &_data);
-      static ::std::pair<::std::string, ::std::string> _parseAttribute(const ls::std::core::byte_field &_data);
-      static ::std::list<::std::pair<::std::string, ::std::string>> _parseAttributes(ls::std::core::byte_field _data);
-      size_t _parseClosingTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-      size_t _parseDeclaration(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-      size_t _parseOpeningTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-      static ls::std::core::byte_field _parseTagName(const ls::std::core::byte_field &_data);
-      size_t _parseValue(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
-      void _reset();
-      void _setMaxLevel();
-  };
+          void _analyze(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          void _assignDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
+          static ::std::shared_ptr<ls::std::io::XmlDeclaration> _createDeclaration(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes);
+          static ::std::shared_ptr<ls::std::io::XmlNode> _createNode(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name);
+          static ::std::pair<::std::string, ::std::string> _findAttribute(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name);
+          static size_t _findAttributeEndPosition(const ls::std::core::byte_field &_data);
+          static ls::std::core::byte_field _getNextTagString(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          void _isClosingTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          void _isDeclaration(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          void _isOpeningTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          void _isValue(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          void _mergeNodes();
+          void _mergeChildrenToParentNode(const ::std::shared_ptr<ls::std::io::XmlNode> &_parent, ::std::list<ls::std::io::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel);
+          void _mergeNodesOnCurrentLevel();
+          void _parse(const ls::std::core::byte_field &_data);
+          static ::std::pair<::std::string, ::std::string> _parseAttribute(const ls::std::core::byte_field &_data);
+          static ::std::list<::std::pair<::std::string, ::std::string>> _parseAttributes(ls::std::core::byte_field _data);
+          size_t _parseClosingTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          size_t _parseDeclaration(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          size_t _parseOpeningTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          static ls::std::core::byte_field _parseTagName(const ls::std::core::byte_field &_data);
+          size_t _parseValue(const ls::std::core::byte_field &_data, ::std::string::size_type _index);
+          void _reset();
+          void _setMaxLevel();
+      };
+    }
+  }
 }
 
 #endif

include/ls_std/io/xml/XmlReader.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-08
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -20,31 +20,37 @@
 
 namespace ls
 {
-  class XmlReader : public ls::std::core::Class, public ls::IReader
+  namespace std
   {
-    public:
+    namespace io
+    {
+      class XmlReader : public ls::std::core::Class, public ls::std::io::IReader
+      {
+        public:
 
-      explicit XmlReader(const ::std::shared_ptr<ls::XmlDocument> &_document, const ::std::string &_absolutePath);
-      ~XmlReader() override = default;
+          explicit XmlReader(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document, const ::std::string &_absolutePath);
+          ~XmlReader() override = default;
 
-      // implementation
+          // implementation
 
-      ls::std::core::byte_field read() override;
+          ls::std::core::byte_field read() override;
 
-      // additional functionality
+          // additional functionality
 
-      ::std::shared_ptr<ls::XmlDocument> getDocument();
-      void setDocument(const ::std::shared_ptr<ls::XmlDocument> &_document);
-      void setFile(const ls::File &_xmlFile);
+          ::std::shared_ptr<ls::std::io::XmlDocument> getDocument();
+          void setDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
+          void setFile(const ls::std::io::File &_xmlFile);
 
-    private:
+        private:
 
-      ::std::shared_ptr<ls::XmlDocument> document{};
-      ls::File xmlFile;
+          ::std::shared_ptr<ls::std::io::XmlDocument> document{};
+          ls::std::io::File xmlFile;
 
-      void _assignDocument(const ::std::shared_ptr<ls::XmlDocument> &_document);
-      void _assignFile(ls::File _xmlFile);
-  };
+          void _assignDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document);
+          void _assignFile(ls::std::io::File _xmlFile);
+      };
+    }
+  }
 }
 
 #endif

source/ls_std/io/File.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -30,48 +30,48 @@
 
 #endif
 
-ls::File::File(::std::string _absoluteFilePath)
+ls::std::io::File::File(::std::string _absoluteFilePath)
     : ls::std::core::Class("File"),
-      absoluteFilePath(ls::File::_normalizePath(::std::move(_absoluteFilePath)))
+      absoluteFilePath(ls::std::io::File::_normalizePath(::std::move(_absoluteFilePath)))
 {}
 
-bool ls::File::operator==(ls::File &_file)
+bool ls::std::io::File::operator==(ls::std::io::File &_file)
 {
-  return ls::File::_equals(*this, _file);
+  return ls::std::io::File::_equals(*this, _file);
 }
 
-bool ls::File::operator!=(ls::File &_file)
+bool ls::std::io::File::operator!=(ls::std::io::File &_file)
 {
-  return !ls::File::_equals(*this, _file);
+  return !ls::std::io::File::_equals(*this, _file);
 }
 
-bool ls::File::canExecute()
+bool ls::std::io::File::canExecute()
 {
-  return ls::File::_isExecutable(this->absoluteFilePath);
+  return ls::std::io::File::_isExecutable(this->absoluteFilePath);
 }
 
-bool ls::File::canRead()
+bool ls::std::io::File::canRead()
 {
   bool readable;
 
   #if defined(unix) || defined(__APPLE__)
-  readable = ls::File::_isReadableUnix(this->absoluteFilePath);
+  readable = ls::std::io::File::_isReadableUnix(this->absoluteFilePath);
   #endif
   #ifdef _WIN32
-  readable = ls::File::_isReadableWindows(this->absoluteFilePath);
+  readable = ls::std::io::File::_isReadableWindows(this->absoluteFilePath);
   #endif
 
   return readable;
 }
 
-bool ls::File::canWrite()
+bool ls::std::io::File::canWrite()
 {
-  return ls::File::_isWritable(this->absoluteFilePath);
+  return ls::std::io::File::_isWritable(this->absoluteFilePath);
 }
 
-void ls::File::createNewFile()
+void ls::std::io::File::createNewFile()
 {
-  if (!ls::File::_exists(this->absoluteFilePath))
+  if (!ls::std::io::File::_exists(this->absoluteFilePath))
   {
     ::std::ofstream file{this->absoluteFilePath};
     file.close();
@@ -82,57 +82,57 @@ void ls::File::createNewFile()
   }
 }
 
-bool ls::File::exists()
+bool ls::std::io::File::exists()
 {
-  return ls::File::_exists(this->absoluteFilePath);
+  return ls::std::io::File::_exists(this->absoluteFilePath);
 }
 
-std::string ls::File::getAbsoluteFilePath()
+std::string ls::std::io::File::getAbsoluteFilePath()
 {
   return this->absoluteFilePath;
 }
 
-std::string ls::File::getName()
+std::string ls::std::io::File::getName()
 {
   ::std::string copy = this->absoluteFilePath;
 
   // if it's a directory, remove separator from end, if it does exist
 
-  if (ls::File::_isDirectory(this->absoluteFilePath))
+  if (ls::std::io::File::_isDirectory(this->absoluteFilePath))
   {
-    copy.erase(::std::remove_if(copy.end() - 1, copy.end(), ls::FilePathSeparatorMatch()), copy.end());
+    copy.erase(::std::remove_if(copy.end() - 1, copy.end(), ls::std::io::FilePathSeparatorMatch()), copy.end());
   }
 
   // now get the file / directory name
 
-  auto base = ::std::find_if(copy.rbegin(), copy.rend(), ls::FilePathSeparatorMatch()).base();
+  auto base = ::std::find_if(copy.rbegin(), copy.rend(), ls::std::io::FilePathSeparatorMatch()).base();
   return ::std::string{base, copy.end()};
 }
 
-std::string ls::File::getParent()
+std::string ls::std::io::File::getParent()
 {
-  return ls::File::_getParent(this->absoluteFilePath);
+  return ls::std::io::File::_getParent(this->absoluteFilePath);
 }
 
-std::string ls::File::getWorkingDirectory()
+std::string ls::std::io::File::getWorkingDirectory()
 {
   ::std::string workingDirectory{};
 
   #if defined(unix) || defined(__APPLE__)
-  workingDirectory = ls::File::_getWorkingDirectoryUnix();
+  workingDirectory = ls::std::io::File::_getWorkingDirectoryUnix();
   #endif
   #ifdef _WIN32
-  workingDirectory = ls::File::_getWorkingDirectoryWindows();
+  workingDirectory = ls::std::io::File::_getWorkingDirectoryWindows();
   #endif
 
   return workingDirectory;
 }
 
-long ls::File::getSize()
+long ls::std::io::File::getSize()
 {
   ::std::streampos fileSize{};
 
-  if (ls::File::_exists(this->absoluteFilePath))
+  if (ls::std::io::File::_exists(this->absoluteFilePath))
   {
     ::std::ifstream fileHandler{this->absoluteFilePath, ::std::ios::in};
     fileSize = fileHandler.tellg();
@@ -144,88 +144,88 @@ long ls::File::getSize()
   return (long) fileSize;
 }
 
-bool ls::File::isDirectory()
+bool ls::std::io::File::isDirectory()
 {
-  return ls::File::_isDirectory(this->absoluteFilePath);
+  return ls::std::io::File::_isDirectory(this->absoluteFilePath);
 }
 
-bool ls::File::isFile()
+bool ls::std::io::File::isFile()
 {
-  return ls::File::_isFile(this->absoluteFilePath);
+  return ls::std::io::File::_isFile(this->absoluteFilePath);
 }
 
-time_t ls::File::lastModified()
+time_t ls::std::io::File::lastModified()
 {
-  return ls::File::_lastModified(this->absoluteFilePath);
+  return ls::std::io::File::_lastModified(this->absoluteFilePath);
 }
 
-std::list<std::string> ls::File::list()
+std::list<std::string> ls::std::io::File::list()
 {
   ::std::list<::std::string> fileList{};
 
-  if (ls::File::_isDirectory(this->absoluteFilePath))
+  if (ls::std::io::File::_isDirectory(this->absoluteFilePath))
   {
-    fileList = ls::File::_list(this->absoluteFilePath);
+    fileList = ls::std::io::File::_list(this->absoluteFilePath);
   }
 
   return fileList;
 }
 
-std::list<std::string> ls::File::listFiles()
+std::list<std::string> ls::std::io::File::listFiles()
 {
   ::std::list<::std::string> fileList{};
 
-  if (ls::File::_isDirectory(this->absoluteFilePath))
+  if (ls::std::io::File::_isDirectory(this->absoluteFilePath))
   {
-    fileList = ls::File::_listFiles(this->absoluteFilePath);
+    fileList = ls::std::io::File::_listFiles(this->absoluteFilePath);
   }
 
   return fileList;
 }
 
-void ls::File::makeDirectory()
+void ls::std::io::File::makeDirectory()
 {
-  if (ls::File::_mkdir(this->absoluteFilePath))
+  if (ls::std::io::File::_mkdir(this->absoluteFilePath))
   {
     throw ls::std::core::FileOperationException{};
   }
 }
 
-void ls::File::makeDirectories()
+void ls::std::io::File::makeDirectories()
 {
-  ::std::vector<::std::string> subDirectories = ls::File::_splitIntoSubDirectoryNames(this->absoluteFilePath);
-  const char separator = ls::FilePathSeparator::get();
+  ::std::vector<::std::string> subDirectories = ls::std::io::File::_splitIntoSubDirectoryNames(this->absoluteFilePath);
+  const char separator = ls::std::io::FilePathSeparator::get();
   ::std::string currentHierarchy{};
 
   for (const auto &subDirectory: subDirectories)
   {
     currentHierarchy += subDirectory;
 
-    if (!ls::File::_exists(currentHierarchy))
+    if (!ls::std::io::File::_exists(currentHierarchy))
     {
-      ls::File::_mkdir(currentHierarchy);
+      ls::std::io::File::_mkdir(currentHierarchy);
     }
 
     currentHierarchy += separator;
   }
 }
 
-void ls::File::remove()
+void ls::std::io::File::remove()
 {
-  if (ls::File::_isFile(this->absoluteFilePath))
+  if (ls::std::io::File::_isFile(this->absoluteFilePath))
   {
     ::std::remove(this->absoluteFilePath.c_str());
   }
 
-  if (ls::File::_isDirectory(this->absoluteFilePath))
+  if (ls::std::io::File::_isDirectory(this->absoluteFilePath))
   {
-    ls::File::_remove(this->absoluteFilePath);
+    ls::std::io::File::_remove(this->absoluteFilePath);
   }
 }
 
-bool ls::File::renameTo(const ::std::string &_newName)
+bool ls::std::io::File::renameTo(const ::std::string &_newName)
 {
-  bool renamed = ls::File::_renameTo(this->absoluteFilePath, _newName);
+  bool renamed = ls::std::io::File::_renameTo(this->absoluteFilePath, _newName);
 
   if (renamed)
   {
@@ -235,16 +235,16 @@ bool ls::File::renameTo(const ::std::string &_newName)
   return renamed;
 }
 
-void ls::File::reset(const ::std::string &_newPath)
+void ls::std::io::File::reset(const ::std::string &_newPath)
 {
-  this->absoluteFilePath = ls::File::_normalizePath(_newPath);
+  this->absoluteFilePath = ls::std::io::File::_normalizePath(_newPath);
 }
 
 #ifdef _WIN32
 
-void ls::File::_addToFileListWindows(const std::string &_path, bool _withDirectories, WIN32_FIND_DATA _data, std::list<std::string> &_list)
+void ls::std::io::File::_addToFileListWindows(const std::string &_path, bool _withDirectories, WIN32_FIND_DATA _data, std::list<std::string> &_list)
 {
-  const char separator = ls::FilePathSeparator::get();
+  const char separator = ls::std::io::FilePathSeparator::get();
   std::string absolutePath = _path + separator + _data.cFileName;
 
   if (_withDirectories)
@@ -253,7 +253,7 @@ void ls::File::_addToFileListWindows(const std::string &_path, bool _withDirecto
   }
   else
   {
-    if (ls::File::_isFile(absolutePath))
+    if (ls::std::io::File::_isFile(absolutePath))
     {
       _list.emplace_back(absolutePath);
     }
@@ -264,9 +264,9 @@ void ls::File::_addToFileListWindows(const std::string &_path, bool _withDirecto
 
 #if defined(unix) || defined(__APPLE__)
 
-void ls::File::_addToFileListUnix(const ::std::string &_path, bool _withDirectories, dirent *directoryEntity, ::std::list<::std::string> &_list)
+void ls::std::io::File::_addToFileListUnix(const ::std::string &_path, bool _withDirectories, dirent *directoryEntity, ::std::list<::std::string> &_list)
 {
-  const char separator = ls::FilePathSeparator::get();
+  const char separator = ls::std::io::FilePathSeparator::get();
   ::std::string absolutePath = _path + separator + directoryEntity->d_name;
 
   if (_withDirectories)
@@ -275,7 +275,7 @@ void ls::File::_addToFileListUnix(const ::std::string &_path, bool _withDirector
   }
   else
   {
-    if (ls::File::_isFile(absolutePath))
+    if (ls::std::io::File::_isFile(absolutePath))
     {
       _list.emplace_back(absolutePath);
     }
@@ -284,7 +284,7 @@ void ls::File::_addToFileListUnix(const ::std::string &_path, bool _withDirector
 
 #endif
 
-bool ls::File::_equals(ls::File &_file, ls::File &_foreignFile)
+bool ls::std::io::File::_equals(ls::std::io::File &_file, ls::std::io::File &_foreignFile)
 {
   bool isEqual = _file.getAbsoluteFilePath() == _foreignFile.getAbsoluteFilePath();
 
@@ -298,17 +298,17 @@ bool ls::File::_equals(ls::File &_file, ls::File &_foreignFile)
   return isEqual;
 }
 
-bool ls::File::_exists(const ::std::string &_path)
+bool ls::std::io::File::_exists(const ::std::string &_path)
 {
   struct stat _stat{};
   return (stat(_path.c_str(), &_stat) == 0);
 }
 
-std::string ls::File::_getParent(const ::std::string &_path)
+std::string ls::std::io::File::_getParent(const ::std::string &_path)
 {
   ::std::string parent{};
-  ::std::vector<::std::string> subDirectoryNames = ls::File::_splitIntoSubDirectoryNames(_path);
-  const char separator = ls::FilePathSeparator::get();
+  ::std::vector<::std::string> subDirectoryNames = ls::std::io::File::_splitIntoSubDirectoryNames(_path);
+  const char separator = ls::std::io::FilePathSeparator::get();
   subDirectoryNames.pop_back();
 
   for (auto const &subDirectoryName: subDirectoryNames)
@@ -321,7 +321,7 @@ std::string ls::File::_getParent(const ::std::string &_path)
 
 #if defined(unix) || defined(__APPLE__)
 
-std::string ls::File::_getWorkingDirectoryUnix()
+std::string ls::std::io::File::_getWorkingDirectoryUnix()
 {
   ::std::string workingDirectory{};
   char buffer[PATH_MAX];
@@ -342,7 +342,7 @@ std::string ls::File::_getWorkingDirectoryUnix()
 
 #ifdef _WIN32
 
-std::string ls::File::_getWorkingDirectoryWindows()
+std::string ls::std::io::File::_getWorkingDirectoryWindows()
 {
   std::string workingDirectory{};
   TCHAR buffer[MAX_PATH];
@@ -361,7 +361,7 @@ std::string ls::File::_getWorkingDirectoryWindows()
 
 #endif
 
-bool ls::File::_isDirectory(const ::std::string &_path)
+bool ls::std::io::File::_isDirectory(const ::std::string &_path)
 {
   bool match{};
   struct stat _stat{};
@@ -374,11 +374,11 @@ bool ls::File::_isDirectory(const ::std::string &_path)
   return match;
 }
 
-bool ls::File::_isExecutable(const ::std::string &_path)
+bool ls::std::io::File::_isExecutable(const ::std::string &_path)
 {
   bool executable{};
 
-  if (ls::File::_exists(_path))
+  if (ls::std::io::File::_exists(_path))
   {
     struct stat _stat{};
 
@@ -391,7 +391,7 @@ bool ls::File::_isExecutable(const ::std::string &_path)
   return executable;
 }
 
-bool ls::File::_isFile(const ::std::string &_path)
+bool ls::std::io::File::_isFile(const ::std::string &_path)
 {
   bool match{};
   struct stat _stat{};
@@ -406,11 +406,11 @@ bool ls::File::_isFile(const ::std::string &_path)
 
 #if defined(unix) || defined(__APPLE__)
 
-bool ls::File::_isReadableUnix(const ::std::string &_path)
+bool ls::std::io::File::_isReadableUnix(const ::std::string &_path)
 {
   bool readable{};
 
-  if (ls::File::_exists(_path))
+  if (ls::std::io::File::_exists(_path))
   {
     struct stat _stat{};
 
@@ -431,7 +431,7 @@ bool ls::File::_isReadableUnix(const ::std::string &_path)
 
 #ifdef _WIN32
 
-bool ls::File::_isReadableWindows(const std::string &_path)
+bool ls::std::io::File::_isReadableWindows(const std::string &_path)
 {
   bool readable;
   WIN32_FIND_DATA data{};
@@ -451,11 +451,11 @@ bool ls::File::_isReadableWindows(const std::string &_path)
 
 #endif
 
-bool ls::File::_isWritable(const ::std::string &_path)
+bool ls::std::io::File::_isWritable(const ::std::string &_path)
 {
   bool writable{};
 
-  if (ls::File::_exists(_path))
+  if (ls::std::io::File::_exists(_path))
   {
     struct stat _stat{};
 
@@ -468,7 +468,7 @@ bool ls::File::_isWritable(const ::std::string &_path)
   return writable;
 }
 
-time_t ls::File::_lastModified(const ::std::string &_path)
+time_t ls::std::io::File::_lastModified(const ::std::string &_path)
 {
   time_t lastModifiedTimeStamp{};
   struct stat _stat{};
@@ -481,29 +481,29 @@ time_t ls::File::_lastModified(const ::std::string &_path)
   return lastModifiedTimeStamp;
 }
 
-std::list<std::string> ls::File::_list(const ::std::string &_path)
+std::list<std::string> ls::std::io::File::_list(const ::std::string &_path)
 {
   ::std::list<::std::string> filesInDirectory{};
 
   #if defined(unix) || defined(__APPLE__)
-  filesInDirectory = ls::File::_listUnix(_path, true);
+  filesInDirectory = ls::std::io::File::_listUnix(_path, true);
   #endif
   #ifdef _WIN32
-  filesInDirectory = ls::File::_listWindows(_path, true);
+  filesInDirectory = ls::std::io::File::_listWindows(_path, true);
   #endif
 
   return filesInDirectory;
 }
 
-std::list<std::string> ls::File::_listFiles(const ::std::string &_path)
+std::list<std::string> ls::std::io::File::_listFiles(const ::std::string &_path)
 {
   ::std::list<::std::string> filesInDirectory{};
 
   #if defined(unix) || defined(__APPLE__)
-  filesInDirectory = ls::File::_listUnix(_path, false);
+  filesInDirectory = ls::std::io::File::_listUnix(_path, false);
   #endif
   #ifdef _WIN32
-  filesInDirectory = ls::File::_listWindows(_path, false);
+  filesInDirectory = ls::std::io::File::_listWindows(_path, false);
   #endif
 
   return filesInDirectory;
@@ -511,7 +511,7 @@ std::list<std::string> ls::File::_listFiles(const ::std::string &_path)
 
 #if defined(unix) || defined(__APPLE__)
 
-std::list<std::string> ls::File::_listUnix(const ::std::string &_path, bool withDirectories)
+std::list<std::string> ls::std::io::File::_listUnix(const ::std::string &_path, bool withDirectories)
 {
   ::std::list<::std::string> filesInDirectory{};
   DIR *directory = opendir(_path.c_str());
@@ -520,7 +520,7 @@ std::list<std::string> ls::File::_listUnix(const ::std::string &_path, bool with
 
   while ((directoryEntity = readdir(directory)) != nullptr)
   {
-    ls::File::_addToFileListUnix(_path, withDirectories, directoryEntity, filesInDirectory);
+    ls::std::io::File::_addToFileListUnix(_path, withDirectories, directoryEntity, filesInDirectory);
   }
 
   closedir(directory);
@@ -531,18 +531,18 @@ std::list<std::string> ls::File::_listUnix(const ::std::string &_path, bool with
 
 #ifdef _WIN32
 
-std::list<std::string> ls::File::_listWindows(const std::string &_path, bool withDirectories)
+std::list<std::string> ls::std::io::File::_listWindows(const std::string &_path, bool withDirectories)
 {
   std::list<std::string> filesInDirectory{};
   WIN32_FIND_DATA data{};
   HANDLE hFind;
-  std::string pattern{_path + ls::FilePathSeparator::get() + "*"};
+  std::string pattern{_path + ls::std::io::FilePathSeparator::get() + "*"};
 
   if ((hFind = FindFirstFile(pattern.c_str(), &data)) != INVALID_HANDLE_VALUE)
   {
     do
     {
-      ls::File::_addToFileListWindows(_path, withDirectories, data, filesInDirectory);
+      ls::std::io::File::_addToFileListWindows(_path, withDirectories, data, filesInDirectory);
     } while (FindNextFile(hFind, &data) != 0);
 
     FindClose(hFind);
@@ -553,7 +553,7 @@ std::list<std::string> ls::File::_listWindows(const std::string &_path, bool wit
 
 #endif
 
-int ls::File::_mkdir(const ::std::string &_path)
+int ls::std::io::File::_mkdir(const ::std::string &_path)
 {
   int result;
 
@@ -568,17 +568,17 @@ int ls::File::_mkdir(const ::std::string &_path)
   return result;
 }
 
-std::string ls::File::_normalizePath(::std::string _path)
+std::string ls::std::io::File::_normalizePath(::std::string _path)
 {
-  _path = ls::File::_replaceWrongSeparator(_path);
-  _path = ls::File::_reduceSeparators(_path);
+  _path = ls::std::io::File::_replaceWrongSeparator(_path);
+  _path = ls::std::io::File::_reduceSeparators(_path);
 
   return _path;
 }
 
-std::string ls::File::_reduceSeparators(const ::std::string &_path)
+std::string ls::std::io::File::_reduceSeparators(const ::std::string &_path)
 {
-  static const char separator = {ls::FilePathSeparator::get()};
+  static const char separator = {ls::std::io::FilePathSeparator::get()};
   ::std::string normalizedPath{};
   int index{};
 
@@ -603,19 +603,19 @@ std::string ls::File::_reduceSeparators(const ::std::string &_path)
   return normalizedPath;
 }
 
-void ls::File::_remove(const ::std::string &_path)
+void ls::std::io::File::_remove(const ::std::string &_path)
 {
   #if defined(unix) || defined(__APPLE__)
-  ls::File::_removeUnix(_path);
+  ls::std::io::File::_removeUnix(_path);
   #endif
   #ifdef _WIN32
-  ls::File::_removeWindows(_path);
+  ls::std::io::File::_removeWindows(_path);
   #endif
 }
 
 #if defined(unix) || defined(__APPLE__)
 
-void ls::File::_removeUnix(const ::std::string &_path)
+void ls::std::io::File::_removeUnix(const ::std::string &_path)
 {
   rmdir(_path.c_str());
 }
@@ -624,22 +624,22 @@ void ls::File::_removeUnix(const ::std::string &_path)
 
 #ifdef _WIN32
 
-void ls::File::_removeWindows(const std::string &_path)
+void ls::std::io::File::_removeWindows(const std::string &_path)
 {
   _rmdir(_path.c_str());
 }
 
 #endif
 
-bool ls::File::_renameTo(const ::std::string &_oldName, const ::std::string &_newName)
+bool ls::std::io::File::_renameTo(const ::std::string &_oldName, const ::std::string &_newName)
 {
   return ::std::rename(_oldName.c_str(), _newName.c_str()) == 0;
 }
 
-std::string ls::File::_replaceWrongSeparator(::std::string _path)
+std::string ls::std::io::File::_replaceWrongSeparator(::std::string _path)
 {
-  static const char unixSeparator = ls::FilePathSeparator::getUnixFilePathSeparator();
-  static const char windowsSeparator = ls::FilePathSeparator::getWindowsFilePathSeparator();
+  static const char unixSeparator = ls::std::io::FilePathSeparator::getUnixFilePathSeparator();
+  static const char windowsSeparator = ls::std::io::FilePathSeparator::getWindowsFilePathSeparator();
 
   #if defined(unix) || defined(__APPLE__)
   ::std::replace(_path.begin(), _path.end(), windowsSeparator, unixSeparator);
@@ -652,12 +652,12 @@ std::string ls::File::_replaceWrongSeparator(::std::string _path)
   return _path;
 }
 
-std::vector<std::string> ls::File::_splitIntoSubDirectoryNames(const ::std::string &_path)
+std::vector<std::string> ls::std::io::File::_splitIntoSubDirectoryNames(const ::std::string &_path)
 {
   ::std::vector<::std::string> subDirectoryNames{};
   ::std::stringstream _stream{_path};
   ::std::string subDirectoryName{};
-  const char separator = ls::FilePathSeparator::get();
+  const char separator = ls::std::io::FilePathSeparator::get();
 
   while (::std::getline(_stream, subDirectoryName, separator))
   {

source/ls_std/io/FileOutputStream.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -11,14 +11,14 @@
 #include <ls_std/core/exception/FileNotFoundException.hpp>
 #include <ls_std/core/exception/FileOperationException.hpp>
 
-ls::FileOutputStream::FileOutputStream(ls::File &_file)
+ls::std::io::FileOutputStream::FileOutputStream(ls::std::io::File &_file)
     : ls::std::core::Class("FileOutputStream"),
       file(_file)
 {
   this->_init();
 }
 
-ls::FileOutputStream::FileOutputStream(ls::File &_file, bool _append)
+ls::std::io::FileOutputStream::FileOutputStream(ls::std::io::File &_file, bool _append)
     : ls::std::core::Class("FileOutputStream"),
       append(_append),
       file(_file)
@@ -26,17 +26,17 @@ ls::FileOutputStream::FileOutputStream(ls::File &_file, bool _append)
   this->_init();
 }
 
-ls::FileOutputStream::~FileOutputStream()
+ls::std::io::FileOutputStream::~FileOutputStream()
 {
   this->_close();
 }
 
-void ls::FileOutputStream::close()
+void ls::std::io::FileOutputStream::close()
 {
   this->_close();
 }
 
-bool ls::FileOutputStream::write(const ls::std::core::byte_field &_data)
+bool ls::std::io::FileOutputStream::write(const ls::std::core::byte_field &_data)
 {
   bool succeeded{};
 
@@ -55,7 +55,7 @@ bool ls::FileOutputStream::write(const ls::std::core::byte_field &_data)
   return succeeded;
 }
 
-void ls::FileOutputStream::_close()
+void ls::std::io::FileOutputStream::_close()
 {
   if (this->outputStream.is_open())
   {
@@ -63,7 +63,7 @@ void ls::FileOutputStream::_close()
   }
 }
 
-void ls::FileOutputStream::_init()
+void ls::std::io::FileOutputStream::_init()
 {
   if (!this->file.exists())
   {

source/ls_std/io/FileReader.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -12,14 +12,14 @@
 #include <ls_std/core/exception/FileNotFoundException.hpp>
 #include <ls_std/core/exception/FileOperationException.hpp>
 
-ls::FileReader::FileReader(ls::File &_file)
+ls::std::io::FileReader::FileReader(ls::std::io::File &_file)
     : ls::std::core::Class("FileReader"),
       file(_file)
 {
-  ls::FileReader::_init(_file);
+  ls::std::io::FileReader::_init(_file);
 }
 
-ls::std::core::byte_field ls::FileReader::read()
+ls::std::core::byte_field ls::std::io::FileReader::read()
 {
   ls::std::core::byte *data;
   ::std::ifstream inputStream{this->file.getAbsoluteFilePath(), ::std::ifstream::binary};
@@ -39,13 +39,13 @@ ls::std::core::byte_field ls::FileReader::read()
   return readData;
 }
 
-void ls::FileReader::reset(ls::File &_file)
+void ls::std::io::FileReader::reset(ls::std::io::File &_file)
 {
-  ls::FileReader::_init(_file);
+  ls::std::io::FileReader::_init(_file);
   this->file = _file;
 }
 
-void ls::FileReader::_init(ls::File &_file)
+void ls::std::io::FileReader::_init(ls::std::io::File &_file)
 {
   if (!_file.exists())
   {

source/ls_std/io/FileWriter.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -12,20 +12,20 @@
 #include <ls_std/core/exception/FileNotFoundException.hpp>
 #include <ls_std/core/exception/FileOperationException.hpp>
 
-ls::FileWriter::FileWriter(ls::File &_file)
+ls::std::io::FileWriter::FileWriter(ls::std::io::File &_file)
     : ls::std::core::Class("FileWriter"),
       file(_file)
 {
-  ls::FileWriter::_init(_file);
+  ls::std::io::FileWriter::_init(_file);
 }
 
-void ls::FileWriter::reset(ls::File &_file)
+void ls::std::io::FileWriter::reset(ls::std::io::File &_file)
 {
-  ls::FileWriter::_init(_file);
+  ls::std::io::FileWriter::_init(_file);
   this->file = _file;
 }
 
-bool ls::FileWriter::write(const ls::std::core::byte_field &_data)
+bool ls::std::io::FileWriter::write(const ls::std::core::byte_field &_data)
 {
   ::std::ofstream outputStream{};
   outputStream.open(this->file.getAbsoluteFilePath());
@@ -34,7 +34,7 @@ bool ls::FileWriter::write(const ls::std::core::byte_field &_data)
   return !outputStream.fail();
 }
 
-void ls::FileWriter::_init(ls::File &_file)
+void ls::std::io::FileWriter::_init(ls::std::io::File &_file)
 {
   if (!_file.exists())
   {

source/ls_std/io/StandardOutputWriter.cpp

@@ -3,14 +3,14 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-06
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
 #include <iostream>
 #include <ls_std/io/StandardOutputWriter.hpp>
 
-bool ls::StandardOutputWriter::write(const ls::std::core::byte_field &_data)
+bool ls::std::io::StandardOutputWriter::write(const ls::std::core::byte_field &_data)
 {
   ::std::cout << _data;
   return !::std::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:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -11,38 +11,38 @@
 #include <ls_std/io/FileReader.hpp>
 #include <ls_std/io/FileWriter.hpp>
 
-ls::StorableFile::StorableFile(const ::std::string &_path)
+ls::std::io::StorableFile::StorableFile(const ::std::string &_path)
 {
   this->_init(_path);
 }
 
-std::shared_ptr<ls::File> ls::StorableFile::getFile()
+std::shared_ptr<ls::std::io::File> ls::std::io::StorableFile::getFile()
 {
   return this->file;
 }
 
-ls::std::core::byte_field ls::StorableFile::load()
+ls::std::core::byte_field ls::std::io::StorableFile::load()
 {
-  ls::FileReader reader{*this->file};
+  ls::std::io::FileReader reader{*this->file};
   return reader.read();
 }
 
-void ls::StorableFile::reset(const ::std::string &_path)
+void ls::std::io::StorableFile::reset(const ::std::string &_path)
 {
   this->_init(_path);
 }
 
-void ls::StorableFile::save(const ls::std::core::byte_field &_data)
+void ls::std::io::StorableFile::save(const ls::std::core::byte_field &_data)
 {
-  ls::FileWriter writer{*this->file};
+  ls::std::io::FileWriter writer{*this->file};
   writer.write(_data);
 }
 
-void ls::StorableFile::_init(const ::std::string &_path)
+void ls::std::io::StorableFile::_init(const ::std::string &_path)
 {
   if (this->file == nullptr)
   {
-    this->file = ::std::make_shared<ls::File>(_path);
+    this->file = ::std::make_shared<ls::std::io::File>(_path);
   }
   else
   {

source/ls_std/io/kv/KvDocument.cpp

@@ -3,49 +3,49 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
 #include <ls_std/io/kv/KvDocument.hpp>
 
-ls::KvDocument::KvDocument() : ls::std::core::Class("KvDocument")
+ls::std::io::KvDocument::KvDocument() : ls::std::core::Class("KvDocument")
 {}
 
-bool ls::KvDocument::addPair(ls::KvPair _pair)
+bool ls::std::io::KvDocument::addPair(ls::std::io::KvPair _pair)
 {
   bool added{};
 
   if (!this->_hasPair(_pair.getKey()))
   {
-    ::std::pair<ls::kv_key, ls::KvPair> pair = ::std::make_pair(_pair.getKey(), _pair);
+    ::std::pair<ls::std::io::kv_key, ls::std::io::KvPair> pair = ::std::make_pair(_pair.getKey(), _pair);
     added = this->pairs.insert(pair).second;
   }
 
   return added;
 }
 
-void ls::KvDocument::clear()
+void ls::std::io::KvDocument::clear()
 {
   this->pairs.clear();
 }
 
-std::map<ls::kv_key, ls::KvPair> ls::KvDocument::getPairs()
+std::map<ls::std::io::kv_key, ls::std::io::KvPair> ls::std::io::KvDocument::getPairs()
 {
   return this->pairs;
 }
 
-bool ls::KvDocument::hasPair(const ls::kv_key &_key)
+bool ls::std::io::KvDocument::hasPair(const ls::std::io::kv_key &_key)
 {
   return this->_hasPair(_key);
 }
 
-bool ls::KvDocument::removePair(const ls::kv_key &_key)
+bool ls::std::io::KvDocument::removePair(const ls::std::io::kv_key &_key)
 {
   return this->pairs.erase(_key) == 1;
 }
 
-bool ls::KvDocument::_hasPair(const ls::kv_key &_key)
+bool ls::std::io::KvDocument::_hasPair(const ls::std::io::kv_key &_key)
 {
   return this->pairs.find(_key) != this->pairs.end();
 }

source/ls_std/io/kv/KvFileReader.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -12,38 +12,38 @@
 #include <ls_std/io/FileReader.hpp>
 #include <ls_std/io/kv/KvParser.hpp>
 
-ls::KvFileReader::KvFileReader(const ::std::shared_ptr<ls::KvDocument> &_document, const ::std::string &_absolutePath)
+ls::std::io::KvFileReader::KvFileReader(const ::std::shared_ptr<ls::std::io::KvDocument> &_document, const ::std::string &_absolutePath)
     : ls::std::core::Class("KvFileReader"),
-      kvFile(ls::File{""})
+      kvFile(ls::std::io::File{""})
 {
   this->_assignDocument(_document);
-  this->_assignFile(ls::File{_absolutePath});
+  this->_assignFile(ls::std::io::File{_absolutePath});
 }
 
-ls::std::core::byte_field ls::KvFileReader::read()
+ls::std::core::byte_field ls::std::io::KvFileReader::read()
 {
-  ls::std::core::byte_field data = ls::FileReader{this->kvFile}.read();
-  ls::KvParser{this->document}.parse(data);
+  ls::std::core::byte_field data = ls::std::io::FileReader{this->kvFile}.read();
+  ls::std::io::KvParser{this->document}.parse(data);
 
   return data;
 }
 
-std::shared_ptr<ls::KvDocument> ls::KvFileReader::getDocument()
+std::shared_ptr<ls::std::io::KvDocument> ls::std::io::KvFileReader::getDocument()
 {
   return this->document;
 }
 
-void ls::KvFileReader::setDocument(const ::std::shared_ptr<ls::KvDocument> &_document)
+void ls::std::io::KvFileReader::setDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-void ls::KvFileReader::setFile(const ls::File &_kvFile)
+void ls::std::io::KvFileReader::setFile(const ls::std::io::File &_kvFile)
 {
   this->_assignFile(_kvFile);
 }
 
-void ls::KvFileReader::_assignDocument(const ::std::shared_ptr<ls::KvDocument> &_document)
+void ls::std::io::KvFileReader::_assignDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document)
 {
   if (_document == nullptr)
   {
@@ -53,7 +53,7 @@ void ls::KvFileReader::_assignDocument(const ::std::shared_ptr<ls::KvDocument> &
   this->document = _document;
 }
 
-void ls::KvFileReader::_assignFile(ls::File _kvFile)
+void ls::std::io::KvFileReader::_assignFile(ls::std::io::File _kvFile)
 {
   if (!_kvFile.exists())
   {

source/ls_std/io/kv/KvPair.cpp

@@ -3,36 +3,36 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
 #include <ls_std/io/kv/KvPair.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::KvPair::KvPair(const ls::kv_key &_key, ls::kv_value _value)
+ls::std::io::KvPair::KvPair(const ls::std::io::kv_key &_key, ls::std::io::kv_value _value)
     : ls::std::core::Class("KvPair"),
       value(::std::move(_value))
 {
   this->_assignKey(_key);
 }
 
-ls::kv_key ls::KvPair::getKey()
+ls::std::io::kv_key ls::std::io::KvPair::getKey()
 {
   return this->key;
 }
 
-ls::kv_value ls::KvPair::getValue()
+ls::std::io::kv_value ls::std::io::KvPair::getValue()
 {
   return this->value;
 }
 
-void ls::KvPair::setValue(const ls::kv_value &_value)
+void ls::std::io::KvPair::setValue(const ls::std::io::kv_value &_value)
 {
   this->value = _value;
 }
 
-void ls::KvPair::_assignKey(const ls::kv_key &_key)
+void ls::std::io::KvPair::_assignKey(const ls::std::io::kv_key &_key)
 {
   if (_key.empty())
   {

source/ls_std/io/kv/KvParser.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -11,27 +11,27 @@
 #include <ls_std/io/NewLine.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::KvParser::KvParser(const ::std::shared_ptr<ls::KvDocument> &_document) : ls::std::core::Class("KvParser")
+ls::std::io::KvParser::KvParser(const ::std::shared_ptr<ls::std::io::KvDocument> &_document) : ls::std::core::Class("KvParser")
 {
   this->_assignDocument(_document);
 }
 
-std::shared_ptr<ls::KvDocument> ls::KvParser::getDocument()
+std::shared_ptr<ls::std::io::KvDocument> ls::std::io::KvParser::getDocument()
 {
   return this->document;
 }
 
-void ls::KvParser::parse(const ls::std::core::byte_field &_data)
+void ls::std::io::KvParser::parse(const ls::std::core::byte_field &_data)
 {
   this->_parse(_data);
 }
 
-void ls::KvParser::setDocument(const ::std::shared_ptr<ls::KvDocument> &_document)
+void ls::std::io::KvParser::setDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-void ls::KvParser::_assignDocument(const ::std::shared_ptr<ls::KvDocument> &_document)
+void ls::std::io::KvParser::_assignDocument(const ::std::shared_ptr<ls::std::io::KvDocument> &_document)
 {
   if (_document == nullptr)
   {
@@ -41,48 +41,48 @@ void ls::KvParser::_assignDocument(const ::std::shared_ptr<ls::KvDocument> &_doc
   this->document = _document;
 }
 
-bool ls::KvParser::_lineHasPair(ls::KvParseParameter _parseParameter)
+bool ls::std::io::KvParser::_lineHasPair(ls::std::io::KvParseParameter _parseParameter)
 {
   return _parseParameter.line.contains("=") && _parseParameter.line.contains(";");
 }
 
-void ls::KvParser::_parse(const ls::std::core::byte_field &_data)
+void ls::std::io::KvParser::_parse(const ls::std::core::byte_field &_data)
 {
   for (::std::string::size_type index = 0; index < _data.size(); index++)
   {
-    ls::KvParseParameter parseParameter = ls::KvParser::_readLine(_data, index);
+    ls::std::io::KvParseParameter parseParameter = ls::std::io::KvParser::_readLine(_data, index);
     this->_parsePair(parseParameter);
     index = parseParameter.index;
   }
 }
 
-void ls::KvParser::_parsePair(ls::KvParseParameter _parseParameter)
+void ls::std::io::KvParser::_parsePair(ls::std::io::KvParseParameter _parseParameter)
 {
-  if (ls::KvParser::_lineHasPair(_parseParameter))
+  if (ls::std::io::KvParser::_lineHasPair(_parseParameter))
   {
     size_t equalSignPosition = _parseParameter.line.toString().find('=');
-    ls::kv_key key = _parseParameter.line.toString().substr(0, equalSignPosition);
-    ls::kv_value value = _parseParameter.line.toString().substr(equalSignPosition + 1);
+    ls::std::io::kv_key key = _parseParameter.line.toString().substr(0, equalSignPosition);
+    ls::std::io::kv_value value = _parseParameter.line.toString().substr(equalSignPosition + 1);
     value = value.substr(0, value.find(';'));
 
-    this->document->addPair(ls::KvPair{key, value});
+    this->document->addPair(ls::std::io::KvPair{key, value});
   }
 }
 
-ls::KvParseParameter ls::KvParser::_readLine(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+ls::std::io::KvParseParameter ls::std::io::KvParser::_readLine(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
 {
-  ls::KvParseParameter parseParameter{};
+  ls::std::io::KvParseParameter parseParameter{};
   parseParameter.line = _data.substr(_index);
 
-  if (parseParameter.line.contains(ls::NewLine::getWindowsNewLine()))
+  if (parseParameter.line.contains(ls::std::io::NewLine::getWindowsNewLine()))
   {
-    ls::KvParser::_readLineWithWindowsLineBreak(parseParameter);
+    ls::std::io::KvParser::_readLineWithWindowsLineBreak(parseParameter);
   }
   else
   {
-    if (parseParameter.line.contains(ls::NewLine::getUnixNewLine()))
+    if (parseParameter.line.contains(ls::std::io::NewLine::getUnixNewLine()))
     {
-      ls::KvParser::_readLineWithUnixLineBreak(parseParameter);
+      ls::std::io::KvParser::_readLineWithUnixLineBreak(parseParameter);
     }
   }
 
@@ -90,14 +90,14 @@ ls::KvParseParameter ls::KvParser::_readLine(const ls::std::core::byte_field &_d
   return parseParameter;
 }
 
-void ls::KvParser::_readLineWithUnixLineBreak(ls::KvParseParameter &_parseParameter)
+void ls::std::io::KvParser::_readLineWithUnixLineBreak(ls::std::io::KvParseParameter &_parseParameter)
 {
-  size_t newLinePosition = _parseParameter.line.toString().find(ls::NewLine::getUnixNewLine());
+  size_t newLinePosition = _parseParameter.line.toString().find(ls::std::io::NewLine::getUnixNewLine());
   _parseParameter.line = _parseParameter.line.toString().substr(0, newLinePosition);
 }
 
-void ls::KvParser::_readLineWithWindowsLineBreak(ls::KvParseParameter &_parseParameter)
+void ls::std::io::KvParser::_readLineWithWindowsLineBreak(ls::std::io::KvParseParameter &_parseParameter)
 {
-  size_t newLinePosition = _parseParameter.line.toString().find(ls::NewLine::getWindowsNewLine());
+  size_t newLinePosition = _parseParameter.line.toString().find(ls::std::io::NewLine::getWindowsNewLine());
   _parseParameter.line = _parseParameter.line.toString().substr(0, newLinePosition + 1);
 }

source/ls_std/io/logging/LogLevel.cpp

@@ -3,67 +3,67 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
 #include <ls_std/io/logging/LogLevel.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::LogLevel::LogLevel(const ls::LogLevelValue &_value)
+ls::std::io::LogLevel::LogLevel(const ls::std::io::LogLevelValue &_value)
     : ls::std::core::Class("LogLevel"),
       value(_value)
 {
   this->_init();
 }
 
-ls::LogLevel::LogLevel() : ls::std::core::Class("LogLevel")
+ls::std::io::LogLevel::LogLevel() : ls::std::core::Class("LogLevel")
 {
   this->_init();
 }
 
-ls::LogLevel::operator unsigned char() const
+ls::std::io::LogLevel::operator unsigned char() const
 {
   return this->value;
 }
 
-ls::LogLevel &ls::LogLevel::operator=(const ls::LogLevelValue &_value)
+ls::std::io::LogLevel &ls::std::io::LogLevel::operator=(const ls::std::io::LogLevelValue &_value)
 {
   this->value = _value;
   return *this;
 }
 
-bool ls::LogLevel::operator<(const ls::LogLevelValue &_value)
+bool ls::std::io::LogLevel::operator<(const ls::std::io::LogLevelValue &_value)
 {
   return this->value < _value;
 }
 
-bool ls::LogLevel::operator<=(const ls::LogLevelValue &_value)
+bool ls::std::io::LogLevel::operator<=(const ls::std::io::LogLevelValue &_value)
 {
   return this->value <= _value;
 }
 
-bool ls::LogLevel::operator>(const ls::LogLevelValue &_value)
+bool ls::std::io::LogLevel::operator>(const ls::std::io::LogLevelValue &_value)
 {
   return this->value > _value;
 }
 
-bool ls::LogLevel::operator>=(const ls::LogLevelValue &_value)
+bool ls::std::io::LogLevel::operator>=(const ls::std::io::LogLevelValue &_value)
 {
   return this->value >= _value;
 }
 
-bool ls::LogLevel::operator==(const ls::LogLevelValue &_value)
+bool ls::std::io::LogLevel::operator==(const ls::std::io::LogLevelValue &_value)
 {
   return this->value == _value;
 }
 
-void ls::LogLevel::setLogLevel(const ls::LogLevelValue &_value)
+void ls::std::io::LogLevel::setLogLevel(const ls::std::io::LogLevelValue &_value)
 {
   this->value = _value;
 }
 
-void ls::LogLevel::setLogLevel(const ::std::string &_value)
+void ls::std::io::LogLevel::setLogLevel(const ::std::string &_value)
 {
   if (this->_isValidLogLevelString(_value))
   {
@@ -75,20 +75,20 @@ void ls::LogLevel::setLogLevel(const ::std::string &_value)
   }
 }
 
-std::string ls::LogLevel::toString() const
+std::string ls::std::io::LogLevel::toString() const
 {
   return this->level.at(this->value);
 }
 
-ls::LogLevelValue ls::LogLevel::_getValueFromString(const ::std::string &_value)
+ls::std::io::LogLevelValue ls::std::io::LogLevel::_getValueFromString(const ::std::string &_value)
 {
-  ls::LogLevelValue logLevelValue{};
+  ls::std::io::LogLevelValue logLevelValue{};
 
   for (const auto &logLevelString : this->level)
   {
     if (logLevelString.second == _value)
     {
-      logLevelValue = (ls::LogLevelValue) logLevelString.first;
+      logLevelValue = (ls::std::io::LogLevelValue) logLevelString.first;
       break;
     }
   }
@@ -96,17 +96,17 @@ ls::LogLevelValue ls::LogLevel::_getValueFromString(const ::std::string &_value)
   return logLevelValue;
 }
 
-void ls::LogLevel::_init()
+void ls::std::io::LogLevel::_init()
 {
-  this->level.insert({ls::LogLevelValue::FATAL, "FATAL"});
-  this->level.insert({ls::LogLevelValue::ERR, "ERROR"});
-  this->level.insert({ls::LogLevelValue::WARN, "WARN"});
-  this->level.insert({ls::LogLevelValue::INFO, "INFO"});
-  this->level.insert({ls::LogLevelValue::DEBUG, "DEBUG"});
-  this->level.insert({ls::LogLevelValue::TRACE, "TRACE"});
+  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"});
 }
 
-bool ls::LogLevel::_isValidLogLevelString(const ::std::string &_value)
+bool ls::std::io::LogLevel::_isValidLogLevelString(const ::std::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:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -13,72 +13,72 @@
 #include <ls_std/boxing/String.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::Logger::Logger(const ::std::shared_ptr<ls::IWriter> &_writer)
+ls::std::io::Logger::Logger(const ::std::shared_ptr<ls::std::io::IWriter> &_writer)
     : ls::std::core::Class("Logger"),
-      logLevel(ls::LogLevelValue::INFO)
+      logLevel(ls::std::io::LogLevelValue::INFO)
 {
   this->_assignWriter(_writer);
 }
 
-void ls::Logger::debug(const ls::std::core::byte *_data)
+void ls::std::io::Logger::debug(const ls::std::core::byte *_data)
 {
-  if (this->logLevel >= ls::LogLevelValue::DEBUG)
+  if (this->logLevel >= ls::std::io::LogLevelValue::DEBUG)
   {
-    this->_log(_data, ls::LogLevel(ls::LogLevelValue::DEBUG));
+    this->_log(_data, ls::std::io::LogLevel(ls::std::io::LogLevelValue::DEBUG));
   }
 }
 
-void ls::Logger::error(const ls::std::core::byte *_data)
+void ls::std::io::Logger::error(const ls::std::core::byte *_data)
 {
-  if (this->logLevel >= ls::LogLevelValue::ERR)
+  if (this->logLevel >= ls::std::io::LogLevelValue::ERR)
   {
-    this->_log(_data, ls::LogLevel(ls::LogLevelValue::ERR));
+    this->_log(_data, ls::std::io::LogLevel(ls::std::io::LogLevelValue::ERR));
   }
 }
 
-void ls::Logger::fatal(const ls::std::core::byte *_data)
+void ls::std::io::Logger::fatal(const ls::std::core::byte *_data)
 {
-  if (this->logLevel >= ls::LogLevelValue::FATAL)
+  if (this->logLevel >= ls::std::io::LogLevelValue::FATAL)
   {
-    this->_log(_data, ls::LogLevel(ls::LogLevelValue::FATAL));
+    this->_log(_data, ls::std::io::LogLevel(ls::std::io::LogLevelValue::FATAL));
   }
 }
 
-ls::LogLevel ls::Logger::getLogLevel()
+ls::std::io::LogLevel ls::std::io::Logger::getLogLevel()
 {
   return this->logLevel;
 }
 
-void ls::Logger::info(const ls::std::core::byte *_data)
+void ls::std::io::Logger::info(const ls::std::core::byte *_data)
 {
-  if (this->logLevel >= ls::LogLevelValue::INFO)
+  if (this->logLevel >= ls::std::io::LogLevelValue::INFO)
   {
-    this->_log(_data, ls::LogLevel(ls::LogLevelValue::INFO));
+    this->_log(_data, ls::std::io::LogLevel(ls::std::io::LogLevelValue::INFO));
   }
 }
 
-void ls::Logger::setLogLevel(const ls::LogLevelValue &_logLevelValue)
+void ls::std::io::Logger::setLogLevel(const ls::std::io::LogLevelValue &_logLevelValue)
 {
   this->logLevel = _logLevelValue;
 }
 
-void ls::Logger::trace(const ls::std::core::byte *_data)
+void ls::std::io::Logger::trace(const ls::std::core::byte *_data)
 {
-  if (this->logLevel >= ls::LogLevelValue::TRACE)
+  if (this->logLevel >= ls::std::io::LogLevelValue::TRACE)
   {
-    this->_log(_data, ls::LogLevel(ls::LogLevelValue::TRACE));
+    this->_log(_data, ls::std::io::LogLevel(ls::std::io::LogLevelValue::TRACE));
   }
 }
 
-void ls::Logger::warn(const ls::std::core::byte *_data)
+void ls::std::io::Logger::warn(const ls::std::core::byte *_data)
 {
-  if (this->logLevel >= ls::LogLevelValue::WARN)
+  if (this->logLevel >= ls::std::io::LogLevelValue::WARN)
   {
-    this->_log(_data, ls::LogLevel(ls::LogLevelValue::WARN));
+    this->_log(_data, ls::std::io::LogLevel(ls::std::io::LogLevelValue::WARN));
   }
 }
 
-void ls::Logger::_assignWriter(const ::std::shared_ptr<ls::IWriter> &_writer)
+void ls::std::io::Logger::_assignWriter(const ::std::shared_ptr<ls::std::io::IWriter> &_writer)
 {
   if (_writer == nullptr)
   {
@@ -88,9 +88,9 @@ void ls::Logger::_assignWriter(const ::std::shared_ptr<ls::IWriter> &_writer)
   this->writer = _writer;
 }
 
-void ls::Logger::_log(const ls::std::core::byte *_data, const ls::LogLevel &_logLevel)
+void ls::std::io::Logger::_log(const ls::std::core::byte *_data, const ls::std::io::LogLevel &_logLevel)
 {
   ls::std::time::Date date{};
-  ::std::string message = "[" + date.toString() + "] " + ls::std::boxing::String{_logLevel.toString() + ":"}.padRight(10, ' ') + ::std::string(_data) + ls::NewLine::getUnixNewLine();
+  ::std::string message = "[" + date.toString() + "] " + ls::std::boxing::String{_logLevel.toString() + ":"}.padRight(10, ' ') + ::std::string(_data) + ls::std::io::NewLine::getUnixNewLine();
   this->writer->write(message);
 }

source/ls_std/io/xml/XmlAttribute.cpp

@@ -3,44 +3,44 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-23
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
 #include <ls_std/io/xml/XmlAttribute.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::XmlAttribute::XmlAttribute(const ::std::string& _name) : ls::std::core::Class("XmlAttribute")
+ls::std::io::XmlAttribute::XmlAttribute(const ::std::string& _name) : ls::std::core::Class("XmlAttribute")
 {
   this->_assignName(_name);
 }
 
-std::string ls::XmlAttribute::getName()
+std::string ls::std::io::XmlAttribute::getName()
 {
   return this->name;
 }
 
-std::string ls::XmlAttribute::getValue()
+std::string ls::std::io::XmlAttribute::getValue()
 {
   return this->value;
 }
 
-void ls::XmlAttribute::setName(const ::std::string& _name)
+void ls::std::io::XmlAttribute::setName(const ::std::string& _name)
 {
   this->_assignName(_name);
 }
 
-void ls::XmlAttribute::setValue(const ::std::string& _value)
+void ls::std::io::XmlAttribute::setValue(const ::std::string& _value)
 {
   this->_assignValue(_value);
 }
 
-std::string ls::XmlAttribute::toXml()
+std::string ls::std::io::XmlAttribute::toXml()
 {
   return this->name + "=\"" + this->value + "\"";
 }
 
-void ls::XmlAttribute::_assignName(const ::std::string &_name)
+void ls::std::io::XmlAttribute::_assignName(const ::std::string &_name)
 {
   if (_name.empty())
   {
@@ -50,7 +50,7 @@ void ls::XmlAttribute::_assignName(const ::std::string &_name)
   this->name = _name;
 }
 
-void ls::XmlAttribute::_assignValue(const ::std::string &_value)
+void ls::std::io::XmlAttribute::_assignValue(const ::std::string &_value)
 {
   if (_value.empty())
   {

source/ls_std/io/xml/XmlDeclaration.cpp

@@ -3,59 +3,59 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-29
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
 #include <ls_std/io/xml/XmlDeclaration.hpp>
 
-ls::XmlDeclaration::XmlDeclaration(const ::std::string& _version) : ls::std::core::Class("XmlDeclaration")
+ls::std::io::XmlDeclaration::XmlDeclaration(const ::std::string& _version) : ls::std::core::Class("XmlDeclaration")
 {
   this->version.setValue(_version);
 }
 
-std::string ls::XmlDeclaration::getEncoding()
+std::string ls::std::io::XmlDeclaration::getEncoding()
 {
   return this->encoding.getValue();
 }
 
-std::string ls::XmlDeclaration::getStandalone()
+std::string ls::std::io::XmlDeclaration::getStandalone()
 {
   return this->standalone.getValue();
 }
 
-std::string ls::XmlDeclaration::getVersion()
+std::string ls::std::io::XmlDeclaration::getVersion()
 {
   return this->version.getValue();
 }
 
-void ls::XmlDeclaration::setEncoding(const ::std::string& _encoding)
+void ls::std::io::XmlDeclaration::setEncoding(const ::std::string& _encoding)
 {
   this->encoding.setValue(_encoding);
 }
 
-void ls::XmlDeclaration::setStandalone(const ::std::string& _standalone)
+void ls::std::io::XmlDeclaration::setStandalone(const ::std::string& _standalone)
 {
   this->standalone.setValue(_standalone);
 }
 
-void ls::XmlDeclaration::setVersion(const ::std::string& _version)
+void ls::std::io::XmlDeclaration::setVersion(const ::std::string& _version)
 {
   this->version.setValue(_version);
 }
 
-std::string ls::XmlDeclaration::toXml()
+std::string ls::std::io::XmlDeclaration::toXml()
 {
   ::std::string declaration = "<?xml";
 
-  declaration += ls::XmlDeclaration::_toXmlAttribute(this->version);
-  declaration += ls::XmlDeclaration::_toXmlAttribute(this->encoding);
-  declaration += ls::XmlDeclaration::_toXmlAttribute(this->standalone);
+  declaration += ls::std::io::XmlDeclaration::_toXmlAttribute(this->version);
+  declaration += ls::std::io::XmlDeclaration::_toXmlAttribute(this->encoding);
+  declaration += ls::std::io::XmlDeclaration::_toXmlAttribute(this->standalone);
 
   return declaration + " ?>";
 }
 
-std::string ls::XmlDeclaration::_toXmlAttribute(ls::XmlAttribute _attribute)
+std::string ls::std::io::XmlDeclaration::_toXmlAttribute(ls::std::io::XmlAttribute _attribute)
 {
   ::std::string xmlString{};
 

source/ls_std/io/xml/XmlDocument.cpp

@@ -10,30 +10,30 @@
 #include <ls_std/io/xml/XmlDocument.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::XmlDocument::XmlDocument() : ls::std::core::Class("XmlDocument")
+ls::std::io::XmlDocument::XmlDocument() : ls::std::core::Class("XmlDocument")
 {}
 
-std::shared_ptr<ls::XmlDeclaration> ls::XmlDocument::getDeclaration()
+std::shared_ptr<ls::std::io::XmlDeclaration> ls::std::io::XmlDocument::getDeclaration()
 {
   return this->declaration;
 }
 
-std::shared_ptr<ls::XmlNode> ls::XmlDocument::getRootElement()
+std::shared_ptr<ls::std::io::XmlNode> ls::std::io::XmlDocument::getRootElement()
 {
   return this->rootElement;
 }
 
-void ls::XmlDocument::setDeclaration(const ::std::shared_ptr<ls::XmlDeclaration> &_declaration)
+void ls::std::io::XmlDocument::setDeclaration(const ::std::shared_ptr<ls::std::io::XmlDeclaration> &_declaration)
 {
   this->_assignDeclaration(_declaration);
 }
 
-void ls::XmlDocument::setRootElement(const ::std::shared_ptr<ls::XmlNode> &_rootElement)
+void ls::std::io::XmlDocument::setRootElement(const ::std::shared_ptr<ls::std::io::XmlNode> &_rootElement)
 {
   this->_assignRootElement(_rootElement);
 }
 
-std::string ls::XmlDocument::toXml()
+std::string ls::std::io::XmlDocument::toXml()
 {
   ::std::string xmlString{};
 
@@ -50,7 +50,7 @@ std::string ls::XmlDocument::toXml()
   return xmlString + this->rootElement->toXml();
 }
 
-void ls::XmlDocument::_assignDeclaration(const ::std::shared_ptr<ls::XmlDeclaration> &_declaration)
+void ls::std::io::XmlDocument::_assignDeclaration(const ::std::shared_ptr<ls::std::io::XmlDeclaration> &_declaration)
 {
   if (_declaration == nullptr)
   {
@@ -60,7 +60,7 @@ void ls::XmlDocument::_assignDeclaration(const ::std::shared_ptr<ls::XmlDeclarat
   this->declaration = _declaration;
 }
 
-void ls::XmlDocument::_assignRootElement(const ::std::shared_ptr<ls::XmlNode> &_rootElement)
+void ls::std::io::XmlDocument::_assignRootElement(const ::std::shared_ptr<ls::std::io::XmlNode> &_rootElement)
 {
   if (_rootElement == nullptr)
   {

source/ls_std/io/xml/XmlNode.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-24
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -11,12 +11,12 @@
 #include <ls_std/core/utils/STLUtils.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 
-ls::XmlNode::XmlNode(::std::string _name)
+ls::std::io::XmlNode::XmlNode(::std::string _name)
     : ls::std::core::Class("XmlNode"),
       name(::std::move(_name))
 {}
 
-bool ls::XmlNode::addAttributeAfter(const ::std::shared_ptr<ls::XmlAttribute> &_attribute, const ::std::string &_name)
+bool ls::std::io::XmlNode::addAttributeAfter(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute, const ::std::string &_name)
 {
   bool added{};
   auto iterator = this->attributes.begin();
@@ -42,7 +42,7 @@ bool ls::XmlNode::addAttributeAfter(const ::std::shared_ptr<ls::XmlAttribute> &_
   return added;
 }
 
-bool ls::XmlNode::addAttributeBefore(const ::std::shared_ptr<ls::XmlAttribute> &_attribute, const ::std::string &_name)
+bool ls::std::io::XmlNode::addAttributeBefore(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute, const ::std::string &_name)
 {
   bool added{};
   auto iterator = this->attributes.begin();
@@ -67,7 +67,7 @@ bool ls::XmlNode::addAttributeBefore(const ::std::shared_ptr<ls::XmlAttribute> &
   return added;
 }
 
-bool ls::XmlNode::addAttributeToBeginning(const ::std::shared_ptr<ls::XmlAttribute> &_attribute)
+bool ls::std::io::XmlNode::addAttributeToBeginning(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute)
 {
   bool added{};
   _checkIfAttributeReferenceIsValid(_attribute);
@@ -81,7 +81,7 @@ bool ls::XmlNode::addAttributeToBeginning(const ::std::shared_ptr<ls::XmlAttribu
   return added;
 }
 
-bool ls::XmlNode::addAttributeToEnd(const ::std::shared_ptr<ls::XmlAttribute> &_attribute)
+bool ls::std::io::XmlNode::addAttributeToEnd(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute)
 {
   bool added{};
   _checkIfAttributeReferenceIsValid(_attribute);
@@ -95,7 +95,7 @@ bool ls::XmlNode::addAttributeToEnd(const ::std::shared_ptr<ls::XmlAttribute> &_
   return added;
 }
 
-bool ls::XmlNode::addChildAfter(const ::std::shared_ptr<ls::XmlNode> &_child, const ::std::shared_ptr<ls::XmlNode> &_search)
+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 added{};
   auto iterator = this->children.begin();
@@ -121,7 +121,7 @@ bool ls::XmlNode::addChildAfter(const ::std::shared_ptr<ls::XmlNode> &_child, co
   return added;
 }
 
-bool ls::XmlNode::addChildBefore(const ::std::shared_ptr<ls::XmlNode> &_child, const ::std::shared_ptr<ls::XmlNode> &_search)
+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 added{};
   auto iterator = this->children.begin();
@@ -146,7 +146,7 @@ bool ls::XmlNode::addChildBefore(const ::std::shared_ptr<ls::XmlNode> &_child, c
   return added;
 }
 
-bool ls::XmlNode::addChildToBeginning(const ::std::shared_ptr<ls::XmlNode> &_child)
+bool ls::std::io::XmlNode::addChildToBeginning(const ::std::shared_ptr<ls::std::io::XmlNode> &_child)
 {
   bool added{};
   _checkIfNodeReferenceIsValid(_child);
@@ -160,7 +160,7 @@ bool ls::XmlNode::addChildToBeginning(const ::std::shared_ptr<ls::XmlNode> &_chi
   return added;
 }
 
-bool ls::XmlNode::addChildToEnd(const ::std::shared_ptr<ls::XmlNode> &_child)
+bool ls::std::io::XmlNode::addChildToEnd(const ::std::shared_ptr<ls::std::io::XmlNode> &_child)
 {
   bool added{};
   _checkIfNodeReferenceIsValid(_child);
@@ -174,24 +174,24 @@ bool ls::XmlNode::addChildToEnd(const ::std::shared_ptr<ls::XmlNode> &_child)
   return added;
 }
 
-void ls::XmlNode::clearValue()
+void ls::std::io::XmlNode::clearValue()
 {
   this->value.clear();
 }
 
-std::list<std::shared_ptr<ls::XmlAttribute>> ls::XmlNode::getAttributes()
+std::list<std::shared_ptr<ls::std::io::XmlAttribute>> ls::std::io::XmlNode::getAttributes()
 {
   return this->attributes;
 }
 
-std::list<std::shared_ptr<ls::XmlNode>> ls::XmlNode::getChildren()
+std::list<std::shared_ptr<ls::std::io::XmlNode>> ls::std::io::XmlNode::getChildren()
 {
   return this->children;
 }
 
-std::list<std::shared_ptr<ls::XmlNode>> ls::XmlNode::getChildren(const ::std::string &_name)
+std::list<std::shared_ptr<ls::std::io::XmlNode>> ls::std::io::XmlNode::getChildren(const ::std::string &_name)
 {
-  ::std::list<::std::shared_ptr<ls::XmlNode>> childrenWithName{};
+  ::std::list<::std::shared_ptr<ls::std::io::XmlNode>> childrenWithName{};
 
   for (const auto &child : this->children)
   {
@@ -204,32 +204,32 @@ std::list<std::shared_ptr<ls::XmlNode>> ls::XmlNode::getChildren(const ::std::st
   return childrenWithName;
 }
 
-std::string ls::XmlNode::getName()
+std::string ls::std::io::XmlNode::getName()
 {
   return this->name;
 }
 
-std::string ls::XmlNode::getValue()
+std::string ls::std::io::XmlNode::getValue()
 {
   return this->value;
 }
 
-bool ls::XmlNode::hasAttribute(const ::std::string &_name)
+bool ls::std::io::XmlNode::hasAttribute(const ::std::string &_name)
 {
   return this->_hasAttribute(_name);
 }
 
-bool ls::XmlNode::hasChild(const ::std::string &_name)
+bool ls::std::io::XmlNode::hasChild(const ::std::string &_name)
 {
   return this->_hasChild(_name);
 }
 
-bool ls::XmlNode::hasChild(const ::std::shared_ptr<ls::XmlNode> &_child)
+bool ls::std::io::XmlNode::hasChild(const ::std::shared_ptr<ls::std::io::XmlNode> &_child)
 {
   return this->_hasChild(_child);
 }
 
-bool ls::XmlNode::removeFirstAttribute()
+bool ls::std::io::XmlNode::removeFirstAttribute()
 {
   bool isValidOperation = !this->attributes.empty();
 
@@ -241,7 +241,7 @@ bool ls::XmlNode::removeFirstAttribute()
   return isValidOperation;
 }
 
-bool ls::XmlNode::removeLastAttribute()
+bool ls::std::io::XmlNode::removeLastAttribute()
 {
   bool isValidOperation = !this->attributes.empty();
 
@@ -253,7 +253,7 @@ bool ls::XmlNode::removeLastAttribute()
   return isValidOperation;
 }
 
-bool ls::XmlNode::removeFirstChild()
+bool ls::std::io::XmlNode::removeFirstChild()
 {
   bool isValidOperation = !this->children.empty();
 
@@ -265,7 +265,7 @@ bool ls::XmlNode::removeFirstChild()
   return isValidOperation;
 }
 
-bool ls::XmlNode::removeLastChild()
+bool ls::std::io::XmlNode::removeLastChild()
 {
   bool isValidOperation = !this->children.empty();
 
@@ -277,38 +277,38 @@ bool ls::XmlNode::removeLastChild()
   return isValidOperation;
 }
 
-void ls::XmlNode::setName(const ::std::string &_name)
+void ls::std::io::XmlNode::setName(const ::std::string &_name)
 {
   this->_assignName(_name);
 }
 
-void ls::XmlNode::setValue(const ::std::string &_value)
+void ls::std::io::XmlNode::setValue(const ::std::string &_value)
 {
   this->_assignValue(_value);
 }
 
-std::string ls::XmlNode::toXml()
+std::string ls::std::io::XmlNode::toXml()
 {
   return this->_toXml_(0);
 }
 
-std::string ls::XmlNode::_toXml_(uint8_t _tabSize)
+std::string ls::std::io::XmlNode::_toXml_(uint8_t _tabSize)
 {
   ::std::string xmlStream{};
 
-  xmlStream += ls::XmlNode::_getTab(_tabSize);
+  xmlStream += ls::std::io::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::XmlNode::_getTab(_tabSize) : "";
+  xmlStream += this->value.empty() ? ls::std::io::XmlNode::_getTab(_tabSize) : "";
   xmlStream += this->_toXmlCloseTag() + "\n";
 
   return xmlStream;
 }
 
-void ls::XmlNode::_assignName(const ::std::string &_name)
+void ls::std::io::XmlNode::_assignName(const ::std::string &_name)
 {
   if (_name.empty())
   {
@@ -318,7 +318,7 @@ void ls::XmlNode::_assignName(const ::std::string &_name)
   this->name = _name;
 }
 
-void ls::XmlNode::_assignValue(const ::std::string &_value)
+void ls::std::io::XmlNode::_assignValue(const ::std::string &_value)
 {
   if (_value.empty())
   {
@@ -328,7 +328,7 @@ void ls::XmlNode::_assignValue(const ::std::string &_value)
   this->value = _value;
 }
 
-void ls::XmlNode::_checkIfAttributeReferenceIsValid(const ::std::shared_ptr<ls::XmlAttribute> &_attribute)
+void ls::std::io::XmlNode::_checkIfAttributeReferenceIsValid(const ::std::shared_ptr<ls::std::io::XmlAttribute> &_attribute)
 {
   if (_attribute == nullptr)
   {
@@ -336,7 +336,7 @@ void ls::XmlNode::_checkIfAttributeReferenceIsValid(const ::std::shared_ptr<ls::
   }
 }
 
-void ls::XmlNode::_checkIfNameIsNotEmpty(const ::std::string &_name)
+void ls::std::io::XmlNode::_checkIfNameIsNotEmpty(const ::std::string &_name)
 {
   if (_name.empty())
   {
@@ -344,7 +344,7 @@ void ls::XmlNode::_checkIfNameIsNotEmpty(const ::std::string &_name)
   }
 }
 
-void ls::XmlNode::_checkIfNodeReferenceIsValid(const ::std::shared_ptr<ls::XmlNode> &_child)
+void ls::std::io::XmlNode::_checkIfNodeReferenceIsValid(const ::std::shared_ptr<ls::std::io::XmlNode> &_child)
 {
   if (_child == nullptr)
   {
@@ -352,7 +352,7 @@ void ls::XmlNode::_checkIfNodeReferenceIsValid(const ::std::shared_ptr<ls::XmlNo
   }
 }
 
-std::string ls::XmlNode::_getTab(uint8_t _tabSize)
+std::string ls::std::io::XmlNode::_getTab(uint8_t _tabSize)
 {
   ::std::string tab{};
 
@@ -364,7 +364,7 @@ std::string ls::XmlNode::_getTab(uint8_t _tabSize)
   return tab;
 }
 
-bool ls::XmlNode::_hasAttribute(const ::std::string &_name)
+bool ls::std::io::XmlNode::_hasAttribute(const ::std::string &_name)
 {
   bool exists{};
 
@@ -387,13 +387,13 @@ bool ls::XmlNode::_hasAttribute(const ::std::string &_name)
   return exists;
 }
 
-bool ls::XmlNode::_hasChild(const ::std::shared_ptr<ls::XmlNode> &_child)
+bool ls::std::io::XmlNode::_hasChild(const ::std::shared_ptr<ls::std::io::XmlNode> &_child)
 {
   _checkIfNodeReferenceIsValid(_child);
   return ls::std::core::STLUtils::contains(this->children, _child);
 }
 
-bool ls::XmlNode::_hasChild(const ::std::string &_name)
+bool ls::std::io::XmlNode::_hasChild(const ::std::string &_name)
 {
   bool exists{};
 
@@ -416,7 +416,7 @@ bool ls::XmlNode::_hasChild(const ::std::string &_name)
   return exists;
 }
 
-std::string ls::XmlNode::_toXmlAttributes()
+std::string ls::std::io::XmlNode::_toXmlAttributes()
 {
   ::std::string stream{};
 
@@ -428,7 +428,7 @@ std::string ls::XmlNode::_toXmlAttributes()
   return stream;
 }
 
-std::string ls::XmlNode::_toXmlChildren(uint8_t _tabSize)
+std::string ls::std::io::XmlNode::_toXmlChildren(uint8_t _tabSize)
 {
   ::std::string stream{};
 
@@ -443,7 +443,7 @@ std::string ls::XmlNode::_toXmlChildren(uint8_t _tabSize)
   return stream;
 }
 
-std::string ls::XmlNode::_toXmlCloseTag()
+std::string ls::std::io::XmlNode::_toXmlCloseTag()
 {
   ::std::string stream{};
 
@@ -455,12 +455,12 @@ std::string ls::XmlNode::_toXmlCloseTag()
   return stream;
 }
 
-std::string ls::XmlNode::_toXmlOpenTag()
+std::string ls::std::io::XmlNode::_toXmlOpenTag()
 {
   return "<" + this->name;
 }
 
-std::string ls::XmlNode::_toXmlOpenTagClose()
+std::string ls::std::io::XmlNode::_toXmlOpenTagClose()
 {
   ::std::string stream{};
 
@@ -476,7 +476,7 @@ std::string ls::XmlNode::_toXmlOpenTagClose()
   return stream;
 }
 
-std::string ls::XmlNode::_toXmlValue()
+std::string ls::std::io::XmlNode::_toXmlValue()
 {
   return this->value.empty() ? "\n" : this->value;
 }

source/ls_std/io/xml/XmlParser.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -11,40 +11,40 @@
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 #include <ls_std/boxing/String.hpp>
 
-ls::XmlParser::XmlParser(const ::std::shared_ptr<ls::XmlDocument> &_document) : ls::std::core::Class("XmlParser")
+ls::std::io::XmlParser::XmlParser(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document) : ls::std::core::Class("XmlParser")
 {
   this->_assignDocument(_document);
   this->_reset();
 }
 
-::std::shared_ptr<ls::XmlDocument> ls::XmlParser::getDocument()
+::std::shared_ptr<ls::std::io::XmlDocument> ls::std::io::XmlParser::getDocument()
 {
   return this->document;
 }
 
-void ls::XmlParser::parse(const ls::std::core::byte_field &_data)
+void ls::std::io::XmlParser::parse(const ls::std::core::byte_field &_data)
 {
   this->_parse(_data);
   this->_mergeNodes();
   this->_reset();
 }
 
-void ls::XmlParser::setDocument(const ::std::shared_ptr<ls::XmlDocument> &_document)
+void ls::std::io::XmlParser::setDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-::std::pair<::std::string, ::std::string> ls::XmlParser::_readAttribute_(const ls::std::core::byte_field &_data)
+::std::pair<::std::string, ::std::string> ls::std::io::XmlParser::_readAttribute_(const ls::std::core::byte_field &_data)
 {
-  return ls::XmlParser::_parseAttribute(_data);
+  return ls::std::io::XmlParser::_parseAttribute(_data);
 }
 
-::std::list<::std::pair<::std::string, ::std::string>> ls::XmlParser::_readAttributes_(ls::std::core::byte_field _data)
+::std::list<::std::pair<::std::string, ::std::string>> ls::std::io::XmlParser::_readAttributes_(ls::std::core::byte_field _data)
 {
-  return ls::XmlParser::_parseAttributes(::std::move(_data));
+  return ls::std::io::XmlParser::_parseAttributes(::std::move(_data));
 }
 
-void ls::XmlParser::_analyze(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+void ls::std::io::XmlParser::_analyze(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
 {
   this->_isDeclaration(_data, _index);
   this->_isClosingTag(_data, _index);
@@ -52,7 +52,7 @@ void ls::XmlParser::_analyze(const ls::std::core::byte_field &_data, ::std::stri
   this->_isValue(_data, _index);
 }
 
-void ls::XmlParser::_assignDocument(const ::std::shared_ptr<ls::XmlDocument> &_document)
+void ls::std::io::XmlParser::_assignDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document)
 {
   if (_document == nullptr)
   {
@@ -62,24 +62,24 @@ void ls::XmlParser::_assignDocument(const ::std::shared_ptr<ls::XmlDocument> &_d
   this->document = _document;
 }
 
-::std::shared_ptr<ls::XmlDeclaration> ls::XmlParser::_createDeclaration(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes)
+::std::shared_ptr<ls::std::io::XmlDeclaration> ls::std::io::XmlParser::_createDeclaration(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes)
 {
-  ::std::shared_ptr<ls::XmlDeclaration> declaration = ::std::make_shared<ls::XmlDeclaration>("1.0");
-  ::std::pair<::std::string, ::std::string> attribute = ls::XmlParser::_findAttribute(_attributes, "version");
+  ::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");
 
   if (!attribute.first.empty())
   {
     declaration->setVersion(attribute.second);
   }
 
-  attribute = ls::XmlParser::_findAttribute(_attributes, "encoding");
+  attribute = ls::std::io::XmlParser::_findAttribute(_attributes, "encoding");
 
   if (!attribute.first.empty())
   {
     declaration->setEncoding(attribute.second);
   }
 
-  attribute = ls::XmlParser::_findAttribute(_attributes, "standalone");
+  attribute = ls::std::io::XmlParser::_findAttribute(_attributes, "standalone");
 
   if (!attribute.first.empty())
   {
@@ -89,14 +89,14 @@ void ls::XmlParser::_assignDocument(const ::std::shared_ptr<ls::XmlDocument> &_d
   return declaration;
 }
 
-::std::shared_ptr<ls::XmlNode> ls::XmlParser::_createNode(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name)
+::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)
 {
-  ::std::shared_ptr<ls::XmlNode> node = ::std::make_shared<ls::XmlNode>(_name);
-  ::std::shared_ptr<ls::XmlAttribute> attribute{};
+  ::std::shared_ptr<ls::std::io::XmlNode> node = ::std::make_shared<ls::std::io::XmlNode>(_name);
+  ::std::shared_ptr<ls::std::io::XmlAttribute> attribute{};
 
   for (const auto &parsedAttribute : _attributes)
   {
-    attribute = ::std::make_shared<ls::XmlAttribute>(parsedAttribute.first);
+    attribute = ::std::make_shared<ls::std::io::XmlAttribute>(parsedAttribute.first);
     attribute->setValue(parsedAttribute.second);
     node->addAttributeToEnd(attribute);
   }
@@ -104,7 +104,7 @@ void ls::XmlParser::_assignDocument(const ::std::shared_ptr<ls::XmlDocument> &_d
   return node;
 }
 
-::std::pair<::std::string, ::std::string> ls::XmlParser::_findAttribute(const ::std::list<::std::pair<::std::string, ::std::string>> &_attributes, const ::std::string &_name)
+::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)
 {
   ::std::pair<::std::string, ::std::string> attribute{};
 
@@ -120,7 +120,7 @@ void ls::XmlParser::_assignDocument(const ::std::shared_ptr<ls::XmlDocument> &_d
   return attribute;
 }
 
-size_t ls::XmlParser::_findAttributeEndPosition(const ls::std::core::byte_field &_data)
+size_t ls::std::io::XmlParser::_findAttributeEndPosition(const ls::std::core::byte_field &_data)
 {
   ::std::string::size_type position = ::std::string::npos;
   ::std::string::size_type counter{};
@@ -143,7 +143,7 @@ size_t ls::XmlParser::_findAttributeEndPosition(const ls::std::core::byte_field
   return position;
 }
 
-ls::std::core::byte_field ls::XmlParser::_getNextTagString(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+ls::std::core::byte_field ls::std::io::XmlParser::_getNextTagString(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
 {
   ls::std::core::byte_field tag{};
   size_t closingCharacterPosition = _index + _data.substr(_index).find('>');
@@ -156,7 +156,7 @@ ls::std::core::byte_field ls::XmlParser::_getNextTagString(const ls::std::core::
   return tag;
 }
 
-void ls::XmlParser::_isClosingTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+void ls::std::io::XmlParser::_isClosingTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
 {
   if (this->mode == XML_PARSE_MODE_ANALYZE && _data.substr(_index, 2) == "</")
   {
@@ -164,7 +164,7 @@ void ls::XmlParser::_isClosingTag(const ls::std::core::byte_field &_data, ::std:
   }
 }
 
-void ls::XmlParser::_isDeclaration(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+void ls::std::io::XmlParser::_isDeclaration(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
 {
   if (_data.substr(_index, 5) == "<?xml")
   {
@@ -172,7 +172,7 @@ void ls::XmlParser::_isDeclaration(const ls::std::core::byte_field &_data, ::std
   }
 }
 
-void ls::XmlParser::_isOpeningTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+void ls::std::io::XmlParser::_isOpeningTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
 {
   if (this->mode == XML_PARSE_MODE_ANALYZE && _data.substr(_index, 1) == "<")
   {
@@ -180,7 +180,7 @@ void ls::XmlParser::_isOpeningTag(const ls::std::core::byte_field &_data, ::std:
   }
 }
 
-void ls::XmlParser::_isValue(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+void ls::std::io::XmlParser::_isValue(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
 {
   if (this->mode == XML_PARSE_MODE_ANALYZE)
   {
@@ -199,7 +199,7 @@ void ls::XmlParser::_isValue(const ls::std::core::byte_field &_data, ::std::stri
   }
 }
 
-void ls::XmlParser::_mergeNodes()
+void ls::std::io::XmlParser::_mergeNodes()
 {
   while (this->maxLevel > 1)
   {
@@ -210,7 +210,7 @@ void ls::XmlParser::_mergeNodes()
   this->document->setRootElement(this->parseParameters.front().node);
 }
 
-void ls::XmlParser::_mergeChildrenToParentNode(const ::std::shared_ptr<ls::XmlNode> &_parent, ::std::list<ls::XmlParseParameter>::iterator &_iterator, uint8_t _parentLevel)
+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)
 {
   do
   {
@@ -230,7 +230,7 @@ void ls::XmlParser::_mergeChildrenToParentNode(const ::std::shared_ptr<ls::XmlNo
   } while (_iterator->level > _parentLevel);
 }
 
-void ls::XmlParser::_mergeNodesOnCurrentLevel()
+void ls::std::io::XmlParser::_mergeNodesOnCurrentLevel()
 {
   auto iterator = this->parseParameters.begin();
   uint8_t parentLevel = this->maxLevel - 1;
@@ -248,7 +248,7 @@ void ls::XmlParser::_mergeNodesOnCurrentLevel()
   }
 }
 
-void ls::XmlParser::_parse(const ls::std::core::byte_field &_data)
+void ls::std::io::XmlParser::_parse(const ls::std::core::byte_field &_data)
 {
   for (::std::string::size_type index = 0; index < _data.size(); index++)
   {
@@ -269,21 +269,21 @@ void ls::XmlParser::_parse(const ls::std::core::byte_field &_data)
       case XML_PARSE_MODE_OPENING_TAG:
       {
         --index;
-        index = ls::XmlParser::_parseOpeningTag(_data, index);
+        index = ls::std::io::XmlParser::_parseOpeningTag(_data, index);
         this->mode = XML_PARSE_MODE_ANALYZE;
       }
         break;
       case XML_PARSE_MODE_VALUE:
       {
         --index;
-        index = ls::XmlParser::_parseValue(_data, index);
+        index = ls::std::io::XmlParser::_parseValue(_data, index);
         this->mode = XML_PARSE_MODE_ANALYZE;
       }
         break;
       case XML_PARSE_MODE_CLOSING_TAG:
       {
         --index;
-        index = ls::XmlParser::_parseClosingTag(_data, index);
+        index = ls::std::io::XmlParser::_parseClosingTag(_data, index);
         this->mode = XML_PARSE_MODE_ANALYZE;
       }
         break;
@@ -291,7 +291,7 @@ void ls::XmlParser::_parse(const ls::std::core::byte_field &_data)
   }
 }
 
-::std::pair<::std::string, ::std::string> ls::XmlParser::_parseAttribute(const ls::std::core::byte_field &_data)
+::std::pair<::std::string, ::std::string> ls::std::io::XmlParser::_parseAttribute(const ls::std::core::byte_field &_data)
 {
   ::std::pair<::std::string, ::std::string> parsedAttribute{};
   parsedAttribute.first = _data.substr(0, _data.find('='));
@@ -301,7 +301,7 @@ void ls::XmlParser::_parse(const ls::std::core::byte_field &_data)
   return parsedAttribute;
 }
 
-::std::list<::std::pair<::std::string, ::std::string>> ls::XmlParser::_parseAttributes(ls::std::core::byte_field _data)
+::std::list<::std::pair<::std::string, ::std::string>> ls::std::io::XmlParser::_parseAttributes(ls::std::core::byte_field _data)
 {
   ::std::list<::std::pair<::std::string, ::std::string>> attributes{};
   size_t position = _data.find(' ');
@@ -319,44 +319,44 @@ void ls::XmlParser::_parse(const ls::std::core::byte_field &_data)
       break;
     }
 
-    ::std::string attributeString = _data.substr(position, ls::XmlParser::_findAttributeEndPosition(_data) + 1);
-    attributes.push_back(ls::XmlParser::_parseAttribute(attributeString));
+    ::std::string attributeString = _data.substr(position, ls::std::io::XmlParser::_findAttributeEndPosition(_data) + 1);
+    attributes.push_back(ls::std::io::XmlParser::_parseAttribute(attributeString));
     _data = _data.substr(position + attributeString.size());
   }
 
   return attributes;
 }
 
-size_t ls::XmlParser::_parseClosingTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+size_t ls::std::io::XmlParser::_parseClosingTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
 {
-  ::std::string tagString = ls::XmlParser::_getNextTagString(_data, _index);
+  ::std::string tagString = ls::std::io::XmlParser::_getNextTagString(_data, _index);
   this->currentLevel -= 1;
   return tagString.empty() ? _index : _index + (tagString.size() - 1);
 }
 
-size_t ls::XmlParser::_parseDeclaration(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+size_t ls::std::io::XmlParser::_parseDeclaration(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
 {
-  ::std::string tagString = ls::XmlParser::_getNextTagString(_data, _index);
+  ::std::string tagString = ls::std::io::XmlParser::_getNextTagString(_data, _index);
   bool isValidTagString = !tagString.empty();
 
   if (isValidTagString)
   {
-    ::std::shared_ptr<ls::XmlDeclaration> declaration = this->_createDeclaration(ls::XmlParser::_parseAttributes(tagString));
+    ::std::shared_ptr<ls::std::io::XmlDeclaration> declaration = this->_createDeclaration(ls::std::io::XmlParser::_parseAttributes(tagString));
     this->document->setDeclaration(declaration);
   }
 
   return !isValidTagString ? _index : _index + (tagString.size() - 1);
 }
 
-size_t ls::XmlParser::_parseOpeningTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+size_t ls::std::io::XmlParser::_parseOpeningTag(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
 {
-  ls::std::boxing::String tagString{ls::XmlParser::_getNextTagString(_data, _index)};
+  ls::std::boxing::String tagString{ls::std::io::XmlParser::_getNextTagString(_data, _index)};
   bool isValidTagString = !tagString.toString().empty();
-  ls::XmlParseParameter singleParseParameter{};
+  ls::std::io::XmlParseParameter singleParseParameter{};
 
   if (isValidTagString)
   {
-    ::std::shared_ptr<ls::XmlNode> node = ls::XmlParser::_createNode(ls::XmlParser::_parseAttributes(tagString), ls::XmlParser::_parseTagName(tagString));
+    ::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));
 
     singleParseParameter.level = this->currentLevel;
     singleParseParameter.node = node;
@@ -372,7 +372,7 @@ size_t ls::XmlParser::_parseOpeningTag(const ls::std::core::byte_field &_data, :
   return !isValidTagString ? _index : _index + (tagString.toString().size() - 1);
 }
 
-ls::std::core::byte_field ls::XmlParser::_parseTagName(const ls::std::core::byte_field &_data)
+ls::std::core::byte_field ls::std::io::XmlParser::_parseTagName(const ls::std::core::byte_field &_data)
 {
   ::std::string::size_type position = _data.find(' ');
 
@@ -384,7 +384,7 @@ ls::std::core::byte_field ls::XmlParser::_parseTagName(const ls::std::core::byte
   return _data.substr(1, position - 1);
 }
 
-size_t ls::XmlParser::_parseValue(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
+size_t ls::std::io::XmlParser::_parseValue(const ls::std::core::byte_field &_data, ::std::string::size_type _index)
 {
   ls::std::core::byte_field value = _data.substr(_index, _data.substr(_index).find('<'));
   this->parseParameters.back().node->setValue(value);
@@ -392,7 +392,7 @@ size_t ls::XmlParser::_parseValue(const ls::std::core::byte_field &_data, ::std:
   return _index + (value.size() - 1);
 }
 
-void ls::XmlParser::_reset()
+void ls::std::io::XmlParser::_reset()
 {
   this->currentLevel = 1;
   this->maxLevel = 1;
@@ -400,7 +400,7 @@ void ls::XmlParser::_reset()
   this->parseParameters.clear();
 }
 
-void ls::XmlParser::_setMaxLevel()
+void ls::std::io::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:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -13,38 +13,38 @@
 #include <ls_std/boxing/String.hpp>
 #include <ls_std/io/xml/XmlParser.hpp>
 
-ls::XmlReader::XmlReader(const ::std::shared_ptr<ls::XmlDocument> &_document, const ::std::string &_absolutePath)
+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::File{""})
+      xmlFile(ls::std::io::File{""})
 {
   this->_assignDocument(_document);
-  this->_assignFile(ls::File{_absolutePath});
+  this->_assignFile(ls::std::io::File{_absolutePath});
 }
 
-ls::std::core::byte_field ls::XmlReader::read()
+ls::std::core::byte_field ls::std::io::XmlReader::read()
 {
-  ls::std::core::byte_field data = ls::FileReader{this->xmlFile}.read();
-  ls::XmlParser{this->document}.parse(data);
+  ls::std::core::byte_field data = ls::std::io::FileReader{this->xmlFile}.read();
+  ls::std::io::XmlParser{this->document}.parse(data);
 
   return data;
 }
 
-::std::shared_ptr<ls::XmlDocument> ls::XmlReader::getDocument()
+::std::shared_ptr<ls::std::io::XmlDocument> ls::std::io::XmlReader::getDocument()
 {
   return this->document;
 }
 
-void ls::XmlReader::setDocument(const ::std::shared_ptr<ls::XmlDocument> &_document)
+void ls::std::io::XmlReader::setDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document)
 {
   this->_assignDocument(_document);
 }
 
-void ls::XmlReader::setFile(const ls::File &_xmlFile)
+void ls::std::io::XmlReader::setFile(const ls::std::io::File &_xmlFile)
 {
   this->_assignFile(_xmlFile);
 }
 
-void ls::XmlReader::_assignDocument(const ::std::shared_ptr<ls::XmlDocument> &_document)
+void ls::std::io::XmlReader::_assignDocument(const ::std::shared_ptr<ls::std::io::XmlDocument> &_document)
 {
   if (_document == nullptr)
   {
@@ -54,7 +54,7 @@ void ls::XmlReader::_assignDocument(const ::std::shared_ptr<ls::XmlDocument> &_d
   this->document = _document;
 }
 
-void ls::XmlReader::_assignFile(ls::File _xmlFile)
+void ls::std::io::XmlReader::_assignFile(ls::std::io::File _xmlFile)
 {
   if (!_xmlFile.exists())
   {

test/TestDataFactory.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-16
- * Changed:         2022-05-05
+ * Changed:         2022-05-11
  *
  * */
 
@@ -39,31 +39,31 @@ ls::StateMachine ls_std_test::TestDataFactory::createStateMachine()
   return stateMachine;
 }
 
-std::shared_ptr<ls::XmlNode> ls_std_test::TestDataFactory::createXmlContent()
+std::shared_ptr<ls::std::io::XmlNode> ls_std_test::TestDataFactory::createXmlContent()
 {
-  std::shared_ptr<ls::XmlNode> root = std::make_shared<ls::XmlNode>("dialog");
-  std::shared_ptr<ls::XmlAttribute> attribute{};
-  std::shared_ptr<ls::XmlNode> child{};
-  std::shared_ptr<ls::XmlNode> text{};
+  std::shared_ptr<ls::std::io::XmlNode> root = std::make_shared<ls::std::io::XmlNode>("dialog");
+  std::shared_ptr<ls::std::io::XmlAttribute> attribute{};
+  std::shared_ptr<ls::std::io::XmlNode> child{};
+  std::shared_ptr<ls::std::io::XmlNode> text{};
 
-  attribute = std::make_shared<ls::XmlAttribute>("name");
+  attribute = std::make_shared<ls::std::io::XmlAttribute>("name");
   attribute->setValue("dungeon_001");
   root->addAttributeToEnd(attribute);
 
-  child = std::make_shared<ls::XmlNode>("dialogUnit");
-  attribute = std::make_shared<ls::XmlAttribute>("id");
+  child = std::make_shared<ls::std::io::XmlNode>("dialogUnit");
+  attribute = std::make_shared<ls::std::io::XmlAttribute>("id");
   attribute->setValue("001");
   child->addAttributeToEnd(attribute);
-  text = std::make_shared<ls::XmlNode>("text");
+  text = std::make_shared<ls::std::io::XmlNode>("text");
   text->setValue("Hello!");
   child->addChildToEnd(text);
   root->addChildToEnd(child);
 
-  child = std::make_shared<ls::XmlNode>("dialogUnit");
-  attribute = std::make_shared<ls::XmlAttribute>("id");
+  child = std::make_shared<ls::std::io::XmlNode>("dialogUnit");
+  attribute = std::make_shared<ls::std::io::XmlAttribute>("id");
   attribute->setValue("002");
   child->addAttributeToEnd(attribute);
-  text = std::make_shared<ls::XmlNode>("text");
+  text = std::make_shared<ls::std::io::XmlNode>("text");
   text->setValue("Hello again!");
   child->addChildToEnd(text);
   root->addChildToEnd(child);

test/TestDataFactory.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-16
- * Changed:         2022-05-05
+ * Changed:         2022-05-11
  *
  * */
 
@@ -22,7 +22,7 @@ namespace ls_std_test
       ~TestDataFactory() = default;
 
       static ls::StateMachine createStateMachine();
-      static std::shared_ptr<ls::XmlNode> createXmlContent();
+      static std::shared_ptr<ls::std::io::XmlNode> createXmlContent();
   };
 }
 

test/TestHelper.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2022-05-05
+ * Changed:         2022-05-11
  *
  * */
 
@@ -22,13 +22,13 @@ class TestHelper
 
     static std::string getResourcesFolderLocation()
     {
-      return TestHelper::getTestFolderLocation() + "resources" + ls::FilePathSeparator::get();
+      return TestHelper::getTestFolderLocation() + "resources" + ls::std::io::FilePathSeparator::get();
     }
 
     static std::string getTestFolderLocation()
     {
-      ls::File buildDirectory{ls::File::getWorkingDirectory()};
-      return buildDirectory.getParent() + "test" + ls::FilePathSeparator::get();
+      ls::std::io::File buildDirectory{ls::std::io::File::getWorkingDirectory()};
+      return buildDirectory.getParent() + "test" + ls::std::io::FilePathSeparator::get();
     }
 };
 

test/cases/io/FileOutputStreamTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -30,12 +30,12 @@ namespace
   TEST_F(FileOutputStreamTest, constructor_file_does_not_exist)
   {
     std::string path = TestHelper::getResourcesFolderLocation() + "not_existing.txt";
-    ls::File file{path};
+    ls::std::io::File file{path};
 
     EXPECT_THROW({
                    try
                    {
-                     ls::FileOutputStream outputStream{file};
+                     ls::std::io::FileOutputStream outputStream{file};
                    }
                    catch (const ls::std::core::FileNotFoundException &_exception)
                    {
@@ -47,11 +47,11 @@ namespace
   TEST_F(FileOutputStreamTest, write)
   {
     std::string path = TestHelper::getResourcesFolderLocation() + "tmp_output_stream.txt";
-    ls::File file{path};
+    ls::std::io::File file{path};
     file.createNewFile();
     ASSERT_TRUE(file.exists());
 
-    ls::FileOutputStream outputStream{file};
+    ls::std::io::FileOutputStream outputStream{file};
     ASSERT_TRUE(outputStream.write("Hello! "));
     ASSERT_TRUE(outputStream.write("How are you?"));
     outputStream.close();
@@ -63,23 +63,23 @@ namespace
   TEST_F(FileOutputStreamTest, write_with_another_appending_stream)
   {
     std::string path = TestHelper::getResourcesFolderLocation() + "tmp_output_stream.txt";
-    ls::File file{path};
+    ls::std::io::File file{path};
     file.createNewFile();
     ASSERT_TRUE(file.exists());
 
-    ls::FileOutputStream outputStream{file};
+    ls::std::io::FileOutputStream outputStream{file};
     ASSERT_TRUE(outputStream.write("Hello! "));
     ASSERT_TRUE(outputStream.write("How are you?"));
     outputStream.close();
 
-    ls::FileOutputStream newOutputStream{file, true};
+    ls::std::io::FileOutputStream newOutputStream{file, true};
     ASSERT_TRUE(newOutputStream.write(" I'm fine! "));
     ASSERT_TRUE(newOutputStream.write("Thank you!"));
     newOutputStream.close();
 
     // validation
 
-    ls::FileReader reader{file};
+    ls::std::io::FileReader reader{file};
     ls::std::boxing::String content{reader.read()};
 
     ASSERT_TRUE(content.contains("Hello! How are you? I'm fine! Thank you!"));
@@ -91,13 +91,13 @@ namespace
   TEST_F(FileOutputStreamTest, write_no_permission_to_write)
   {
     #if defined(unix) || defined(__APPLE__)
-    ls::File file{TestHelper::getResourcesFolderLocation() + "no_writable.txt"};
+    ls::std::io::File file{TestHelper::getResourcesFolderLocation() + "no_writable.txt"};
     #endif
     #ifdef _WIN32
-    ls::File file{TestHelper::getResourcesFolderLocation() + "no_writable_windows.txt"};
+    ls::std::io::File file{TestHelper::getResourcesFolderLocation() + "no_writable_windows.txt"};
     #endif
 
-    ls::FileOutputStream outputStream{file};
+    ls::std::io::FileOutputStream outputStream{file};
 
     EXPECT_THROW({
                    try

test/cases/io/FileReaderTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-18
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -29,12 +29,12 @@ namespace
 
   TEST_F(FileReaderTest, constructor_file_does_not_exist)
   {
-    ls::File file{TestHelper::getResourcesFolderLocation() + "does_not_exist.txt"};
+    ls::std::io::File file{TestHelper::getResourcesFolderLocation() + "does_not_exist.txt"};
 
     EXPECT_THROW({
                    try
                    {
-                     ls::FileReader reader{file};
+                     ls::std::io::FileReader reader{file};
                    }
                    catch (const ls::std::core::FileNotFoundException &_exception)
                    {
@@ -45,10 +45,10 @@ namespace
 
   TEST_F(FileReaderTest, read)
   {
-    ls::File file{TestHelper::getResourcesFolderLocation() + "simple.txt"};
-    ls::FileReader reader{file};
-    std::string expectedUnix = "Hello!" + ls::NewLine::getUnixNewLine();
-    std::string expectedWindows = "Hello!" + ls::NewLine::getWindowsNewLine();
+    ls::std::io::File file{TestHelper::getResourcesFolderLocation() + "simple.txt"};
+    ls::std::io::FileReader reader{file};
+    std::string expectedUnix = "Hello!" + ls::std::io::NewLine::getUnixNewLine();
+    std::string expectedWindows = "Hello!" + ls::std::io::NewLine::getWindowsNewLine();
 
     ls::std::core::byte_field content = reader.read();
     ASSERT_TRUE(content == expectedUnix || content == expectedWindows);
@@ -56,9 +56,9 @@ namespace
 
   TEST_F(FileReaderTest, read_file_gets_lost_in_between)
   {
-    ls::File file{TestHelper::getResourcesFolderLocation() + "lost_readable_file.txt"};
+    ls::std::io::File file{TestHelper::getResourcesFolderLocation() + "lost_readable_file.txt"};
     file.createNewFile();
-    ls::FileReader reader{file};
+    ls::std::io::FileReader reader{file};
     file.remove();
 
     EXPECT_THROW({
@@ -75,18 +75,18 @@ namespace
 
   TEST_F(FileReaderTest, reset)
   {
-    ls::File file{TestHelper::getResourcesFolderLocation() + "simple.txt"};
-    ls::FileReader reader{file};
-    std::string expectedUnix = "Hello!" + ls::NewLine::getUnixNewLine();
-    std::string expectedWindows = "Hello!" + ls::NewLine::getWindowsNewLine();
+    ls::std::io::File file{TestHelper::getResourcesFolderLocation() + "simple.txt"};
+    ls::std::io::FileReader reader{file};
+    std::string expectedUnix = "Hello!" + ls::std::io::NewLine::getUnixNewLine();
+    std::string expectedWindows = "Hello!" + ls::std::io::NewLine::getWindowsNewLine();
 
     ls::std::core::byte_field content = reader.read();
     ASSERT_TRUE(content == expectedUnix || content == expectedWindows);
 
-    ls::File anotherFile{TestHelper::getResourcesFolderLocation() + "list_test/bla.txt"};
+    ls::std::io::File anotherFile{TestHelper::getResourcesFolderLocation() + "list_test/bla.txt"};
     reader.reset(anotherFile);
-    expectedUnix = "nothing to say!" + ls::NewLine::getUnixNewLine();
-    expectedWindows = "nothing to say!" + ls::NewLine::getWindowsNewLine();
+    expectedUnix = "nothing to say!" + ls::std::io::NewLine::getUnixNewLine();
+    expectedWindows = "nothing to say!" + ls::std::io::NewLine::getWindowsNewLine();
 
     content = reader.read();
     ASSERT_TRUE(content == expectedUnix || content == expectedWindows);

test/cases/io/FileTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-15
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -33,10 +33,10 @@ namespace
 
   TEST_F(FileTest, operator_equals)
   {
-    ls::File file{this->fileLocation};
-    ls::File file2{this->fileLocation};
-    ls::File file3{"/home/bla/text.txt"};
-    ls::File file4{"\\home/bla\\text.txt"};
+    ls::std::io::File file{this->fileLocation};
+    ls::std::io::File file2{this->fileLocation};
+    ls::std::io::File file3{"/home/bla/text.txt"};
+    ls::std::io::File file4{"\\home/bla\\text.txt"};
 
     ASSERT_TRUE(file == file2);
     ASSERT_TRUE(file2 == file);
@@ -46,8 +46,8 @@ namespace
 
   TEST_F(FileTest, operator_not_equals)
   {
-    ls::File file{this->fileLocation};
-    ls::File file2{TestHelper::getResourcesFolderLocation() + "app.exe"};
+    ls::std::io::File file{this->fileLocation};
+    ls::std::io::File file2{TestHelper::getResourcesFolderLocation() + "app.exe"};
 
     ASSERT_TRUE(file != file2);
     ASSERT_TRUE(file2 != file);
@@ -58,10 +58,10 @@ namespace
   TEST_F(FileTest, canExecute)
   {
     #ifdef _WIN32
-    ls::File executableFile{TestHelper::getResourcesFolderLocation() + "app.exe"};
+    ls::std::io::File executableFile{TestHelper::getResourcesFolderLocation() + "app.exe"};
     #endif
     #if defined(unix) || defined(__APPLE__)
-    ls::File executableFile{TestHelper::getResourcesFolderLocation() + "app"};
+    ls::std::io::File executableFile{TestHelper::getResourcesFolderLocation() + "app"};
     #endif
 
     ASSERT_TRUE(executableFile.canExecute());
@@ -69,19 +69,19 @@ namespace
 
   TEST_F(FileTest, canExecute_not_executable)
   {
-    ls::File file{this->fileLocation};
+    ls::std::io::File file{this->fileLocation};
     ASSERT_FALSE(file.canExecute());
   }
 
   TEST_F(FileTest, canRead)
   {
-    ls::File readableFile{this->fileLocation};
+    ls::std::io::File readableFile{this->fileLocation};
     ASSERT_TRUE(readableFile.canRead());
   }
 
   TEST_F(FileTest, canRead_file_does_not_exist)
   {
-    ls::File file{""};
+    ls::std::io::File file{""};
 
     EXPECT_THROW({
                    try
@@ -97,25 +97,25 @@ namespace
 
   TEST_F(FileTest, canWrite)
   {
-    ls::File readableFile{this->fileLocation};
+    ls::std::io::File readableFile{this->fileLocation};
     ASSERT_TRUE(readableFile.canWrite());
   }
 
   TEST_F(FileTest, canWrite_not_writable)
   {
     #if defined(unix) || defined(__APPLE__)
-    ls::File noWritableFile{TestHelper::getResourcesFolderLocation() + "no_writable.txt"};
+    ls::std::io::File noWritableFile{TestHelper::getResourcesFolderLocation() + "no_writable.txt"};
     ASSERT_FALSE(noWritableFile.canWrite());
     #endif
     #ifdef _WIN32
-    ls::File noWritableFile{TestHelper::getResourcesFolderLocation() + "no_writable_windows.txt"};
+    ls::std::io::File noWritableFile{TestHelper::getResourcesFolderLocation() + "no_writable_windows.txt"};
     ASSERT_FALSE(noWritableFile.canWrite());
     #endif
   }
 
   TEST_F(FileTest, createNewFile)
   {
-    ls::File file{TestHelper::getResourcesFolderLocation() + "tmp.txt"};
+    ls::std::io::File file{TestHelper::getResourcesFolderLocation() + "tmp.txt"};
     ASSERT_FALSE(file.exists());
 
     file.createNewFile();
@@ -127,7 +127,7 @@ namespace
 
   TEST_F(FileTest, createNewFile_file_does_already_exist)
   {
-    ls::File file{TestHelper::getResourcesFolderLocation() + "simple.txt"};
+    ls::std::io::File file{TestHelper::getResourcesFolderLocation() + "simple.txt"};
 
     EXPECT_THROW({
                    try
@@ -143,8 +143,8 @@ namespace
 
   TEST_F(FileTest, exists)
   {
-    ls::File file{this->fileLocation};
-    ls::File directory{TestHelper::getResourcesFolderLocation()};
+    ls::std::io::File file{this->fileLocation};
+    ls::std::io::File directory{TestHelper::getResourcesFolderLocation()};
 
     ASSERT_TRUE(file.exists());
     ASSERT_TRUE(directory.exists());
@@ -152,28 +152,28 @@ namespace
 
   TEST_F(FileTest, exists_does_not_exist)
   {
-    ls::File file{TestHelper::getResourcesFolderLocation() + "bla.txt"};
+    ls::std::io::File file{TestHelper::getResourcesFolderLocation() + "bla.txt"};
     ASSERT_FALSE(file.exists());
   }
 
   TEST_F(FileTest, getAbsoluteFilePath)
   {
-    ls::File file{this->fileLocation};
+    ls::std::io::File file{this->fileLocation};
     ASSERT_STREQ(this->fileLocation.c_str(), file.getAbsoluteFilePath().c_str());
-    std::string s = {ls::FilePathSeparator::get()};
+    std::string s = {ls::std::io::FilePathSeparator::get()};
 
     std::string wrongFilePath = "home" + s + s + s + "user" + s + "bla" + s + s + "sub_folder";
     std::string expectedFilePath = "home" + s + "user" + s + "bla" + s + "sub_folder";
-    ls::File anotherFile{wrongFilePath};
+    ls::std::io::File anotherFile{wrongFilePath};
     ASSERT_STREQ(expectedFilePath.c_str(), anotherFile.getAbsoluteFilePath().c_str());
   }
 
   TEST_F(FileTest, getName)
   {
-    ls::File file{this->fileLocation};
-    ls::File executableFile{TestHelper::getResourcesFolderLocation() + "app.exe"};
-    ls::File anotherFile{"bla.txt"};
-    ls::File directory{TestHelper::getResourcesFolderLocation()};
+    ls::std::io::File file{this->fileLocation};
+    ls::std::io::File executableFile{TestHelper::getResourcesFolderLocation() + "app.exe"};
+    ls::std::io::File anotherFile{"bla.txt"};
+    ls::std::io::File directory{TestHelper::getResourcesFolderLocation()};
 
     ASSERT_STREQ("simple.txt", file.getName().c_str());
     ASSERT_STREQ("app.exe", executableFile.getName().c_str());
@@ -183,19 +183,19 @@ namespace
 
   TEST_F(FileTest, getParent)
   {
-    ls::File file{this->fileLocation};
+    ls::std::io::File file{this->fileLocation};
     ASSERT_STREQ(TestHelper::getResourcesFolderLocation().c_str(), file.getParent().c_str());
   }
 
   TEST_F(FileTest, getWorkingDirectory)
   {
-    std::string workingDirectory = ls::File::getWorkingDirectory();
+    std::string workingDirectory = ls::std::io::File::getWorkingDirectory();
     ASSERT_FALSE(workingDirectory.empty());
   }
 
   TEST_F(FileTest, getSize)
   {
-    ls::File file{this->fileLocation};
+    ls::std::io::File file{this->fileLocation};
     size_t size = file.getSize();
 
     ASSERT_TRUE(size == 7 || size == 8); // different OS specific new lines
@@ -203,45 +203,45 @@ namespace
 
   TEST_F(FileTest, isDirectory)
   {
-    ls::File directory{TestHelper::getResourcesFolderLocation()};
+    ls::std::io::File directory{TestHelper::getResourcesFolderLocation()};
     ASSERT_TRUE(directory.isDirectory());
   }
 
   TEST_F(FileTest, isDirectory_is_a_file)
   {
-    ls::File file{this->fileLocation};
+    ls::std::io::File file{this->fileLocation};
     ASSERT_FALSE(file.isDirectory());
   }
 
   TEST_F(FileTest, isFile)
   {
-    const char separator = ls::FilePathSeparator::get();
+    const char separator = ls::std::io::FilePathSeparator::get();
 
-    ls::File file{this->fileLocation};
+    ls::std::io::File file{this->fileLocation};
     ASSERT_TRUE(file.isFile());
 
-    ls::File file2{TestHelper::getResourcesFolderLocation() + "list_test" + separator + "bla.txt"};
+    ls::std::io::File file2{TestHelper::getResourcesFolderLocation() + "list_test" + separator + "bla.txt"};
     ASSERT_TRUE(file2.isFile());
   }
 
   TEST_F(FileTest, isFile_is_a_directory)
   {
-    ls::File directory{TestHelper::getResourcesFolderLocation()};
+    ls::std::io::File directory{TestHelper::getResourcesFolderLocation()};
     ASSERT_FALSE(directory.isFile());
   }
 
   TEST_F(FileTest, lastModified)
   {
-    ls::File file{this->fileLocation};
+    ls::std::io::File file{this->fileLocation};
     ASSERT_TRUE(file.lastModified() > 1590000000);
   }
 
   TEST_F(FileTest, list)
   {
-    ls::File file{TestHelper::getResourcesFolderLocation() + "list_test"};
+    ls::std::io::File file{TestHelper::getResourcesFolderLocation() + "list_test"};
     std::list<std::string> filesInDirectory = file.list();
     std::string expectedFile{};
-    const char separator = ls::FilePathSeparator::get();
+    const char separator = ls::std::io::FilePathSeparator::get();
 
     auto filesIterator = filesInDirectory.begin();
 
@@ -266,10 +266,10 @@ namespace
 
   TEST_F(FileTest, listFiles)
   {
-    ls::File file{TestHelper::getResourcesFolderLocation() + "list_test"};
+    ls::std::io::File file{TestHelper::getResourcesFolderLocation() + "list_test"};
     std::list<std::string> filesInDirectory = file.listFiles();
     std::string expectedFile{};
-    const char separator = ls::FilePathSeparator::get();
+    const char separator = ls::std::io::FilePathSeparator::get();
 
     ASSERT_FALSE(filesInDirectory.empty());
     ASSERT_EQ(4, filesInDirectory.size());
@@ -286,7 +286,7 @@ namespace
 
   TEST_F(FileTest, makeDirectory)
   {
-    ls::File directory{TestHelper::getResourcesFolderLocation() + "testDir"};
+    ls::std::io::File directory{TestHelper::getResourcesFolderLocation() + "testDir"};
     ASSERT_FALSE(directory.exists());
 
     directory.makeDirectory();
@@ -298,7 +298,7 @@ namespace
 
   TEST_F(FileTest, makeDirectory_directory_already_exists)
   {
-    ls::File directory{TestHelper::getResourcesFolderLocation() + "list_test"};
+    ls::std::io::File directory{TestHelper::getResourcesFolderLocation() + "list_test"};
 
     EXPECT_THROW({
                    try
@@ -314,7 +314,7 @@ namespace
 
   TEST_F(FileTest, makeDirectories)
   {
-    ls::File directory{TestHelper::getResourcesFolderLocation() + "testDir/sub/tmp/bla"};
+    ls::std::io::File directory{TestHelper::getResourcesFolderLocation() + "testDir/sub/tmp/bla"};
     ASSERT_FALSE(directory.exists());
 
     directory.makeDirectories();
@@ -323,18 +323,18 @@ namespace
     // clean up
 
     directory.remove();
-    directory = ls::File(TestHelper::getResourcesFolderLocation() + "testDir/sub/tmp");
+    directory = ls::std::io::File(TestHelper::getResourcesFolderLocation() + "testDir/sub/tmp");
     directory.remove();
-    directory = ls::File(TestHelper::getResourcesFolderLocation() + "testDir/sub");
+    directory = ls::std::io::File(TestHelper::getResourcesFolderLocation() + "testDir/sub");
     directory.remove();
-    directory = ls::File(TestHelper::getResourcesFolderLocation() + "testDir");
+    directory = ls::std::io::File(TestHelper::getResourcesFolderLocation() + "testDir");
     directory.remove();
   }
 
   TEST_F(FileTest, remove)
   {
     std::string fileName = TestHelper::getResourcesFolderLocation() + "removable_file.txt";
-    ls::File file{fileName};
+    ls::std::io::File file{fileName};
     file.createNewFile();
 
     ASSERT_TRUE(file.exists());
@@ -348,7 +348,7 @@ namespace
     std::string currentName = TestHelper::getResourcesFolderLocation() + "tmp_rename_to.txt";
     std::string newName = TestHelper::getResourcesFolderLocation() + "tmp_rename_to_better_name.txt";
 
-    ls::File file{currentName};
+    ls::std::io::File file{currentName};
     file.createNewFile();
 
     ASSERT_TRUE(file.exists());
@@ -363,7 +363,7 @@ namespace
 
   TEST_F(FileTest, reset)
   {
-    ls::File file{this->fileLocation};
+    ls::std::io::File file{this->fileLocation};
     ASSERT_TRUE(file.exists());
 
     file.reset(TestHelper::getResourcesFolderLocation() + "list_test/hello.txt");

test/cases/io/FileWriterTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-17
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -30,12 +30,12 @@ namespace
   TEST_F(FileWriterTest, constructor_file_does_not_exist)
   {
     std::string path = TestHelper::getResourcesFolderLocation() + "not_existing_file.txt";
-    ls::File file{path};
+    ls::std::io::File file{path};
 
     EXPECT_THROW({
                    try
                    {
-                     ls::FileWriter writer{file};
+                     ls::std::io::FileWriter writer{file};
                    }
                    catch (const ls::std::core::FileNotFoundException &_exception)
                    {
@@ -47,15 +47,15 @@ namespace
   TEST_F(FileWriterTest, reset)
   {
     std::string path = TestHelper::getResourcesFolderLocation() + "tmp_file_writer_test.txt";
-    ls::File file{path};
+    ls::std::io::File file{path};
     file.createNewFile();
-    ls::FileWriter writer{file};
+    ls::std::io::FileWriter writer{file};
     ASSERT_TRUE(writer.write("Testing something!\n"));
 
     // reset
 
     path = TestHelper::getResourcesFolderLocation() + "tmp_file_writer_test2.txt";
-    ls::File anotherFile{path};
+    ls::std::io::File anotherFile{path};
     anotherFile.createNewFile();
 
     writer.reset(anotherFile);
@@ -72,13 +72,13 @@ namespace
   TEST_F(FileWriterTest, write)
   {
     std::string path = TestHelper::getResourcesFolderLocation() + "tmp_file_writer_test.txt";
-    ls::File file{path};
+    ls::std::io::File file{path};
 
     ASSERT_FALSE(file.exists());
     file.createNewFile();
     ASSERT_TRUE(file.exists());
 
-    ls::FileWriter writer{file};
+    ls::std::io::FileWriter writer{file};
     ASSERT_TRUE(writer.write("Testing something!\n"));
 
     file.remove();

test/cases/io/StandardOutputWriterTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-09-18
- * Changed:         2022-05-05
+ * Changed:         2022-05-11
  *
  * */
 
@@ -28,7 +28,7 @@ namespace
 
   TEST_F(StandardOutputWriterTest, write)
   {
-    ls::StandardOutputWriter writer{};
+    ls::std::io::StandardOutputWriter writer{};
     ASSERT_TRUE(writer.write("Try something!"));
   }
 }

test/cases/io/StorableFileTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-19
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -31,28 +31,28 @@ namespace
 
   TEST_F(StorableFileTest, getFile)
   {
-    ls::StorableFile storableFile{this->fileLocation};
+    ls::std::io::StorableFile storableFile{this->fileLocation};
     ASSERT_STREQ(this->fileLocation.c_str(), storableFile.getFile()->getAbsoluteFilePath().c_str());
   }
 
   TEST_F(StorableFileTest, load)
   {
-    ls::StorableFile storableFile{this->fileLocation};
+    ls::std::io::StorableFile storableFile{this->fileLocation};
     ls::std::core::byte_field content = storableFile.load();
 
-    std::string expectedUnix = "Hello!" + ls::NewLine::getUnixNewLine();
-    std::string expectedWindows = "Hello!" + ls::NewLine::getWindowsNewLine();
+    std::string expectedUnix = "Hello!" + ls::std::io::NewLine::getUnixNewLine();
+    std::string expectedWindows = "Hello!" + ls::std::io::NewLine::getWindowsNewLine();
 
     ASSERT_TRUE(content == expectedUnix || content == expectedWindows);
   }
 
   TEST_F(StorableFileTest, reset)
   {
-    ls::StorableFile storableFile{this->fileLocation};
+    ls::std::io::StorableFile storableFile{this->fileLocation};
     ls::std::core::byte_field content = storableFile.load();
 
-    std::string expectedUnix = "Hello!" + ls::NewLine::getUnixNewLine();
-    std::string expectedWindows = "Hello!" + ls::NewLine::getWindowsNewLine();
+    std::string expectedUnix = "Hello!" + ls::std::io::NewLine::getUnixNewLine();
+    std::string expectedWindows = "Hello!" + ls::std::io::NewLine::getWindowsNewLine();
 
     ASSERT_TRUE(content == expectedUnix || content == expectedWindows);
 
@@ -62,8 +62,8 @@ namespace
     storableFile.reset(anotherFileLocation);
     content = storableFile.load();
 
-    expectedUnix = "nothing to say!" + ls::NewLine::getUnixNewLine();
-    expectedWindows = "nothing to say!" + ls::NewLine::getWindowsNewLine();
+    expectedUnix = "nothing to say!" + ls::std::io::NewLine::getUnixNewLine();
+    expectedWindows = "nothing to say!" + ls::std::io::NewLine::getWindowsNewLine();
 
     ASSERT_TRUE(content == expectedUnix || content == expectedWindows);
   }
@@ -71,12 +71,12 @@ namespace
   TEST_F(StorableFileTest, save)
   {
     std::string path = TestHelper::getResourcesFolderLocation() + "tmp_storable_file.txt";
-    ls::File file{path};
+    ls::std::io::File file{path};
     file.createNewFile();
 
-    ls::StorableFile storableFile{path};
-    ls::std::core::byte_field textUnix = "Testing save method!" + ls::NewLine::getUnixNewLine();
-    ls::std::core::byte_field textWindows = "Testing save method!" + ls::NewLine::getWindowsNewLine();
+    ls::std::io::StorableFile storableFile{path};
+    ls::std::core::byte_field textUnix = "Testing save method!" + ls::std::io::NewLine::getUnixNewLine();
+    ls::std::core::byte_field textWindows = "Testing save method!" + ls::std::io::NewLine::getWindowsNewLine();
 
     storableFile.save(textUnix);
     ls::std::core::byte_field content = storableFile.load();

test/cases/io/kv/KvDocumentTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-05
+ * Changed:         2022-05-11
  *
  * */
 
@@ -28,8 +28,8 @@ namespace
 
   TEST_F(KvDocumentTest, addPair)
   {
-    ls::KvDocument document{};
-    ls::KvPair pair{"port", "13088"};
+    ls::std::io::KvDocument document{};
+    ls::std::io::KvPair pair{"port", "13088"};
 
     ASSERT_TRUE(document.addPair(pair));
     ASSERT_EQ(1, document.getPairs().size());
@@ -37,8 +37,8 @@ namespace
 
   TEST_F(KvDocumentTest, addPair_retry_to_add_pair)
   {
-    ls::KvDocument document{};
-    ls::KvPair pair{"port", "13088"};
+    ls::std::io::KvDocument document{};
+    ls::std::io::KvPair pair{"port", "13088"};
 
     ASSERT_TRUE(document.addPair(pair));
     ASSERT_FALSE(document.addPair(pair));
@@ -48,8 +48,8 @@ namespace
   {
     // preparation
 
-    ls::KvDocument document{};
-    ls::KvPair pair{"port", "13088"};
+    ls::std::io::KvDocument document{};
+    ls::std::io::KvPair pair{"port", "13088"};
     document.addPair(pair);
 
     // check
@@ -61,21 +61,21 @@ namespace
 
   TEST_F(KvDocumentTest, getPairs)
   {
-    ls::KvDocument document{};
+    ls::std::io::KvDocument document{};
     ASSERT_TRUE(document.getPairs().empty());
   }
 
   TEST_F(KvDocumentTest, hasPair)
   {
-    ls::KvDocument document{};
-    document.addPair(ls::KvPair{"port", "80"});
+    ls::std::io::KvDocument document{};
+    document.addPair(ls::std::io::KvPair{"port", "80"});
 
     ASSERT_TRUE(document.hasPair("port"));
   }
 
   TEST_F(KvDocumentTest, hasPair_no_pairs_available)
   {
-    ls::KvDocument document{};
+    ls::std::io::KvDocument document{};
     ASSERT_FALSE(document.hasPair("port"));
   }
 
@@ -83,10 +83,10 @@ namespace
   {
     // preparation
 
-    ls::KvDocument document{};
-    document.addPair(ls::KvPair{"port", "80"});
-    document.addPair(ls::KvPair{"host", "localhost"});
-    document.addPair(ls::KvPair{"protocol", "TCP"});
+    ls::std::io::KvDocument document{};
+    document.addPair(ls::std::io::KvPair{"port", "80"});
+    document.addPair(ls::std::io::KvPair{"host", "localhost"});
+    document.addPair(ls::std::io::KvPair{"protocol", "TCP"});
 
     // remove pair and check
 
@@ -98,7 +98,7 @@ namespace
 
   TEST_F(KvDocumentTest, removePair_no_pair_available)
   {
-    ls::KvDocument document{};
+    ls::std::io::KvDocument document{};
     ASSERT_FALSE(document.removePair("port"));
   }
 }

test/cases/io/kv/KvFileReaderTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -26,12 +26,12 @@ namespace
       void TearDown() override
       {}
 
-      static std::shared_ptr<ls::KvFileReader> createTestKVFileReader()
+      static std::shared_ptr<ls::std::io::KvFileReader> createTestKVFileReader()
       {
         std::string kvPath = TestHelper::getResourcesFolderLocation() + "server_settings.kv";
-        std::shared_ptr<ls::KvDocument> document = std::make_shared<ls::KvDocument>();
+        std::shared_ptr<ls::std::io::KvDocument> document = std::make_shared<ls::std::io::KvDocument>();
 
-        return std::make_shared<ls::KvFileReader>(document, kvPath);
+        return std::make_shared<ls::std::io::KvFileReader>(document, kvPath);
       }
   };
 
@@ -41,7 +41,7 @@ namespace
                    try
                    {
                      std::string kvPath = TestHelper::getResourcesFolderLocation() + "server_settings.kv";
-                     ls::KvFileReader reader = ls::KvFileReader(nullptr, kvPath);
+                     ls::std::io::KvFileReader reader = ls::std::io::KvFileReader(nullptr, kvPath);
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -55,7 +55,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::KvFileReader reader = ls::KvFileReader(std::make_shared<ls::KvDocument>(), "invalid_path");
+                     ls::std::io::KvFileReader reader = ls::std::io::KvFileReader(std::make_shared<ls::std::io::KvDocument>(), "invalid_path");
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -66,7 +66,7 @@ namespace
 
   TEST_F(KvFileReaderTest, getDocument)
   {
-    const std::shared_ptr<ls::KvFileReader> &reader = createTestKVFileReader();
+    const std::shared_ptr<ls::std::io::KvFileReader> &reader = createTestKVFileReader();
     ASSERT_TRUE(reader->getDocument() != nullptr);
   }
 
@@ -74,12 +74,12 @@ namespace
   {
     // preparation
 
-    const std::shared_ptr<ls::KvFileReader> &reader = createTestKVFileReader();
+    const std::shared_ptr<ls::std::io::KvFileReader> &reader = createTestKVFileReader();
 
     // read file and check
 
     reader->read();
-    const std::shared_ptr<ls::KvDocument> &document = reader->getDocument();
+    const std::shared_ptr<ls::std::io::KvDocument> &document = reader->getDocument();
 
     ASSERT_EQ(3, document->getPairs().size());
     ASSERT_TRUE(document->hasPair("port"));
@@ -93,12 +93,12 @@ namespace
 
   TEST_F(KvFileReaderTest, setFile_no_existing_file)
   {
-    const std::shared_ptr<ls::KvFileReader> &reader = createTestKVFileReader();
+    const std::shared_ptr<ls::std::io::KvFileReader> &reader = createTestKVFileReader();
 
     EXPECT_THROW({
                    try
                    {
-                     reader->setFile(ls::File{"invalid_path"});
+                     reader->setFile(ls::std::io::File{"invalid_path"});
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -111,18 +111,18 @@ namespace
   {
     // preparation
 
-    const std::shared_ptr<ls::KvFileReader> &reader = createTestKVFileReader();
+    const std::shared_ptr<ls::std::io::KvFileReader> &reader = createTestKVFileReader();
 
     // set new document and check
 
-    std::shared_ptr<ls::KvDocument> newDocument = std::make_shared<ls::KvDocument>();
+    std::shared_ptr<ls::std::io::KvDocument> newDocument = std::make_shared<ls::std::io::KvDocument>();
     reader->setDocument(newDocument);
     ASSERT_TRUE(reader->getDocument() == newDocument);
   }
 
   TEST_F(KvFileReaderTest, setDocument_no_reference)
   {
-    const std::shared_ptr<ls::KvFileReader> &reader = createTestKVFileReader();
+    const std::shared_ptr<ls::std::io::KvFileReader> &reader = createTestKVFileReader();
 
     EXPECT_THROW({
                    try

test/cases/io/kv/KvPairTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -32,7 +32,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::KvPair pair = ls::KvPair("", "1989");
+                     ls::std::io::KvPair pair = ls::std::io::KvPair("", "1989");
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -43,19 +43,19 @@ namespace
 
   TEST_F(KvPairTest, getKey)
   {
-    ls::KvPair pair{"port", "13088"};
+    ls::std::io::KvPair pair{"port", "13088"};
     ASSERT_STREQ("port", pair.getKey().c_str());
   }
 
   TEST_F(KvPairTest, getValue)
   {
-    ls::KvPair pair{"port", "13088"};
+    ls::std::io::KvPair pair{"port", "13088"};
     ASSERT_STREQ("13088", pair.getValue().c_str());
   }
 
   TEST_F(KvPairTest, setValue)
   {
-    ls::KvPair pair{"port", "13088"};
+    ls::std::io::KvPair pair{"port", "13088"};
     ASSERT_STREQ("13088", pair.getValue().c_str());
 
     pair.setValue("8080");

test/cases/io/kv/KvParserTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-25
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -31,7 +31,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::KvParser parser{nullptr};
+                     ls::std::io::KvParser parser{nullptr};
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -42,14 +42,14 @@ namespace
 
   TEST_F(KvParserTest, getDocument)
   {
-    ls::KvParser parser{std::make_shared<ls::KvDocument>()};
+    ls::std::io::KvParser parser{std::make_shared<ls::std::io::KvDocument>()};
     ASSERT_TRUE(parser.getDocument() != nullptr);
   }
 
   TEST_F(KvParserTest, parse)
   {
-    std::shared_ptr<ls::KvDocument> document = std::make_shared<ls::KvDocument>();
-    ls::KvParser parser{document};
+    std::shared_ptr<ls::std::io::KvDocument> document = std::make_shared<ls::std::io::KvDocument>();
+    ls::std::io::KvParser parser{document};
     ls::std::core::byte_field data = "# starting comment\n\nport=8080; # some comment\nhost=localhost;\nservice-name=deamon;";
     parser.parse(data);
 
@@ -67,20 +67,20 @@ namespace
   {
     // preparation
 
-    std::shared_ptr<ls::KvDocument> document = std::make_shared<ls::KvDocument>();
-    ls::KvParser parser{document};
+    std::shared_ptr<ls::std::io::KvDocument> document = std::make_shared<ls::std::io::KvDocument>();
+    ls::std::io::KvParser parser{document};
 
     // set and check
 
-    std::shared_ptr<ls::KvDocument> newDocument = std::make_shared<ls::KvDocument>();
+    std::shared_ptr<ls::std::io::KvDocument> newDocument = std::make_shared<ls::std::io::KvDocument>();
     parser.setDocument(newDocument);
     ASSERT_TRUE(parser.getDocument() == newDocument);
   }
 
   TEST_F(KvParserTest, setDocument_no_reference)
   {
-    std::shared_ptr<ls::KvDocument> document = std::make_shared<ls::KvDocument>();
-    ls::KvParser parser{document};
+    std::shared_ptr<ls::std::io::KvDocument> document = std::make_shared<ls::std::io::KvDocument>();
+    ls::std::io::KvParser parser{document};
 
     EXPECT_THROW({
                    try

test/cases/io/logging/LogLevelTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-05-02
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -28,124 +28,124 @@ namespace
 
   TEST_F(LogLevelTest, constructor_with_log_level_value_parameter)
   {
-    ls::LogLevel logLevel{ls::LogLevelValue::INFO};
-    ASSERT_EQ(ls::LogLevelValue::INFO, logLevel);
+    ls::std::io::LogLevel logLevel{ls::std::io::LogLevelValue::INFO};
+    ASSERT_EQ(ls::std::io::LogLevelValue::INFO, logLevel);
   }
 
   TEST_F(LogLevelTest, constructor_default)
   {
-    ls::LogLevel logLevel{};
-    ASSERT_EQ(ls::LogLevelValue::FATAL, logLevel);
+    ls::std::io::LogLevel logLevel{};
+    ASSERT_EQ(ls::std::io::LogLevelValue::FATAL, logLevel);
   }
 
   TEST_F(LogLevelTest, operator_assign)
   {
-    ls::LogLevel logLevel{ls::LogLevelValue::DEBUG};
-    logLevel = ls::LogLevelValue::INFO;
+    ls::std::io::LogLevel logLevel{ls::std::io::LogLevelValue::DEBUG};
+    logLevel = ls::std::io::LogLevelValue::INFO;
 
-    ASSERT_EQ(ls::LogLevelValue::INFO, logLevel);
+    ASSERT_EQ(ls::std::io::LogLevelValue::INFO, logLevel);
   }
 
   TEST_F(LogLevelTest, operator_lessThan)
   {
-    ls::LogLevel logLevel{}; // default is FATAL
+    ls::std::io::LogLevel logLevel{}; // default is FATAL
 
-    ASSERT_TRUE(logLevel < ls::LogLevelValue::ERR);
-    ASSERT_TRUE(logLevel < ls::LogLevelValue::WARN);
-    ASSERT_TRUE(logLevel < ls::LogLevelValue::INFO);
-    ASSERT_TRUE(logLevel < ls::LogLevelValue::DEBUG);
-    ASSERT_TRUE(logLevel < ls::LogLevelValue::TRACE);
+    ASSERT_TRUE(logLevel < ls::std::io::LogLevelValue::ERR);
+    ASSERT_TRUE(logLevel < ls::std::io::LogLevelValue::WARN);
+    ASSERT_TRUE(logLevel < ls::std::io::LogLevelValue::INFO);
+    ASSERT_TRUE(logLevel < ls::std::io::LogLevelValue::DEBUG);
+    ASSERT_TRUE(logLevel < ls::std::io::LogLevelValue::TRACE);
   }
 
   TEST_F(LogLevelTest, operator_lessThan_not_less_than)
   {
-    ls::LogLevel logLevel{ls::LogLevelValue::DEBUG};
-    ASSERT_FALSE(logLevel < ls::LogLevelValue::ERR);
+    ls::std::io::LogLevel logLevel{ls::std::io::LogLevelValue::DEBUG};
+    ASSERT_FALSE(logLevel < ls::std::io::LogLevelValue::ERR);
   }
 
   TEST_F(LogLevelTest, operator_less_than_equals)
   {
-    ls::LogLevel logLevel{}; // default is FATAL
+    ls::std::io::LogLevel logLevel{}; // default is FATAL
 
-    ASSERT_TRUE(logLevel <= ls::LogLevelValue::FATAL);
-    ASSERT_TRUE(logLevel <= ls::LogLevelValue::ERR);
-    ASSERT_TRUE(logLevel <= ls::LogLevelValue::WARN);
-    ASSERT_TRUE(logLevel <= ls::LogLevelValue::INFO);
-    ASSERT_TRUE(logLevel <= ls::LogLevelValue::DEBUG);
-    ASSERT_TRUE(logLevel <= ls::LogLevelValue::TRACE);
+    ASSERT_TRUE(logLevel <= ls::std::io::LogLevelValue::FATAL);
+    ASSERT_TRUE(logLevel <= ls::std::io::LogLevelValue::ERR);
+    ASSERT_TRUE(logLevel <= ls::std::io::LogLevelValue::WARN);
+    ASSERT_TRUE(logLevel <= ls::std::io::LogLevelValue::INFO);
+    ASSERT_TRUE(logLevel <= ls::std::io::LogLevelValue::DEBUG);
+    ASSERT_TRUE(logLevel <= ls::std::io::LogLevelValue::TRACE);
   }
 
   TEST_F(LogLevelTest, operator_less_than_equals_not_less_than_equals)
   {
-    ls::LogLevel logLevel{ls::LogLevelValue::DEBUG};
-    ASSERT_FALSE(logLevel <= ls::LogLevelValue::ERR);
+    ls::std::io::LogLevel logLevel{ls::std::io::LogLevelValue::DEBUG};
+    ASSERT_FALSE(logLevel <= ls::std::io::LogLevelValue::ERR);
   }
 
   TEST_F(LogLevelTest, operator_greater_than)
   {
-    ls::LogLevel logLevel{ls::LogLevelValue::DEBUG};
-    ASSERT_TRUE(logLevel > ls::LogLevelValue::ERR);
+    ls::std::io::LogLevel logLevel{ls::std::io::LogLevelValue::DEBUG};
+    ASSERT_TRUE(logLevel > ls::std::io::LogLevelValue::ERR);
   }
 
   TEST_F(LogLevelTest, operator_greater_than_not_greater_than)
   {
-    ls::LogLevel logLevel{ls::LogLevelValue::DEBUG};
-    ASSERT_FALSE(logLevel > ls::LogLevelValue::DEBUG);
+    ls::std::io::LogLevel logLevel{ls::std::io::LogLevelValue::DEBUG};
+    ASSERT_FALSE(logLevel > ls::std::io::LogLevelValue::DEBUG);
   }
 
   TEST_F(LogLevelTest, operator_greater_than_equals)
   {
-    ls::LogLevel logLevel{ls::LogLevelValue::DEBUG};
-    ASSERT_TRUE(logLevel >= ls::LogLevelValue::ERR);
+    ls::std::io::LogLevel logLevel{ls::std::io::LogLevelValue::DEBUG};
+    ASSERT_TRUE(logLevel >= ls::std::io::LogLevelValue::ERR);
   }
 
   TEST_F(LogLevelTest, operator_greater_than_equals_not_greater_than_equals)
   {
-    ls::LogLevel logLevel{};
-    ASSERT_FALSE(logLevel >= ls::LogLevelValue::ERR);
+    ls::std::io::LogLevel logLevel{};
+    ASSERT_FALSE(logLevel >= ls::std::io::LogLevelValue::ERR);
   }
 
   TEST_F(LogLevelTest, operator_equals)
   {
-    ls::LogLevel logLevel{ls::LogLevelValue::DEBUG};
-    ASSERT_TRUE(logLevel == ls::LogLevelValue::DEBUG);
+    ls::std::io::LogLevel logLevel{ls::std::io::LogLevelValue::DEBUG};
+    ASSERT_TRUE(logLevel == ls::std::io::LogLevelValue::DEBUG);
   }
 
   TEST_F(LogLevelTest, operator_equals_not_equals)
   {
-    ls::LogLevel logLevel{ls::LogLevelValue::TRACE};
-    ASSERT_FALSE(logLevel == ls::LogLevelValue::DEBUG);
+    ls::std::io::LogLevel logLevel{ls::std::io::LogLevelValue::TRACE};
+    ASSERT_FALSE(logLevel == ls::std::io::LogLevelValue::DEBUG);
   }
 
   TEST_F(LogLevelTest, setLogLevel_with_log_level_value)
   {
-    ls::LogLevel logLevel{};
-    logLevel.setLogLevel(ls::LogLevelValue::INFO);
+    ls::std::io::LogLevel logLevel{};
+    logLevel.setLogLevel(ls::std::io::LogLevelValue::INFO);
 
-    ASSERT_EQ(ls::LogLevelValue::INFO, logLevel);
+    ASSERT_EQ(ls::std::io::LogLevelValue::INFO, logLevel);
   }
 
   TEST_F(LogLevelTest, setLogLevel_with_string)
   {
-    ls::LogLevel logLevel{};
+    ls::std::io::LogLevel logLevel{};
 
     logLevel.setLogLevel("FATAL");
-    ASSERT_EQ(ls::LogLevelValue::FATAL, logLevel);
+    ASSERT_EQ(ls::std::io::LogLevelValue::FATAL, logLevel);
     logLevel.setLogLevel("ERROR");
-    ASSERT_EQ(ls::LogLevelValue::ERR, logLevel);
+    ASSERT_EQ(ls::std::io::LogLevelValue::ERR, logLevel);
     logLevel.setLogLevel("WARN");
-    ASSERT_EQ(ls::LogLevelValue::WARN, logLevel);
+    ASSERT_EQ(ls::std::io::LogLevelValue::WARN, logLevel);
     logLevel.setLogLevel("INFO");
-    ASSERT_EQ(ls::LogLevelValue::INFO, logLevel);
+    ASSERT_EQ(ls::std::io::LogLevelValue::INFO, logLevel);
     logLevel.setLogLevel("DEBUG");
-    ASSERT_EQ(ls::LogLevelValue::DEBUG, logLevel);
+    ASSERT_EQ(ls::std::io::LogLevelValue::DEBUG, logLevel);
     logLevel.setLogLevel("TRACE");
-    ASSERT_EQ(ls::LogLevelValue::TRACE, logLevel);
+    ASSERT_EQ(ls::std::io::LogLevelValue::TRACE, logLevel);
   }
 
   TEST_F(LogLevelTest, setLogLevel_string_no_valid_string)
   {
-    ls::LogLevel logLevel{};
+    ls::std::io::LogLevel logLevel{};
 
     EXPECT_THROW({
                    try
@@ -161,17 +161,17 @@ namespace
 
   TEST_F(LogLevelTest, toString)
   {
-    ls::LogLevel logLevel{};
+    ls::std::io::LogLevel logLevel{};
     ASSERT_STREQ("FATAL", logLevel.toString().c_str());
-    logLevel.setLogLevel(ls::LogLevelValue::ERR);
+    logLevel.setLogLevel(ls::std::io::LogLevelValue::ERR);
     ASSERT_STREQ("ERROR", logLevel.toString().c_str());
-    logLevel.setLogLevel(ls::LogLevelValue::WARN);
+    logLevel.setLogLevel(ls::std::io::LogLevelValue::WARN);
     ASSERT_STREQ("WARN", logLevel.toString().c_str());
-    logLevel.setLogLevel(ls::LogLevelValue::INFO);
+    logLevel.setLogLevel(ls::std::io::LogLevelValue::INFO);
     ASSERT_STREQ("INFO", logLevel.toString().c_str());
-    logLevel.setLogLevel(ls::LogLevelValue::DEBUG);
+    logLevel.setLogLevel(ls::std::io::LogLevelValue::DEBUG);
     ASSERT_STREQ("DEBUG", logLevel.toString().c_str());
-    logLevel.setLogLevel(ls::LogLevelValue::TRACE);
+    logLevel.setLogLevel(ls::std::io::LogLevelValue::TRACE);
     ASSERT_STREQ("TRACE", logLevel.toString().c_str());
   }
 }

test/cases/io/logging/LoggerTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-08-20
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -26,25 +26,25 @@ namespace
       void TearDown() override
       {}
 
-      static std::shared_ptr<ls::IWriter> createFileLogger(const std::string &_logName)
+      static std::shared_ptr<ls::std::io::IWriter> createFileLogger(const std::string &_logName)
       {
         std::string path = TestHelper::getResourcesFolderLocation() + _logName;
-        ls::File file{path};
+        ls::std::io::File file{path};
 
         if (!file.exists())
         {
           file.createNewFile();
         }
 
-        std::shared_ptr<ls::IWriter> writer = std::dynamic_pointer_cast<ls::IWriter>(std::make_shared<ls::FileOutputStream>(file));
+        std::shared_ptr<ls::std::io::IWriter> writer = std::dynamic_pointer_cast<ls::std::io::IWriter>(std::make_shared<ls::std::io::FileOutputStream>(file));
 
         return writer;
       }
 
       static ls::std::boxing::String getContentFromLogFile(const std::string &_logName)
       {
-        ls::File file{TestHelper::getResourcesFolderLocation() + _logName};
-        ls::FileReader reader{file};
+        ls::std::io::File file{TestHelper::getResourcesFolderLocation() + _logName};
+        ls::std::io::FileReader reader{file};
         ls::std::boxing::String content{reader.read()};
         file.remove();
 
@@ -57,7 +57,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::Logger logger{nullptr};
+                     ls::std::io::Logger logger{nullptr};
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -71,10 +71,10 @@ namespace
     // write to log file
 
     std::string logName = "output_debug.log";
-    std::shared_ptr<ls::IWriter> writer = createFileLogger(logName);
+    std::shared_ptr<ls::std::io::IWriter> writer = createFileLogger(logName);
 
-    ls::Logger logger{writer};
-    logger.setLogLevel(ls::LogLevelValue::DEBUG);
+    ls::std::io::Logger logger{writer};
+    logger.setLogLevel(ls::std::io::LogLevelValue::DEBUG);
     logger.debug("1. line!");
     logger.info("2. line!");
     logger.error("3. line!");
@@ -84,7 +84,7 @@ namespace
 
     // get content and check
 
-    std::dynamic_pointer_cast<ls::FileOutputStream>(writer)->close();
+    std::dynamic_pointer_cast<ls::std::io::FileOutputStream>(writer)->close();
     ls::std::boxing::String content = getContentFromLogFile(logName);
 
     ASSERT_TRUE(content.contains("1. line!"));
@@ -100,10 +100,10 @@ namespace
     // write to log file
 
     std::string logName = "output_error.log";
-    std::shared_ptr<ls::IWriter> writer = createFileLogger(logName);
+    std::shared_ptr<ls::std::io::IWriter> writer = createFileLogger(logName);
 
-    ls::Logger logger{writer};
-    logger.setLogLevel(ls::LogLevelValue::ERR);
+    ls::std::io::Logger logger{writer};
+    logger.setLogLevel(ls::std::io::LogLevelValue::ERR);
     logger.debug("1. line!");
     logger.info("2. line!");
     logger.error("3. line!");
@@ -113,7 +113,7 @@ namespace
 
     // get content and check
 
-    std::dynamic_pointer_cast<ls::FileOutputStream>(writer)->close();
+    std::dynamic_pointer_cast<ls::std::io::FileOutputStream>(writer)->close();
     ls::std::boxing::String content = getContentFromLogFile(logName);
 
     ASSERT_FALSE(content.contains("1. line!"));
@@ -129,10 +129,10 @@ namespace
     // write to log file
 
     std::string logName = "output_fatal.log";
-    std::shared_ptr<ls::IWriter> writer = createFileLogger(logName);
+    std::shared_ptr<ls::std::io::IWriter> writer = createFileLogger(logName);
 
-    ls::Logger logger{writer};
-    logger.setLogLevel(ls::LogLevelValue::FATAL);
+    ls::std::io::Logger logger{writer};
+    logger.setLogLevel(ls::std::io::LogLevelValue::FATAL);
     logger.debug("1. line!");
     logger.info("2. line!");
     logger.error("3. line!");
@@ -142,7 +142,7 @@ namespace
 
     // get content and check
 
-    std::dynamic_pointer_cast<ls::FileOutputStream>(writer)->close();
+    std::dynamic_pointer_cast<ls::std::io::FileOutputStream>(writer)->close();
     ls::std::boxing::String content = getContentFromLogFile(logName);
 
     ASSERT_FALSE(content.contains("1. line!"));
@@ -155,8 +155,8 @@ namespace
 
   TEST_F(LoggerTest, getLogLevel)
   {
-    ls::Logger logger{createFileLogger("output.log")};
-    ASSERT_EQ(ls::LogLevelValue::INFO, logger.getLogLevel());
+    ls::std::io::Logger logger{createFileLogger("output.log")};
+    ASSERT_EQ(ls::std::io::LogLevelValue::INFO, logger.getLogLevel());
   }
 
   TEST_F(LoggerTest, info)
@@ -164,10 +164,10 @@ namespace
     // write to log file
 
     std::string logName = "output_info.log";
-    std::shared_ptr<ls::IWriter> writer = createFileLogger(logName);
+    std::shared_ptr<ls::std::io::IWriter> writer = createFileLogger(logName);
 
-    ls::Logger logger{writer};
-    logger.setLogLevel(ls::LogLevelValue::INFO);
+    ls::std::io::Logger logger{writer};
+    logger.setLogLevel(ls::std::io::LogLevelValue::INFO);
     logger.fatal("1. line!");
     logger.error("2. line!");
     logger.warn("3. line!");
@@ -177,7 +177,7 @@ namespace
 
     // get content and check
 
-    std::dynamic_pointer_cast<ls::FileOutputStream>(writer)->close();
+    std::dynamic_pointer_cast<ls::std::io::FileOutputStream>(writer)->close();
     ls::std::boxing::String content = getContentFromLogFile(logName);
 
     ASSERT_TRUE(content.contains("1. line!"));
@@ -190,10 +190,10 @@ namespace
 
   TEST_F(LoggerTest, setLogLevel)
   {
-    ls::Logger logger{createFileLogger("output.log")};
-    logger.setLogLevel(ls::LogLevelValue::ERR);
+    ls::std::io::Logger logger{createFileLogger("output.log")};
+    logger.setLogLevel(ls::std::io::LogLevelValue::ERR);
 
-    ASSERT_EQ(ls::LogLevelValue::ERR, logger.getLogLevel());
+    ASSERT_EQ(ls::std::io::LogLevelValue::ERR, logger.getLogLevel());
   }
 
   TEST_F(LoggerTest, trace)
@@ -201,10 +201,10 @@ namespace
     // write to log file
 
     std::string logName = "output_trace.log";
-    std::shared_ptr<ls::IWriter> writer = createFileLogger(logName);
+    std::shared_ptr<ls::std::io::IWriter> writer = createFileLogger(logName);
 
-    ls::Logger logger{writer};
-    logger.setLogLevel(ls::LogLevelValue::TRACE);
+    ls::std::io::Logger logger{writer};
+    logger.setLogLevel(ls::std::io::LogLevelValue::TRACE);
     logger.fatal("1. line!");
     logger.error("2. line!");
     logger.warn("3. line!");
@@ -214,7 +214,7 @@ namespace
 
     // get content and check
 
-    std::dynamic_pointer_cast<ls::FileOutputStream>(writer)->close();
+    std::dynamic_pointer_cast<ls::std::io::FileOutputStream>(writer)->close();
     ls::std::boxing::String content = getContentFromLogFile(logName);
 
     ASSERT_TRUE(content.contains("1. line!"));
@@ -230,10 +230,10 @@ namespace
     // write to log file
 
     std::string logName = "output_warn.log";
-    std::shared_ptr<ls::IWriter> writer = createFileLogger(logName);
+    std::shared_ptr<ls::std::io::IWriter> writer = createFileLogger(logName);
 
-    ls::Logger logger{writer};
-    logger.setLogLevel(ls::LogLevelValue::WARN);
+    ls::std::io::Logger logger{writer};
+    logger.setLogLevel(ls::std::io::LogLevelValue::WARN);
     logger.fatal("1. line!");
     logger.error("2. line!");
     logger.warn("3. line!");
@@ -243,7 +243,7 @@ namespace
 
     // get content and check
 
-    std::dynamic_pointer_cast<ls::FileOutputStream>(writer)->close();
+    std::dynamic_pointer_cast<ls::std::io::FileOutputStream>(writer)->close();
     ls::std::boxing::String content = getContentFromLogFile(logName);
 
     ASSERT_TRUE(content.contains("1. line!"));

test/cases/io/xml/XmlAttributeTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-23
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -31,7 +31,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::XmlAttribute attribute{""};
+                     ls::std::io::XmlAttribute attribute{""};
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -42,19 +42,19 @@ namespace
 
   TEST_F(XmlAttributeTest, getName)
   {
-    ls::XmlAttribute attribute{"id"};
+    ls::std::io::XmlAttribute attribute{"id"};
     ASSERT_STREQ("id", attribute.getName().c_str());
   }
 
   TEST_F(XmlAttributeTest, getValue)
   {
-    ls::XmlAttribute attribute{"id"};
+    ls::std::io::XmlAttribute attribute{"id"};
     ASSERT_TRUE(attribute.getValue().empty());
   }
 
   TEST_F(XmlAttributeTest, setName)
   {
-    ls::XmlAttribute attribute{"id"};
+    ls::std::io::XmlAttribute attribute{"id"};
     attribute.setName("id2");
 
     ASSERT_STREQ("id2", attribute.getName().c_str());
@@ -65,7 +65,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::XmlAttribute attribute{"id"};
+                     ls::std::io::XmlAttribute attribute{"id"};
                      attribute.setName("");
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
@@ -77,7 +77,7 @@ namespace
 
   TEST_F(XmlAttributeTest, setValue)
   {
-    ls::XmlAttribute attribute{"id"};
+    ls::std::io::XmlAttribute attribute{"id"};
     attribute.setValue("some_content");
 
     ASSERT_STREQ("some_content", attribute.getValue().c_str());
@@ -88,7 +88,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::XmlAttribute attribute{"id"};
+                     ls::std::io::XmlAttribute attribute{"id"};
                      attribute.setValue("");
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
@@ -100,7 +100,7 @@ namespace
 
   TEST_F(XmlAttributeTest, toXml)
   {
-    ls::XmlAttribute attribute{"id"};
+    ls::std::io::XmlAttribute attribute{"id"};
     attribute.setValue("some_content");
 
     ASSERT_STREQ(R"(id="some_content")", attribute.toXml().c_str());

test/cases/io/xml/XmlDeclarationTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-29
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -31,7 +31,7 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::XmlDeclaration declaration{""};
+                     ls::std::io::XmlDeclaration declaration{""};
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -42,25 +42,25 @@ namespace
 
   TEST_F(XmlDeclarationTest, getEncoding)
   {
-    ls::XmlDeclaration declaration{"1.0"};
+    ls::std::io::XmlDeclaration declaration{"1.0"};
     ASSERT_TRUE(declaration.getEncoding().empty());
   }
 
   TEST_F(XmlDeclarationTest, getStandalone)
   {
-    ls::XmlDeclaration declaration{"1.0"};
+    ls::std::io::XmlDeclaration declaration{"1.0"};
     ASSERT_TRUE(declaration.getStandalone().empty());
   }
 
   TEST_F(XmlDeclarationTest, getVersion)
   {
-    ls::XmlDeclaration declaration{"1.0"};
+    ls::std::io::XmlDeclaration declaration{"1.0"};
     ASSERT_STREQ("1.0", declaration.getVersion().c_str());
   }
 
   TEST_F(XmlDeclarationTest, setEncoding)
   {
-    ls::XmlDeclaration declaration{"1.0"};
+    ls::std::io::XmlDeclaration declaration{"1.0"};
 
     ASSERT_TRUE(declaration.getEncoding().empty());
 
@@ -70,7 +70,7 @@ namespace
 
   TEST_F(XmlDeclarationTest, setEncoding_empty_encoding)
   {
-    ls::XmlDeclaration declaration{"1.0"};
+    ls::std::io::XmlDeclaration declaration{"1.0"};
 
     EXPECT_THROW({
                    try
@@ -86,7 +86,7 @@ namespace
 
   TEST_F(XmlDeclarationTest, setStandalone)
   {
-    ls::XmlDeclaration declaration{"1.0"};
+    ls::std::io::XmlDeclaration declaration{"1.0"};
 
     ASSERT_TRUE(declaration.getStandalone().empty());
 
@@ -96,7 +96,7 @@ namespace
 
   TEST_F(XmlDeclarationTest, setStandalone_empty_standalone)
   {
-    ls::XmlDeclaration declaration{"1.0"};
+    ls::std::io::XmlDeclaration declaration{"1.0"};
 
     EXPECT_THROW({
                    try
@@ -112,7 +112,7 @@ namespace
 
   TEST_F(XmlDeclarationTest, setVersion)
   {
-    ls::XmlDeclaration declaration{"1.0"};
+    ls::std::io::XmlDeclaration declaration{"1.0"};
 
     ASSERT_FALSE(declaration.getVersion().empty());
     ASSERT_STREQ("1.0", declaration.getVersion().c_str());
@@ -123,7 +123,7 @@ namespace
 
   TEST_F(XmlDeclarationTest, setVersion_empty_version)
   {
-    ls::XmlDeclaration declaration{"1.0"};
+    ls::std::io::XmlDeclaration declaration{"1.0"};
 
     EXPECT_THROW({
                    try
@@ -139,7 +139,7 @@ namespace
 
   TEST_F(XmlDeclarationTest, toXml)
   {
-    ls::XmlDeclaration declaration{"1.0"};
+    ls::std::io::XmlDeclaration declaration{"1.0"};
     ASSERT_STREQ(R"(<?xml version="1.0" ?>)", declaration.toXml().c_str());
 
     declaration.setStandalone("yes");

test/cases/io/xml/XmlDocumentTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-30
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -29,30 +29,30 @@ namespace
 
   TEST_F(XmlDocumentTest, getDeclaration)
   {
-    ls::XmlDocument document{};
+    ls::std::io::XmlDocument document{};
     ASSERT_TRUE(document.getDeclaration() == nullptr);
   }
 
   TEST_F(XmlDocumentTest, getRootElement)
   {
-    ls::XmlDocument document{};
+    ls::std::io::XmlDocument document{};
     ASSERT_TRUE(document.getRootElement() == nullptr);
   }
 
   TEST_F(XmlDocumentTest, setDeclaration)
   {
-    ls::XmlDocument document{};
+    ls::std::io::XmlDocument document{};
     ASSERT_TRUE(document.getDeclaration() == nullptr);
 
-    ls::XmlDeclaration declaration{"1.0"};
-    document.setDeclaration(std::make_shared<ls::XmlDeclaration>(declaration));
+    ls::std::io::XmlDeclaration declaration{"1.0"};
+    document.setDeclaration(std::make_shared<ls::std::io::XmlDeclaration>(declaration));
     ASSERT_TRUE(document.getDeclaration() != nullptr);
     ASSERT_STREQ("1.0", document.getDeclaration()->getVersion().c_str());
   }
 
   TEST_F(XmlDocumentTest, setDeclaration_no_reference)
   {
-    ls::XmlDocument document{};
+    ls::std::io::XmlDocument document{};
 
     EXPECT_THROW({
                    try
@@ -68,10 +68,10 @@ namespace
 
   TEST_F(XmlDocumentTest, setRootElement)
   {
-    ls::XmlDocument document{};
+    ls::std::io::XmlDocument document{};
     ASSERT_TRUE(document.getRootElement() == nullptr);
 
-    ls::XmlDeclaration declaration{"1.0"};
+    ls::std::io::XmlDeclaration declaration{"1.0"};
     document.setRootElement(ls_std_test::TestDataFactory::createXmlContent());
     ASSERT_TRUE(document.getRootElement() != nullptr);
     ASSERT_STREQ("dialog", document.getRootElement()->getName().c_str());
@@ -79,7 +79,7 @@ namespace
 
   TEST_F(XmlDocumentTest, setRootElement_no_reference)
   {
-    ls::XmlDocument document{};
+    ls::std::io::XmlDocument document{};
 
     EXPECT_THROW({
                    try
@@ -95,12 +95,12 @@ namespace
 
   TEST_F(XmlDocumentTest, toXml)
   {
-    ls::XmlDocument document{};
+    ls::std::io::XmlDocument document{};
 
-    ls::XmlDeclaration declaration{"1.0"};
+    ls::std::io::XmlDeclaration declaration{"1.0"};
     declaration.setEncoding("UTF-8");
     declaration.setStandalone("yes");
-    document.setDeclaration(std::make_shared<ls::XmlDeclaration>(declaration));
+    document.setDeclaration(std::make_shared<ls::std::io::XmlDeclaration>(declaration));
 
     document.setRootElement(ls_std_test::TestDataFactory::createXmlContent());
     std::string xmlStream = document.toXml();

test/cases/io/xml/XmlNodeTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-25
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -29,10 +29,10 @@ namespace
 
   TEST_F(XmlNodeTest, addAttributeAfter)
   {
-    ls::XmlNode dialogNode{"dialog"};
-    std::shared_ptr<ls::XmlAttribute> currentAttribute{};
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("events"));
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("assets"));
+    ls::std::io::XmlNode dialogNode{"dialog"};
+    std::shared_ptr<ls::std::io::XmlAttribute> currentAttribute{};
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("events"));
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("assets"));
 
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 0);
     ASSERT_STREQ("events", currentAttribute->getName().c_str());
@@ -41,7 +41,7 @@ namespace
 
     // add id after events
 
-    ASSERT_TRUE(dialogNode.addAttributeAfter(std::make_shared<ls::XmlAttribute>("id"), "events"));
+    ASSERT_TRUE(dialogNode.addAttributeAfter(std::make_shared<ls::std::io::XmlAttribute>("id"), "events"));
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 0);
     ASSERT_STREQ("events", currentAttribute->getName().c_str());
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 1);
@@ -51,7 +51,7 @@ namespace
 
     // add tasks after assets
 
-    ASSERT_TRUE(dialogNode.addAttributeAfter(std::make_shared<ls::XmlAttribute>("tasks"), "assets"));
+    ASSERT_TRUE(dialogNode.addAttributeAfter(std::make_shared<ls::std::io::XmlAttribute>("tasks"), "assets"));
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 0);
     ASSERT_STREQ("events", currentAttribute->getName().c_str());
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 1);
@@ -64,13 +64,13 @@ namespace
 
   TEST_F(XmlNodeTest, addAttributeAfter_name_not_found)
   {
-    ls::XmlNode dialogNode{"dialog"};
-    ASSERT_FALSE(dialogNode.addAttributeAfter(std::make_shared<ls::XmlAttribute>("id"), "events"));
+    ls::std::io::XmlNode dialogNode{"dialog"};
+    ASSERT_FALSE(dialogNode.addAttributeAfter(std::make_shared<ls::std::io::XmlAttribute>("id"), "events"));
   }
 
   TEST_F(XmlNodeTest, addAttributeAfter_no_reference)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
@@ -86,12 +86,12 @@ namespace
 
   TEST_F(XmlNodeTest, addAttributeAfter_empty_name)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
                    {
-                     dialogNode.addAttributeAfter(std::make_shared<ls::XmlAttribute>("id"), "");
+                     dialogNode.addAttributeAfter(std::make_shared<ls::std::io::XmlAttribute>("id"), "");
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -102,10 +102,10 @@ namespace
 
   TEST_F(XmlNodeTest, addAttributeBefore)
   {
-    ls::XmlNode dialogNode{"dialog"};
-    std::shared_ptr<ls::XmlAttribute> currentAttribute{};
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("events"));
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("assets"));
+    ls::std::io::XmlNode dialogNode{"dialog"};
+    std::shared_ptr<ls::std::io::XmlAttribute> currentAttribute{};
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("events"));
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("assets"));
 
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 0);
     ASSERT_STREQ("events", currentAttribute->getName().c_str());
@@ -114,7 +114,7 @@ namespace
 
     // add id before events
 
-    ASSERT_TRUE(dialogNode.addAttributeBefore(std::make_shared<ls::XmlAttribute>("id"), "events"));
+    ASSERT_TRUE(dialogNode.addAttributeBefore(std::make_shared<ls::std::io::XmlAttribute>("id"), "events"));
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 0);
     ASSERT_STREQ("id", currentAttribute->getName().c_str());
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 1);
@@ -124,7 +124,7 @@ namespace
 
     // add tasks before assets
 
-    ASSERT_TRUE(dialogNode.addAttributeBefore(std::make_shared<ls::XmlAttribute>("tasks"), "assets"));
+    ASSERT_TRUE(dialogNode.addAttributeBefore(std::make_shared<ls::std::io::XmlAttribute>("tasks"), "assets"));
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 0);
     ASSERT_STREQ("id", currentAttribute->getName().c_str());
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 1);
@@ -137,13 +137,13 @@ namespace
 
   TEST_F(XmlNodeTest, addAttributeBefore_name_not_found)
   {
-    ls::XmlNode dialogNode{"dialog"};
-    ASSERT_FALSE(dialogNode.addAttributeBefore(std::make_shared<ls::XmlAttribute>("tasks"), "assets"));
+    ls::std::io::XmlNode dialogNode{"dialog"};
+    ASSERT_FALSE(dialogNode.addAttributeBefore(std::make_shared<ls::std::io::XmlAttribute>("tasks"), "assets"));
   }
 
   TEST_F(XmlNodeTest, addAttributeBefore_no_reference)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
@@ -159,12 +159,12 @@ namespace
 
   TEST_F(XmlNodeTest, addAttributeBefore_empty_name)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
                    {
-                     dialogNode.addAttributeBefore(std::make_shared<ls::XmlAttribute>("id"), "");
+                     dialogNode.addAttributeBefore(std::make_shared<ls::std::io::XmlAttribute>("id"), "");
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -175,22 +175,22 @@ namespace
 
   TEST_F(XmlNodeTest, addAttributeToBeginning)
   {
-    ls::XmlNode dialogNode{"dialog"};
-    std::shared_ptr<ls::XmlAttribute> currentAttribute{};
+    ls::std::io::XmlNode dialogNode{"dialog"};
+    std::shared_ptr<ls::std::io::XmlAttribute> currentAttribute{};
 
-    dialogNode.addAttributeToBeginning(std::make_shared<ls::XmlAttribute>("id"));
+    dialogNode.addAttributeToBeginning(std::make_shared<ls::std::io::XmlAttribute>("id"));
     ASSERT_EQ(1, dialogNode.getAttributes().size());
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 0);
     ASSERT_STREQ("id", currentAttribute->getName().c_str());
 
-    dialogNode.addAttributeToBeginning(std::make_shared<ls::XmlAttribute>("assets"));
+    dialogNode.addAttributeToBeginning(std::make_shared<ls::std::io::XmlAttribute>("assets"));
     ASSERT_EQ(2, dialogNode.getAttributes().size());
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 0);
     ASSERT_STREQ("assets", currentAttribute->getName().c_str());
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 1);
     ASSERT_STREQ("id", currentAttribute->getName().c_str());
 
-    dialogNode.addAttributeToBeginning(std::make_shared<ls::XmlAttribute>("events"));
+    dialogNode.addAttributeToBeginning(std::make_shared<ls::std::io::XmlAttribute>("events"));
     ASSERT_EQ(3, dialogNode.getAttributes().size());
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 0);
     ASSERT_STREQ("events", currentAttribute->getName().c_str());
@@ -202,7 +202,7 @@ namespace
 
   TEST_F(XmlNodeTest, addAttributeToBeginning_no_reference)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
@@ -218,22 +218,22 @@ namespace
 
   TEST_F(XmlNodeTest, addAttributeToEnd)
   {
-    ls::XmlNode dialogNode{"dialog"};
-    std::shared_ptr<ls::XmlAttribute> currentAttribute{};
+    ls::std::io::XmlNode dialogNode{"dialog"};
+    std::shared_ptr<ls::std::io::XmlAttribute> currentAttribute{};
 
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("id"));
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("id"));
     ASSERT_EQ(1, dialogNode.getAttributes().size());
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 0);
     ASSERT_STREQ("id", currentAttribute->getName().c_str());
 
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("assets"));
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("assets"));
     ASSERT_EQ(2, dialogNode.getAttributes().size());
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 0);
     ASSERT_STREQ("id", currentAttribute->getName().c_str());
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 1);
     ASSERT_STREQ("assets", currentAttribute->getName().c_str());
 
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("events"));
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("events"));
     ASSERT_EQ(3, dialogNode.getAttributes().size());
     currentAttribute = *std::next(dialogNode.getAttributes().begin(), 0);
     ASSERT_STREQ("id", currentAttribute->getName().c_str());
@@ -245,7 +245,7 @@ namespace
 
   TEST_F(XmlNodeTest, addAttributeToEnd_no_reference)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
@@ -261,12 +261,12 @@ namespace
 
   TEST_F(XmlNodeTest, addChildAfter)
   {
-    ls::XmlNode dialogsNode{"dialogs"};
-    std::shared_ptr<ls::XmlNode> currentNode{};
-    std::shared_ptr<ls::XmlNode> dialogNodeA = std::make_shared<ls::XmlNode>("dialogNodeA");
-    std::shared_ptr<ls::XmlNode> dialogNodeB = std::make_shared<ls::XmlNode>("dialogNodeB");
-    std::shared_ptr<ls::XmlNode> dialogNodeC = std::make_shared<ls::XmlNode>("dialogNodeC");
-    std::shared_ptr<ls::XmlNode> dialogNodeD = std::make_shared<ls::XmlNode>("dialogNodeD");
+    ls::std::io::XmlNode dialogsNode{"dialogs"};
+    std::shared_ptr<ls::std::io::XmlNode> currentNode{};
+    std::shared_ptr<ls::std::io::XmlNode> dialogNodeA = std::make_shared<ls::std::io::XmlNode>("dialogNodeA");
+    std::shared_ptr<ls::std::io::XmlNode> dialogNodeB = std::make_shared<ls::std::io::XmlNode>("dialogNodeB");
+    std::shared_ptr<ls::std::io::XmlNode> dialogNodeC = std::make_shared<ls::std::io::XmlNode>("dialogNodeC");
+    std::shared_ptr<ls::std::io::XmlNode> dialogNodeD = std::make_shared<ls::std::io::XmlNode>("dialogNodeD");
 
     ASSERT_TRUE(dialogsNode.addChildToEnd(dialogNodeB));
     ASSERT_TRUE(dialogsNode.addChildToEnd(dialogNodeC));
@@ -303,21 +303,21 @@ namespace
 
   TEST_F(XmlNodeTest, addChildAfter_no_search_node_available)
   {
-    ls::XmlNode dialogsNode{"dialogs"};
-    std::shared_ptr<ls::XmlNode> newChild = std::make_shared<ls::XmlNode>("newChild");
-    std::shared_ptr<ls::XmlNode> searchNode = std::make_shared<ls::XmlNode>("searchNode");
+    ls::std::io::XmlNode dialogsNode{"dialogs"};
+    std::shared_ptr<ls::std::io::XmlNode> newChild = std::make_shared<ls::std::io::XmlNode>("newChild");
+    std::shared_ptr<ls::std::io::XmlNode> searchNode = std::make_shared<ls::std::io::XmlNode>("searchNode");
 
     ASSERT_FALSE(dialogsNode.addChildAfter(newChild, searchNode));
   }
 
   TEST_F(XmlNodeTest, addChildAfter_no_child_reference)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
                    {
-                     dialogNode.addChildAfter(nullptr, std::make_shared<ls::XmlNode>("children"));
+                     dialogNode.addChildAfter(nullptr, std::make_shared<ls::std::io::XmlNode>("children"));
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -328,12 +328,12 @@ namespace
 
   TEST_F(XmlNodeTest, addChildAfter_no_search_reference)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
                    {
-                     dialogNode.addChildAfter(std::make_shared<ls::XmlNode>("newChild"), nullptr);
+                     dialogNode.addChildAfter(std::make_shared<ls::std::io::XmlNode>("newChild"), nullptr);
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -344,12 +344,12 @@ namespace
 
   TEST_F(XmlNodeTest, addChildBefore)
   {
-    ls::XmlNode dialogsNode{"dialogs"};
-    std::shared_ptr<ls::XmlNode> currentNode{};
-    std::shared_ptr<ls::XmlNode> dialogNodeA = std::make_shared<ls::XmlNode>("dialogNodeA");
-    std::shared_ptr<ls::XmlNode> dialogNodeB = std::make_shared<ls::XmlNode>("dialogNodeB");
-    std::shared_ptr<ls::XmlNode> dialogNodeC = std::make_shared<ls::XmlNode>("dialogNodeC");
-    std::shared_ptr<ls::XmlNode> dialogNodeD = std::make_shared<ls::XmlNode>("dialogNodeD");
+    ls::std::io::XmlNode dialogsNode{"dialogs"};
+    std::shared_ptr<ls::std::io::XmlNode> currentNode{};
+    std::shared_ptr<ls::std::io::XmlNode> dialogNodeA = std::make_shared<ls::std::io::XmlNode>("dialogNodeA");
+    std::shared_ptr<ls::std::io::XmlNode> dialogNodeB = std::make_shared<ls::std::io::XmlNode>("dialogNodeB");
+    std::shared_ptr<ls::std::io::XmlNode> dialogNodeC = std::make_shared<ls::std::io::XmlNode>("dialogNodeC");
+    std::shared_ptr<ls::std::io::XmlNode> dialogNodeD = std::make_shared<ls::std::io::XmlNode>("dialogNodeD");
 
     ASSERT_TRUE(dialogsNode.addChildToEnd(dialogNodeB));
     ASSERT_TRUE(dialogsNode.addChildToEnd(dialogNodeC));
@@ -386,21 +386,21 @@ namespace
 
   TEST_F(XmlNodeTest, addChildBefore_no_search_node_available)
   {
-    ls::XmlNode dialogsNode{"dialogs"};
-    std::shared_ptr<ls::XmlNode> newChild = std::make_shared<ls::XmlNode>("newChild");
-    std::shared_ptr<ls::XmlNode> searchNode = std::make_shared<ls::XmlNode>("searchNode");
+    ls::std::io::XmlNode dialogsNode{"dialogs"};
+    std::shared_ptr<ls::std::io::XmlNode> newChild = std::make_shared<ls::std::io::XmlNode>("newChild");
+    std::shared_ptr<ls::std::io::XmlNode> searchNode = std::make_shared<ls::std::io::XmlNode>("searchNode");
 
     ASSERT_FALSE(dialogsNode.addChildBefore(newChild, searchNode));
   }
 
   TEST_F(XmlNodeTest, addChildBefore_no_child_reference)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
                    {
-                     dialogNode.addChildBefore(nullptr, std::make_shared<ls::XmlNode>("children"));
+                     dialogNode.addChildBefore(nullptr, std::make_shared<ls::std::io::XmlNode>("children"));
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -411,12 +411,12 @@ namespace
 
   TEST_F(XmlNodeTest, addChildBefore_no_search_reference)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
                    {
-                     dialogNode.addChildBefore(std::make_shared<ls::XmlNode>("newChild"), nullptr);
+                     dialogNode.addChildBefore(std::make_shared<ls::std::io::XmlNode>("newChild"), nullptr);
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -427,19 +427,19 @@ namespace
 
   TEST_F(XmlNodeTest, addChildToBeginning)
   {
-    ls::XmlNode dialogsNode{"dialogs"};
-    std::shared_ptr<ls::XmlNode> currentNode{};
+    ls::std::io::XmlNode dialogsNode{"dialogs"};
+    std::shared_ptr<ls::std::io::XmlNode> currentNode{};
 
-    ls::XmlNode dialogNodeA{"dialogNodeA"};
-    ls::XmlNode dialogNodeB{"dialogNodeB"};
-    ls::XmlNode dialogNodeC{"dialogNodeC"};
+    ls::std::io::XmlNode dialogNodeA{"dialogNodeA"};
+    ls::std::io::XmlNode dialogNodeB{"dialogNodeB"};
+    ls::std::io::XmlNode dialogNodeC{"dialogNodeC"};
 
     ASSERT_TRUE(dialogsNode.getChildren().empty());
     ASSERT_EQ(0, dialogsNode.getChildren().size());
 
     // adding C
 
-    ASSERT_TRUE(dialogsNode.addChildToBeginning(std::make_shared<ls::XmlNode>(dialogNodeC)));
+    ASSERT_TRUE(dialogsNode.addChildToBeginning(std::make_shared<ls::std::io::XmlNode>(dialogNodeC)));
     ASSERT_TRUE(!dialogsNode.getChildren().empty());
     ASSERT_EQ(1, dialogsNode.getChildren().size());
 
@@ -448,7 +448,7 @@ namespace
 
     // adding B
 
-    ASSERT_TRUE(dialogsNode.addChildToBeginning(std::make_shared<ls::XmlNode>(dialogNodeB)));
+    ASSERT_TRUE(dialogsNode.addChildToBeginning(std::make_shared<ls::std::io::XmlNode>(dialogNodeB)));
     ASSERT_EQ(2, dialogsNode.getChildren().size());
     currentNode = *std::next(dialogsNode.getChildren().begin(), 0);
     ASSERT_STREQ("dialogNodeB", currentNode->getName().c_str());
@@ -457,7 +457,7 @@ namespace
 
     // adding A
 
-    ASSERT_TRUE(dialogsNode.addChildToBeginning(std::make_shared<ls::XmlNode>(dialogNodeA)));
+    ASSERT_TRUE(dialogsNode.addChildToBeginning(std::make_shared<ls::std::io::XmlNode>(dialogNodeA)));
     ASSERT_EQ(3, dialogsNode.getChildren().size());
     currentNode = *std::next(dialogsNode.getChildren().begin(), 0);
     ASSERT_STREQ("dialogNodeA", currentNode->getName().c_str());
@@ -469,7 +469,7 @@ namespace
 
   TEST_F(XmlNodeTest, addChildToBeginning_no_child_reference)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
@@ -485,19 +485,19 @@ namespace
 
   TEST_F(XmlNodeTest, addChildToEnd)
   {
-    ls::XmlNode dialogsNode{"dialogs"};
-    std::shared_ptr<ls::XmlNode> currentNode{};
+    ls::std::io::XmlNode dialogsNode{"dialogs"};
+    std::shared_ptr<ls::std::io::XmlNode> currentNode{};
 
-    ls::XmlNode dialogNodeA{"dialogNodeA"};
-    ls::XmlNode dialogNodeB{"dialogNodeB"};
-    ls::XmlNode dialogNodeC{"dialogNodeC"};
+    ls::std::io::XmlNode dialogNodeA{"dialogNodeA"};
+    ls::std::io::XmlNode dialogNodeB{"dialogNodeB"};
+    ls::std::io::XmlNode dialogNodeC{"dialogNodeC"};
 
     ASSERT_TRUE(dialogsNode.getChildren().empty());
     ASSERT_EQ(0, dialogsNode.getChildren().size());
 
     // adding C
 
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>(dialogNodeC)));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>(dialogNodeC)));
     ASSERT_TRUE(!dialogsNode.getChildren().empty());
     ASSERT_EQ(1, dialogsNode.getChildren().size());
 
@@ -506,7 +506,7 @@ namespace
 
     // adding B
 
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>(dialogNodeB)));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>(dialogNodeB)));
     ASSERT_EQ(2, dialogsNode.getChildren().size());
     currentNode = *std::next(dialogsNode.getChildren().begin(), 0);
     ASSERT_STREQ("dialogNodeC", currentNode->getName().c_str());
@@ -515,7 +515,7 @@ namespace
 
     // adding A
 
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>(dialogNodeA)));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>(dialogNodeA)));
     ASSERT_EQ(3, dialogsNode.getChildren().size());
     currentNode = *std::next(dialogsNode.getChildren().begin(), 0);
     ASSERT_STREQ("dialogNodeC", currentNode->getName().c_str());
@@ -527,7 +527,7 @@ namespace
 
   TEST_F(XmlNodeTest, addChildToEnd_no_child_reference)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
@@ -543,7 +543,7 @@ namespace
 
   TEST_F(XmlNodeTest, clearValue)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
     dialogNode.setValue("Something");
     ASSERT_STREQ("Something", dialogNode.getValue().c_str());
 
@@ -554,29 +554,29 @@ namespace
 
   TEST_F(XmlNodeTest, getAttributes)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
     ASSERT_TRUE(dialogNode.getAttributes().empty());
   }
 
   TEST_F(XmlNodeTest, getChildren)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
     ASSERT_TRUE(dialogNode.getChildren().empty());
   }
 
   TEST_F(XmlNodeTest, getChildrenV2)
   {
-    ls::XmlNode dialogsNode{"dialogs"};
-    ls::XmlNode dialogNode{"dialog"};
-    ls::XmlNode otherNode{"something"};
+    ls::std::io::XmlNode dialogsNode{"dialogs"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode otherNode{"something"};
 
     // preparation
 
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>(dialogNode)));
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>(otherNode)));
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>(otherNode)));
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>(dialogNode)));
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>(otherNode)));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>(dialogNode)));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>(otherNode)));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>(otherNode)));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>(dialogNode)));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>(otherNode)));
 
     // check
 
@@ -588,22 +588,22 @@ namespace
 
   TEST_F(XmlNodeTest, getName)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
     ASSERT_STREQ("dialog", dialogNode.getName().c_str());
   }
 
   TEST_F(XmlNodeTest, getValue)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
     ASSERT_TRUE(dialogNode.getValue().empty());
   }
 
   TEST_F(XmlNodeTest, hasAttribute)
   {
-    ls::XmlNode dialogNode{"dialogNode"};
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("id"));
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("events"));
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("assets"));
+    ls::std::io::XmlNode dialogNode{"dialogNode"};
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("id"));
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("events"));
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("assets"));
 
     ASSERT_TRUE(dialogNode.hasAttribute("id"));
     ASSERT_TRUE(dialogNode.hasAttribute("events"));
@@ -612,13 +612,13 @@ namespace
 
   TEST_F(XmlNodeTest, hasAttribute_attribute_not_available)
   {
-    ls::XmlNode dialogNode{"dialogNode"};
+    ls::std::io::XmlNode dialogNode{"dialogNode"};
     ASSERT_FALSE(dialogNode.hasAttribute("fields"));
   }
 
   TEST_F(XmlNodeTest, hasAttribute_empty_name)
   {
-    ls::XmlNode dialogNode{"dialogNode"};
+    ls::std::io::XmlNode dialogNode{"dialogNode"};
 
     EXPECT_THROW({
                    try
@@ -634,10 +634,10 @@ namespace
 
   TEST_F(XmlNodeTest, hasChild)
   {
-    ls::XmlNode dialogsNode{"dialogsNode"};
-    dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("dialogA"));
-    dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("dialogB"));
-    dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("dialogC"));
+    ls::std::io::XmlNode dialogsNode{"dialogsNode"};
+    dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("dialogA"));
+    dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("dialogB"));
+    dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("dialogC"));
 
     ASSERT_TRUE(dialogsNode.hasChild("dialogA"));
     ASSERT_TRUE(dialogsNode.hasChild("dialogB"));
@@ -646,13 +646,13 @@ namespace
 
   TEST_F(XmlNodeTest, hasChild_child_not_available)
   {
-    ls::XmlNode dialogsNode{"dialogsNode"};
+    ls::std::io::XmlNode dialogsNode{"dialogsNode"};
     ASSERT_FALSE(dialogsNode.hasChild("dialogD"));
   }
 
   TEST_F(XmlNodeTest, hasChild_empty_name)
   {
-    ls::XmlNode dialogNode{"dialogNode"};
+    ls::std::io::XmlNode dialogNode{"dialogNode"};
 
     EXPECT_THROW({
                    try
@@ -668,27 +668,27 @@ namespace
 
   TEST_F(XmlNodeTest, hasChildV2)
   {
-    ls::XmlNode dialogsNode{"dialogsNode"};
-    std::shared_ptr<ls::XmlNode> searchNode = std::make_shared<ls::XmlNode>("dialogB");
-    dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("dialogA"));
+    ls::std::io::XmlNode dialogsNode{"dialogsNode"};
+    std::shared_ptr<ls::std::io::XmlNode> searchNode = std::make_shared<ls::std::io::XmlNode>("dialogB");
+    dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("dialogA"));
     dialogsNode.addChildToEnd(searchNode);
-    dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("dialogC"));
+    dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("dialogC"));
 
     ASSERT_TRUE(dialogsNode.hasChild(searchNode));
   }
 
   TEST_F(XmlNodeTest, hasChildV2_child_not_available)
   {
-    ls::XmlNode dialogsNode{"dialogsNode"};
-    std::shared_ptr<ls::XmlNode> searchNode = std::make_shared<ls::XmlNode>("dialogB");
+    ls::std::io::XmlNode dialogsNode{"dialogsNode"};
+    std::shared_ptr<ls::std::io::XmlNode> searchNode = std::make_shared<ls::std::io::XmlNode>("dialogB");
 
     ASSERT_FALSE(dialogsNode.hasChild(searchNode));
   }
 
   TEST_F(XmlNodeTest, hasChildV2_no_child_reference)
   {
-    ls::XmlNode dialogNode{"dialog"};
-    std::shared_ptr<ls::XmlNode> searchNode{};
+    ls::std::io::XmlNode dialogNode{"dialog"};
+    std::shared_ptr<ls::std::io::XmlNode> searchNode{};
 
     EXPECT_THROW({
                    try
@@ -704,11 +704,11 @@ namespace
 
   TEST_F(XmlNodeTest, removeFirstAttribute)
   {
-    ls::XmlNode dialogNode{"dialog"};
-    std::shared_ptr<ls::XmlAttribute> currentAttribute{};
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("id"));
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("events"));
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("assets"));
+    ls::std::io::XmlNode dialogNode{"dialog"};
+    std::shared_ptr<ls::std::io::XmlAttribute> currentAttribute{};
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("id"));
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("events"));
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("assets"));
 
     ASSERT_TRUE(!dialogNode.getAttributes().empty());
     ASSERT_EQ(3, dialogNode.getAttributes().size());
@@ -724,17 +724,17 @@ namespace
 
   TEST_F(XmlNodeTest, removeFirstAttribute_no_attributes_available)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
     ASSERT_FALSE(dialogNode.removeFirstAttribute());
   }
 
   TEST_F(XmlNodeTest, removeLastAttribute)
   {
-    ls::XmlNode dialogNode{"dialog"};
-    std::shared_ptr<ls::XmlAttribute> currentAttribute{};
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("id"));
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("events"));
-    dialogNode.addAttributeToEnd(std::make_shared<ls::XmlAttribute>("assets"));
+    ls::std::io::XmlNode dialogNode{"dialog"};
+    std::shared_ptr<ls::std::io::XmlAttribute> currentAttribute{};
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("id"));
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("events"));
+    dialogNode.addAttributeToEnd(std::make_shared<ls::std::io::XmlAttribute>("assets"));
 
     ASSERT_TRUE(!dialogNode.getAttributes().empty());
     ASSERT_EQ(3, dialogNode.getAttributes().size());
@@ -750,22 +750,22 @@ namespace
 
   TEST_F(XmlNodeTest, removeLastAttribute_no_attributes_available)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
     ASSERT_FALSE(dialogNode.removeLastAttribute());
   }
 
   TEST_F(XmlNodeTest, removeFirstChild)
   {
-    ls::XmlNode dialogsNode{"dialogs"};
-    std::shared_ptr<ls::XmlNode> currentNode{};
+    ls::std::io::XmlNode dialogsNode{"dialogs"};
+    std::shared_ptr<ls::std::io::XmlNode> currentNode{};
 
     // preparation
 
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("dialogA")));
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("dialogB")));
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("dialogC")));
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("additionalInfo")));
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("event")));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("dialogA")));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("dialogB")));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("dialogC")));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("additionalInfo")));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("event")));
 
     ASSERT_EQ(5, dialogsNode.getChildren().size());
     currentNode = *std::next(dialogsNode.getChildren().begin(), 0);
@@ -794,22 +794,22 @@ namespace
 
   TEST_F(XmlNodeTest, removeFirstChild_no_children_available)
   {
-    ls::XmlNode dialogsNode{"dialogs"};
+    ls::std::io::XmlNode dialogsNode{"dialogs"};
     ASSERT_FALSE(dialogsNode.removeFirstChild());
   }
 
   TEST_F(XmlNodeTest, removeLastChild)
   {
-    ls::XmlNode dialogsNode{"dialogs"};
-    std::shared_ptr<ls::XmlNode> currentNode{};
+    ls::std::io::XmlNode dialogsNode{"dialogs"};
+    std::shared_ptr<ls::std::io::XmlNode> currentNode{};
 
     // preparation
 
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("dialogA")));
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("dialogB")));
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("dialogC")));
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("additionalInfo")));
-    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::XmlNode>("event")));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("dialogA")));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("dialogB")));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("dialogC")));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("additionalInfo")));
+    ASSERT_TRUE(dialogsNode.addChildToEnd(std::make_shared<ls::std::io::XmlNode>("event")));
 
     ASSERT_EQ(5, dialogsNode.getChildren().size());
     currentNode = *std::next(dialogsNode.getChildren().begin(), 0);
@@ -838,13 +838,13 @@ namespace
 
   TEST_F(XmlNodeTest, removeLastChild_no_children_available)
   {
-    ls::XmlNode dialogsNode{"dialogs"};
+    ls::std::io::XmlNode dialogsNode{"dialogs"};
     ASSERT_FALSE(dialogsNode.removeLastChild());
   }
 
   TEST_F(XmlNodeTest, setName)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
     dialogNode.setName("dialog2");
 
     ASSERT_STREQ("dialog2", dialogNode.getName().c_str());
@@ -852,7 +852,7 @@ namespace
 
   TEST_F(XmlNodeTest, setName_empty_name)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
@@ -868,7 +868,7 @@ namespace
 
   TEST_F(XmlNodeTest, setValue)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
     dialogNode.setValue("Something written");
 
     ASSERT_STREQ("Something written", dialogNode.getValue().c_str());
@@ -876,7 +876,7 @@ namespace
 
   TEST_F(XmlNodeTest, setValue_empty_value)
   {
-    ls::XmlNode dialogNode{"dialog"};
+    ls::std::io::XmlNode dialogNode{"dialog"};
 
     EXPECT_THROW({
                    try
@@ -900,8 +900,8 @@ namespace
 
   TEST_F(XmlNodeTest, toXml_no_value)
   {
-    std::shared_ptr<ls::XmlNode> singleLineElement = std::make_shared<ls::XmlNode>("info");
-    std::shared_ptr<ls::XmlAttribute> attribute = std::make_shared<ls::XmlAttribute>("id");
+    std::shared_ptr<ls::std::io::XmlNode> singleLineElement = std::make_shared<ls::std::io::XmlNode>("info");
+    std::shared_ptr<ls::std::io::XmlAttribute> attribute = std::make_shared<ls::std::io::XmlAttribute>("id");
     attribute->setValue("important");
     singleLineElement->addAttributeToEnd(attribute);
 

test/cases/io/xml/XmlParserTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -23,8 +23,8 @@ namespace
       static ls::std::core::byte_field readXmlStateMachine()
       {
         std::string xmlPath = TestHelper::getResourcesFolderLocation() + "state_machine_test.xml";
-        ls::File file{xmlPath};
-        ls::std::core::byte_field data = ls::FileReader{file}.read();
+        ls::std::io::File file{xmlPath};
+        ls::std::core::byte_field data = ls::std::io::FileReader{file}.read();
 
         return data;
       }
@@ -38,12 +38,12 @@ namespace
 
   TEST_F(XmlParserTest, constructor)
   {
-    std::shared_ptr<ls::XmlDocument> document{};
+    std::shared_ptr<ls::std::io::XmlDocument> document{};
 
     EXPECT_THROW({
                    try
                    {
-                     ls::XmlParser xmlParser{document};
+                     ls::std::io::XmlParser xmlParser{document};
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {
@@ -54,9 +54,9 @@ namespace
 
   TEST_F(XmlParserTest, read)
   {
-    ls::XmlParser xmlParser{std::make_shared<ls::XmlDocument>()};
-    std::list<std::shared_ptr<ls::XmlNode>> children, statesChildren, memoryChildren, connectionChildren{};
-    std::list<std::shared_ptr<ls::XmlAttribute>> attributes{};
+    ls::std::io::XmlParser xmlParser{std::make_shared<ls::std::io::XmlDocument>()};
+    std::list<std::shared_ptr<ls::std::io::XmlNode>> children, statesChildren, memoryChildren, connectionChildren{};
+    std::list<std::shared_ptr<ls::std::io::XmlAttribute>> attributes{};
 
     ls::std::core::byte_field data = readXmlStateMachine();
     xmlParser.parse(data);
@@ -69,7 +69,7 @@ namespace
 
     // check root element
 
-    std::shared_ptr<ls::XmlNode> root = xmlParser.getDocument()->getRootElement();
+    std::shared_ptr<ls::std::io::XmlNode> root = xmlParser.getDocument()->getRootElement();
     ASSERT_STREQ("stateMachine", root->getName().c_str());
     ASSERT_STREQ("name", root->getAttributes().front()->getName().c_str());
     ASSERT_EQ(1, root->getAttributes().size());
@@ -222,7 +222,7 @@ namespace
   TEST_F(XmlParserTest, getDocument)
   {
     std::string xmlPath = TestHelper::getResourcesFolderLocation() + "state_machine_test.xml";
-    ls::XmlParser xmlParser{std::make_shared<ls::XmlDocument>()};
+    ls::std::io::XmlParser xmlParser{std::make_shared<ls::std::io::XmlDocument>()};
 
     ASSERT_TRUE(xmlParser.getDocument() != nullptr);
   }
@@ -230,19 +230,19 @@ namespace
   TEST_F(XmlParserTest, setDocument)
   {
     std::string xmlPath = TestHelper::getResourcesFolderLocation() + "state_machine_test.xml";
-    std::shared_ptr<ls::XmlDocument> document = std::make_shared<ls::XmlDocument>();
-    ls::XmlParser xmlParser{document};
+    std::shared_ptr<ls::std::io::XmlDocument> document = std::make_shared<ls::std::io::XmlDocument>();
+    ls::std::io::XmlParser xmlParser{document};
     ASSERT_TRUE(xmlParser.getDocument() == document);
 
-    document = std::make_shared<ls::XmlDocument>();
+    document = std::make_shared<ls::std::io::XmlDocument>();
     xmlParser.setDocument(document);
     ASSERT_TRUE(xmlParser.getDocument() == document);
   }
 
   TEST_F(XmlParserTest, setDocument_no_reference)
   {
-    std::shared_ptr<ls::XmlDocument> document = std::make_shared<ls::XmlDocument>();
-    ls::XmlParser xmlParser{document};
+    std::shared_ptr<ls::std::io::XmlDocument> document = std::make_shared<ls::std::io::XmlDocument>();
+    ls::std::io::XmlParser xmlParser{document};
 
     EXPECT_THROW({
                    try

test/cases/io/xml/XmlParserTestWrapperTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-18
- * Changed:         2021-05-02
+ * Changed:         2021-05-11
  *
  * */
 

test/cases/io/xml/XmlReaderTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-10
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -30,7 +30,7 @@ namespace
   TEST_F(XmlReaderTest, read)
   {
     std::string xmlPath = TestHelper::getResourcesFolderLocation() + "state_machine_test.xml";
-    ls::XmlReader xmlReader{std::make_shared<ls::XmlDocument>(), xmlPath};
+    ls::std::io::XmlReader xmlReader{std::make_shared<ls::std::io::XmlDocument>(), xmlPath};
 
     ASSERT_TRUE(!xmlReader.read().empty());
   }
@@ -38,7 +38,7 @@ namespace
   TEST_F(XmlReaderTest, getDocument)
   {
     std::string xmlPath = TestHelper::getResourcesFolderLocation() + "state_machine_test.xml";
-    ls::XmlReader xmlReader{std::make_shared<ls::XmlDocument>(), xmlPath};
+    ls::std::io::XmlReader xmlReader{std::make_shared<ls::std::io::XmlDocument>(), xmlPath};
 
     ASSERT_TRUE(xmlReader.getDocument() != nullptr);
   }
@@ -46,11 +46,11 @@ namespace
   TEST_F(XmlReaderTest, setDocument)
   {
     std::string xmlPath = TestHelper::getResourcesFolderLocation() + "state_machine_test.xml";
-    std::shared_ptr<ls::XmlDocument> document = std::make_shared<ls::XmlDocument>();
-    ls::XmlReader xmlReader{document, xmlPath};
+    std::shared_ptr<ls::std::io::XmlDocument> document = std::make_shared<ls::std::io::XmlDocument>();
+    ls::std::io::XmlReader xmlReader{document, xmlPath};
     ASSERT_TRUE(xmlReader.getDocument() == document);
 
-    document = std::make_shared<ls::XmlDocument>();
+    document = std::make_shared<ls::std::io::XmlDocument>();
     xmlReader.setDocument(document);
     ASSERT_TRUE(xmlReader.getDocument() == document);
   }
@@ -58,8 +58,8 @@ namespace
   TEST_F(XmlReaderTest, setDocument_no_reference)
   {
     std::string xmlPath = TestHelper::getResourcesFolderLocation() + "state_machine_test.xml";
-    std::shared_ptr<ls::XmlDocument> document = std::make_shared<ls::XmlDocument>();
-    ls::XmlReader xmlReader{document, xmlPath};
+    std::shared_ptr<ls::std::io::XmlDocument> document = std::make_shared<ls::std::io::XmlDocument>();
+    ls::std::io::XmlReader xmlReader{document, xmlPath};
 
     EXPECT_THROW({
                    try
@@ -76,8 +76,8 @@ namespace
   TEST_F(XmlReaderTest, setFile)
   {
     std::string xmlPath = TestHelper::getResourcesFolderLocation() + "state_machine_test.xml";
-    ls::XmlReader xmlReader{std::make_shared<ls::XmlDocument>(), xmlPath};
-    ls::File xmlFile{xmlPath};
+    ls::std::io::XmlReader xmlReader{std::make_shared<ls::std::io::XmlDocument>(), xmlPath};
+    ls::std::io::File xmlFile{xmlPath};
     xmlReader.setFile(xmlFile);
 
     ASSERT_TRUE(true);
@@ -86,13 +86,13 @@ namespace
   TEST_F(XmlReaderTest, setFile_does_not_exist)
   {
     std::string xmlPath = TestHelper::getResourcesFolderLocation() + "state_machine_test.xml";
-    ls::XmlReader xmlReader{std::make_shared<ls::XmlDocument>(), xmlPath};
-    ls::File xmlFile{xmlPath};
+    ls::std::io::XmlReader xmlReader{std::make_shared<ls::std::io::XmlDocument>(), xmlPath};
+    ls::std::io::File xmlFile{xmlPath};
 
     EXPECT_THROW({
                    try
                    {
-                     xmlReader.setFile(ls::File{""});
+                     xmlReader.setFile(ls::std::io::File{""});
                    }
                    catch (const ls::std::core::IllegalArgumentException &_exception)
                    {

test/cases/logic/serialization/SerializableJsonStateMachineTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-09-17
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -54,8 +54,8 @@ namespace
     std::string jsonString = serializable.marshal();
     ASSERT_TRUE(!jsonString.empty());
 
-    ls::File file{TestHelper::getResourcesFolderLocation() + "/state_machine_test.json"};
-    ls::FileReader reader{file};
+    ls::std::io::File file{TestHelper::getResourcesFolderLocation() + "/state_machine_test.json"};
+    ls::std::io::FileReader reader{file};
     ls::std::boxing::String data{reader.read()};
 
     ASSERT_TRUE(data.contains(jsonString));
@@ -63,8 +63,8 @@ namespace
 
   TEST_F(SerializableJsonStateMachineTest, unmarshal)
   {
-    ls::File file{TestHelper::getResourcesFolderLocation() + "/state_machine_test.json"};
-    ls::FileReader reader{file};
+    ls::std::io::File file{TestHelper::getResourcesFolderLocation() + "/state_machine_test.json"};
+    ls::std::io::FileReader reader{file};
     std::shared_ptr<ls::StateMachine> machine = std::make_shared<ls::StateMachine>("bla");
     ls::SerializableJsonStateMachine serializable{machine};
 

test/classes/io/xml/XmlParserTestWrapper.cpp

@@ -3,21 +3,21 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-18
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
 #include "XmlParserTestWrapper.hpp"
 
-ls_std_test::XmlParserTestWrapper::XmlParserTestWrapper() : ls::XmlParser(nullptr)
+ls_std_test::XmlParserTestWrapper::XmlParserTestWrapper() : ls::std::io::XmlParser(nullptr)
 {}
 
 std::pair<std::string, std::string> ls_std_test::XmlParserTestWrapper::readAttribute(const ls::std::core::byte_field &_data)
 {
-  return ls::XmlParser::_readAttribute_(_data);
+  return ls::std::io::XmlParser::_readAttribute_(_data);
 }
 
 std::list<std::pair<std::string, std::string>> ls_std_test::XmlParserTestWrapper::readAttributes(ls::std::core::byte_field _data)
 {
-  return ls::XmlParser::_readAttributes_(std::move(_data));
+  return ls::std::io::XmlParser::_readAttributes_(std::move(_data));
 }

test/classes/io/xml/XmlParserTestWrapper.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-10-18
- * Changed:         2022-05-09
+ * Changed:         2022-05-11
  *
  * */
 
@@ -14,7 +14,7 @@
 
 namespace ls_std_test
 {
-  class XmlParserTestWrapper : public ls::XmlParser
+  class XmlParserTestWrapper : public ls::std::io::XmlParser
   {
     public: