swoc_file.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright Apache Software Foundation 2019
 
#pragma once
 
#include <unistd.h>
#include <sys/stat.h>
 
#include <string>
#include <string_view>
#include <system_error>
#include <chrono>
 
#include "swoc/swoc_version.h"
#include "swoc/TextView.h"
 
namespace swoc { inline namespace SWOC_VERSION_NS {
namespace file {
 
using file_time_type = std::chrono::system_clock::time_point;
 
enum class file_type : signed char {
  none      = 0,
  not_found = -1,
  regular   = 1,
  directory = 2,
  symlink   = 3,
  block     = 4,
  character = 5,
  fifo      = 6,
  socket    = 7,
  unknown   = 8
};

static constexpr int NO_FD = -1;

struct unique_fd {
  using self_type = unique_fd; 

  explicit unique_fd(int fd) : _fd(fd) {}

  unique_fd(self_type const &) = delete;

  unique_fd(self_type &&that) : _fd(that._fd) { that._fd = NO_FD; }

  ~unique_fd() {
    if (_fd != NO_FD) {
      ::close(_fd);
      _fd = NO_FD;
    };
  }

  int
  release() {
    auto zret = _fd;
    _fd       = NO_FD;
    return zret;
  }

  operator int() const { return _fd; }
 
protected:
  int _fd = NO_FD;
};

class path {
  using self_type = path; 
 
public:
  static constexpr char SEPARATOR = '/';

  path() = default;

  path(const self_type &that) = default;

  path(self_type &&that) = default;

  explicit path(const char *src);

  path(std::string_view src);

  path(std::string const &p);

  path(std::string &&that);

  self_type &operator=(const self_type &that) = default;

  self_type &operator=(self_type &&that) = default;

  self_type &operator=(std::string_view p);

  self_type &operator=(std::string const &s);

  self_type &operator=(std::string &&s);

  self_type &operator=(char const *s);

  self_type &operator/=(const self_type &that);

  self_type &operator/=(std::string_view that);

  bool empty() const;

  bool is_absolute() const;

  bool is_relative() const;

  self_type parent_path() const;

  self_type relative_path() const;

  self_type filename() const;

  char const *c_str() const;

  std::string const &string() const;

  self_type &reserve(size_t n);

  swoc::TextView view() const;
 
protected:
  std::string _path; 
};

class file_status {
  using self_type = file_status;
 
public:
  file_type type() const;

  mode_t mode() const;
 
protected:
  struct ::stat _stat; 
  file_type _type = file_type::none;
 
  void init();
 
