file_system.h

Go to the documentation of this file.

 
 
#ifndef HERMES_FILE_SYSTEM_H
#define HERMES_FILE_SYSTEM_H
 
#include <hermes/common/defs.h>
#include <hermes/common/str.h>
#include <hermes/common/bitmask_operators.h>
#include <vector>
#include <string>
#include <ostream>
 
namespace hermes {
 
// *********************************************************************************************************************
//                                                                                                               Path
// *********************************************************************************************************************
class Path {
public:
  // *******************************************************************************************************************
  //                                                                                                     CONSTRUCTORS
  // *******************************************************************************************************************
  Path() = default;
  Path(const Str &path);
  Path(const char *const &&path);
  Path(std::string path);
  Path(const Path &other);
  Path(Path &&other) noexcept;
  // *******************************************************************************************************************
  //                                                                                                        OPERATORS
  // *******************************************************************************************************************
  //                                                                                                          casting
  explicit operator std::string() const { return path_.str(); }
  //                                                                                                       assignment
  Path &operator=(const Path &path);
  //                                                                                                          boolean
  bool operator==(const Path &b) const;
  //                                                                                                       arithmetic
  Path operator+(const Str &b) const;
  Path operator/(const Path &other) const;
  Path &operator/=(const Path &other);
  Path &operator+=(const std::string &other);
  Path &operator+=(const Path &other);
  // *******************************************************************************************************************
  //                                                                                                          METHODS
  // *******************************************************************************************************************
  Path &join(const Path &path);
  Path &cd(const std::string &path);
  [[nodiscard]] bool exists() const;
  [[nodiscard]] bool isDirectory() const;
  [[nodiscard]] bool isFile() const;
  [[nodiscard]] bool hasExtension() const;
  [[nodiscard]] std::vector<std::string> parts() const;
  [[nodiscard]] std::string name() const;
  [[nodiscard]] const std::string &fullName() const;
  [[nodiscard]] std::string extension() const;
  [[nodiscard]] bool match_r(const std::string &regular_expression) const;
  [[nodiscard]] Path cwd() const;
  [[nodiscard]] bool mkdir() const;
  [[nodiscard]] bool touch() const;
  [[nodiscard]] u64 writeTo(const std::string &content) const;
  [[nodiscard]] u64 appendTo(const std::string &content) const;
  [[nodiscard]] std::string read() const;
  // *******************************************************************************************************************
  //                                                                                                    PUBLIC FIELDS
  // *******************************************************************************************************************
  std::string separator{"/"}; 
private:
  Str path_;
};
 
// *********************************************************************************************************************
//                                                                                                         ls_options
// *********************************************************************************************************************
enum class ls_options {
  none = 0x0,                                  
  sort = 0x1,                                  
  reverse_sort = 0x2,                          
  directories = 0x4,                           
  files = 0x8,                                 
  group_directories_first = 0x10,              
  recursive = 0x20,                            
};
HERMES_ENABLE_BITMASK_OPERATORS(ls_options);
// *********************************************************************************************************************
//                                                                                                       find_options
// *********************************************************************************************************************
enum class find_options {
  none = 0x0,                
  recursive = 0x1,           
  sort = 0x2,                
};
HERMES_ENABLE_BITMASK_OPERATORS(find_options);
 
// *********************************************************************************************************************
//                                                                                                         FileSystem
// *********************************************************************************************************************
class FileSystem {
public:
  // *******************************************************************************************************************
  //                                                                                                   STATIC METHODS
  // *******************************************************************************************************************
  //                                                                                                   path structure
  static std::vector<std::string> basename(const std::vector<std::string> &paths, const std::string &suffix = "");
  static std::string basename(const std::string &path, const std::string &suffix = "");
  static std::string fileExtension(const std::string &filename);
  static std::string normalizePath(const std::string &path, bool with_backslash = false);
  //                                                                                                        file read
  static u64 readFile(const char *filename, char **text);
  static std::vector<unsigned char> readBinaryFile(const Path &filename);
  static std::vector<std::string> readLines(const Path &path);
  static std::string readFile(const Path &filename);
  //                                                                                                       file write
  static bool touch(const Path &path_to_file);
  static u64 writeFile(const Path &path,
                       const std::vector<char> &content, bool is_binary = false);
  static u64 writeFile(const Path &path,
                       const std::string &content, bool is_binary = false);
  static u64 writeLine(const Path &path, const std::string &line, bool is_binary = false);
  //                                                                                                      file append
  static u64 appendToFile(const Path &path,
                          const std::vector<char> &content, bool is_binary = false);
  static u64 appendToFile(const Path &path,
                          const std::string &content, bool is_binary = false);
  static u64 appendLine(const Path &path, const std::string &line, bool is_binary = false);
  //                                                                                                          queries
  static bool fileExists(const Path &path);
  static bool isFile(const Path &path);
  static bool isDirectory(const Path &dir_name);
  //                                                                                                      directories
  static std::vector<Path> ls(const Path &path, ls_options options = ls_options::none);
  static bool mkdir(const Path &path);
  static bool copyFile(const Path &source, const Path &destination);
  //                                                                                                           search
  static std::vector<Path> find(const Path &path,
                                const std::string &pattern,
                                find_options options = find_options::none);
};
 
// *********************************************************************************************************************
//                                                                                                                 IO
// *********************************************************************************************************************
std::ostream &operator<<(std::ostream &o, const Path &path);
 
}
 
#endif //HERMES_FILE_SYSTEM_H