  friend self_type status(const path &file, std::error_code &ec) noexcept;
  friend int file_type(const self_type &);
  friend uintmax_t file_size(const self_type &);
  friend bool is_regular_file(const self_type &);
  friend bool is_dir(const self_type &);
  friend bool is_char_device(const self_type &);
  friend bool is_block_device(const self_type &);
  friend bool exists(const self_type &);
  friend file_time_type last_write_time(file_status const &fs);
  friend file_time_type access_time(file_status const &fs);
  friend file_time_type status_time(file_status const &fs);
};

file_status status(const path &file, std::error_code &ec) noexcept;
 
// Related free functions.
// These are separate because they are not part of std::filesystem::path.

[[deprecated("Use file_status::type")]] int file_type(const file_status &fs);

bool is_regular_file(const file_status &fs);

bool is_dir(const file_status &p);

bool is_char_device(const file_status &fs);

bool is_block_device(const file_status &fs);

uintmax_t file_size(const file_status &fs);

bool is_readable(const path &s);

bool exists(const path &p);

bool exists(const file_status &fs);

path absolute(path const &src, std::error_code &ec);

path temp_directory_path();

path current_path();

path canonical(const path &p, std::error_code &ec);

bool create_directory(const path &p, std::error_code &ec, mode_t mode = 0775) noexcept;

bool create_directories(const path &p, std::error_code &ec, mode_t mode = 0775) noexcept;

bool copy(const path &from, const path &to, std::error_code &ec);

bool remove(const path &path, std::error_code &ec);

uintmax_t remove_all(const path &path, std::error_code &ec);

[[deprecated("See last_write_time")]] file_time_type modify_time(file_status const &fs);
file_time_type last_write_time(file_status const &fs);

file_time_type last_write_time(path const &p, std::error_code &ec);

file_time_type access_time(file_status const &fs);
file_time_type status_time(file_status const &fs);

std::string load(const path &p, std::error_code &ec);
 
/* ------------------------------------------------------------------- */
 
inline path::path(char const *src) : _path(src) {}
 
inline path::path(std::string_view base) : _path(base) {}
 
inline path::path(std::string const &p) : _path(p) {}
 
inline path::path(std::string &&that) : _path(std::move(that)) {}
 
inline path &
path::operator=(std::string_view p) {
  _path.assign(p);
  return *this;
}
 
inline path &
path::operator=(std::string const &s) {
  _path.assign(s);
  return *this;
}
 
inline path &
path::operator=(std::string &&s) {
  _path.assign(std::move(s));
  return *this;
}
 
inline path &
path::operator=(char const *s) {
  _path.assign(s);
  return *this;
}
 
inline char const *
path::c_str() const {
  return _path.c_str();
}
 
inline std::string const &
path::string() const {
  return _path;
}
 
inline swoc::TextView
path::view() const {
  return {_path};
}
 
inline bool
path::empty() const {
  return _path.empty();
}
 
inline bool
path::is_absolute() const {
  return !_path.empty() && '/' == _path[0];
}
 
inline bool
path::is_relative() const {
  return !this->is_absolute();
}
 
inline path &
path::operator/=(const self_type &that) {
  return *this /= std::string_view(that._path);
}

inline bool
operator==(path const &lhs, path const &rhs) {
  return lhs.view() == rhs.view();
}

inline bool
operator!=(path const &lhs, path const &rhs) {
  return lhs.view() != rhs.view();
}

inline path
operator/(const path &lhs, const path &rhs) {
  return path(lhs) /= rhs;
}

inline path
operator/(path &&lhs, const path &rhs) {
  return path(std::move(lhs)) /= rhs;
}

inline path
operator/(const path &lhs, std::string_view rhs) {
  return path(lhs) /= rhs;
}
 
inline auto
path::reserve(size_t n) -> self_type & {
  _path.reserve(n);
  return *this;
}

inline path
operator/(path &&lhs, std::string_view rhs) {
  return path(std::move(lhs)) /= rhs;
}
 
// Can remove "enum" after the function @c file_type is removed.
inline enum file_type
file_status::type() const {
  return _type;
}
 
inline mode_t
file_status::mode() const {
  return _stat.st_mode;
}
 
inline bool
is_char_device(const file_status &fs) {
  return fs._type == file_type::character;
}
 
inline bool
is_block_device(const file_status &fs) {
  return fs._type == file_type::block;
}
 
inline bool
is_regular_file(const file_status &fs) {
  return fs._type == file_type::regular;
}
 
inline bool
is_dir(const file_status &fs) {
  return fs._type == file_type::directory;
}
 
inline bool
exists(const file_status &fs) {
  return fs._type != file_type::none && fs._type != file_type::not_found;
}
 
inline file_time_type
modify_time(file_status const &fs) {
  return last_write_time(fs);
}
} // namespace file
 
class BufferWriter;
namespace bwf {
struct Spec;
}
 
BufferWriter &bwformat(BufferWriter &w, bwf::Spec const &spec, file::path const &p);
}} // namespace swoc::SWOC_VERSION_NS
 
namespace std {
template <> struct hash<swoc::file::path> {
  size_t
  operator()(swoc::file::path const &path) const {
    return hash<string_view>()(path.view());
  }
};
} // namespace std