fs.h

#ifndef UVW_FS_INCLUDE_H
#define UVW_FS_INCLUDE_H
 
#include <chrono>
#include <memory>
#include <string>
#include <utility>
#include <uv.h>
#include "config.h"
#include "enum.hpp"
#include "loop.h"
#include "request.hpp"
#include "util.h"
 
namespace uvw {
 
namespace details {
 
enum class uvw_fs_type : std::underlying_type_t<uv_fs_type> {
    UNKNOWN = UV_FS_UNKNOWN,
    CUSTOM = UV_FS_CUSTOM,
    OPEN = UV_FS_OPEN,
    CLOSE = UV_FS_CLOSE,
    READ = UV_FS_READ,
    WRITE = UV_FS_WRITE,
    SENDFILE = UV_FS_SENDFILE,
    STAT = UV_FS_STAT,
    LSTAT = UV_FS_LSTAT,
    FSTAT = UV_FS_FSTAT,
    FTRUNCATE = UV_FS_FTRUNCATE,
    UTIME = UV_FS_UTIME,
    FUTIME = UV_FS_FUTIME,
    ACCESS = UV_FS_ACCESS,
    CHMOD = UV_FS_CHMOD,
    FCHMOD = UV_FS_FCHMOD,
    FSYNC = UV_FS_FSYNC,
    FDATASYNC = UV_FS_FDATASYNC,
    UNLINK = UV_FS_UNLINK,
    RMDIR = UV_FS_RMDIR,
    MKDIR = UV_FS_MKDIR,
    MKDTEMP = UV_FS_MKDTEMP,
    RENAME = UV_FS_RENAME,
    SCANDIR = UV_FS_SCANDIR,
    LINK = UV_FS_LINK,
    SYMLINK = UV_FS_SYMLINK,
    READLINK = UV_FS_READLINK,
    CHOWN = UV_FS_CHOWN,
    FCHOWN = UV_FS_FCHOWN,
    REALPATH = UV_FS_REALPATH,
    COPYFILE = UV_FS_COPYFILE,
    LCHOWN = UV_FS_LCHOWN,
    OPENDIR = UV_FS_OPENDIR,
    READDIR = UV_FS_READDIR,
    CLOSEDIR = UV_FS_CLOSEDIR,
    STATFS = UV_FS_STATFS,
    MKSTEMP = UV_FS_MKSTEMP,
    LUTIME = UV_FS_LUTIME
};
 
enum class uvw_dirent_type_t : std::underlying_type_t<uv_dirent_type_t> {
    UNKNOWN = UV_DIRENT_UNKNOWN,
    FILE = UV_DIRENT_FILE,
    DIR = UV_DIRENT_DIR,
    LINK = UV_DIRENT_LINK,
    FIFO = UV_DIRENT_FIFO,
    SOCKET = UV_DIRENT_SOCKET,
    CHAR = UV_DIRENT_CHAR,
    BLOCK = UV_DIRENT_BLOCK
};
 
enum class uvw_file_open_flags : int {
    APPEND = UV_FS_O_APPEND,
    CREAT = UV_FS_O_CREAT,
    DIRECT = UV_FS_O_DIRECT,
    DIRECTORY = UV_FS_O_DIRECTORY,
    DSYNC = UV_FS_O_DSYNC,
    EXCL = UV_FS_O_EXCL,
    EXLOCK = UV_FS_O_EXLOCK,
    FILEMAP = UV_FS_O_FILEMAP,
    NOATIME = UV_FS_O_NOATIME,
    NOCTTY = UV_FS_O_NOCTTY,
    NOFOLLOW = UV_FS_O_NOFOLLOW,
    NONBLOCK = UV_FS_O_NONBLOCK,
    RANDOM = UV_FS_O_RANDOM,
    RDONLY = UV_FS_O_RDONLY,
    RDWR = UV_FS_O_RDWR,
    SEQUENTIAL = UV_FS_O_SEQUENTIAL,
    SHORT_LIVED = UV_FS_O_SHORT_LIVED,
    SYMLINK = UV_FS_O_SYMLINK,
    SYNC = UV_FS_O_SYNC,
    TEMPORARY = UV_FS_O_TEMPORARY,
    TRUNC = UV_FS_O_TRUNC,
    WRONLY = UV_FS_O_WRONLY,
    _UVW_ENUM = 0
};
 
enum class uvw_copy_file_flags : int {
    EXCL = UV_FS_COPYFILE_EXCL,
    FICLONE = UV_FS_COPYFILE_FICLONE,
    FICLONE_FORCE = UV_FS_COPYFILE_FICLONE_FORCE,
    _UVW_ENUM = 0
};
 
enum class uvw_symlink_flags : int {
    DIR = UV_FS_SYMLINK_DIR,
    JUNCTION = UV_FS_SYMLINK_JUNCTION,
    _UVW_ENUM = 0
};
 
} // namespace details
 
struct fs_event {
    using fs_type = details::uvw_fs_type;
    using entry_type = details::uvw_dirent_type_t;
 
    fs_event(const uv_fs_t &req, std::unique_ptr<const char[]> data)
        : fs_event{req} {
        read.data = std::move(data);
    }
 
    fs_event(const uv_fs_t &req)
        : type{req.fs_type},
          path{req.path},
          result{static_cast<std::size_t>(req.result)} {
        switch(type) {
        case fs_type::STAT:
        case fs_type::LSTAT:
        case fs_type::FSTAT:
            stat = *static_cast<file_info *>(req.ptr);
            break;
        case fs_type::READLINK:
            readlink.data = static_cast<char *>(req.ptr);
            break;
        case fs_type::READDIR:
            dirent.name = static_cast<uv_dir_t *>(req.ptr)->dirents[0].name;
            dirent.type = static_cast<entry_type>(static_cast<uv_dir_t *>(req.ptr)->dirents[0].type);
            dirent.eos = !req.result;
            break;
        case fs_type::STATFS:
            statfs = *static_cast<fs_info *>(req.ptr);
            break;
        default:
            // nothing to do here
            break;
        }
    }
 
    fs_type type;       
    const char *path;   
    std::size_t result; 
    struct {
        std::unique_ptr<const char[]> data; 
    } read;
 
    struct {
        const char *data; 
    } readlink;
 
    file_info stat; 
    fs_info statfs; 
    struct {
        const char *name; 
        entry_type type;  
        bool eos;         
    } dirent;
};
 
template<typename T>
class fs_request: public request<T, uv_fs_t, fs_event> {
protected:
    static void fs_request_callback(uv_fs_t *req) {
        if(auto ptr = request<T, uv_fs_t, fs_event>::reserve(req); req->result < 0) {
            ptr->publish(error_event{req->result});
        } else {
            ptr->publish(fs_event{*req});
        }
    }
 
public:
    using time = std::chrono::duration<double>;
    using fs_type = details::uvw_fs_type;
    using entry_type = details::uvw_dirent_type_t;
 
    using request<T, uv_fs_t, fs_event>::request;
};
 
class file_req final: public fs_request<file_req> {
    static constexpr uv_file BAD_FD = -1;
 
    static void fs_open_callback(uv_fs_t *req);
    static void fs_close_callback(uv_fs_t *req);
    static void fs_read_callback(uv_fs_t *req);
 
public:
    using file_open_flags = details::uvw_file_open_flags;
 
    using fs_request::fs_request;
 
    ~file_req() noexcept;
 
    void close();
 
    bool close_sync();
 
    void open(const std::string &path, file_open_flags flags, int mode);
 
    bool open_sync(const std::string &path, file_open_flags flags, int mode);
 
    void read(int64_t offset, unsigned int len);
 
    std::pair<bool, std::pair<std::unique_ptr<const char[]>, std::size_t>> read_sync(int64_t offset, unsigned int len);
 
    void write(std::unique_ptr<char[]> buf, unsigned int len, int64_t offset);
 
    void write(char *buf, unsigned int len, int64_t offset);
 
    std::pair<bool, std::size_t> write_sync(std::unique_ptr<char[]> buf, unsigned int len, int64_t offset);
 
    void stat();
 
    std::pair<bool, file_info> stat_sync();
 
    void sync();
 
    bool sync_sync();
 
    void datasync();
 
    bool datasync_sync();
 
    void truncate(int64_t offset);
 
    bool truncate_sync(int64_t offset);
 
    void sendfile(file_handle out, int64_t offset, std::size_t length);
 
    std::pair<bool, std::size_t> sendfile_sync(file_handle out, int64_t offset, std::size_t length);
 
    void chmod(int mode);
 
    bool chmod_sync(int mode);
 
    void futime(time atime, time mtime);
 
    bool futime_sync(time atime, time mtime);
 
    void chown(uid_type uid, gid_type gid);
 
    bool chown_sync(uid_type uid, gid_type gid);
 
    operator file_handle() const noexcept;
 
private:
    std::unique_ptr<char[]> current{nullptr};
    uv_buf_t buffer{};
    uv_file file{BAD_FD};
};
 
class fs_req final: public fs_request<fs_req> {
public:
    using copy_file_flags = details::uvw_copy_file_flags;
    using symlink_flags = details::uvw_symlink_flags;
 
    using fs_request::fs_request;
 
    ~fs_req() noexcept;
 
    void unlink(const std::string &path);
 
    bool unlink_sync(const std::string &path);
 
    void mkdir(const std::string &path, int mode);
 
    bool mkdir_sync(const std::string &path, int mode);
 
    void mkdtemp(const std::string &tpl);
 
    std::pair<bool, const char *> mkdtemp_sync(const std::string &tpl);
 
    void mkstemp(const std::string &tpl);
 
    std::pair<bool, std::pair<std::string, std::size_t>> mkstemp_sync(const std::string &tpl);
 
    void lutime(const std::string &path, time atime, time mtime);
 
    bool lutime_sync(const std::string &path, time atime, time mtime);
 
    void rmdir(const std::string &path);
 
    bool rmdir_sync(const std::string &path);
 
    void scandir(const std::string &path, int flags);
 
    std::pair<bool, std::size_t> scandir_sync(const std::string &path, int flags);
 
    std::pair<bool, std::pair<entry_type, const char *>> scandir_next();
 
    void stat(const std::string &path);
 
    std::pair<bool, file_info> stat_sync(const std::string &path);
 
    void lstat(const std::string &path);
 
    std::pair<bool, file_info> lstat_sync(const std::string &path);
 
    void statfs(const std::string &path);
 
    std::pair<bool, fs_info> statfs_sync(const std::string &path);
 
    void rename(const std::string &old, const std::string &path);
 
    bool rename_sync(const std::string &old, const std::string &path);
 
    void copyfile(const std::string &old, const std::string &path, copy_file_flags flags = copy_file_flags::_UVW_ENUM);
 
    bool copyfile_sync(const std::string &old, const std::string &path, copy_file_flags flags = copy_file_flags::_UVW_ENUM);
 
    void access(const std::string &path, int mode);
 
    bool access_sync(const std::string &path, int mode);
 
    void chmod(const std::string &path, int mode);
 
    bool chmod_sync(const std::string &path, int mode);
 
    void utime(const std::string &path, time atime, time mtime);
 
    bool utime_sync(const std::string &path, time atime, time mtime);
 
    void link(const std::string &old, const std::string &path);
 
    bool link_sync(const std::string &old, const std::string &path);
 
    void symlink(const std::string &old, const std::string &path, symlink_flags flags = symlink_flags::_UVW_ENUM);
 
    bool symlink_sync(const std::string &old, const std::string &path, symlink_flags flags = symlink_flags::_UVW_ENUM);
 
    void readlink(const std::string &path);
 
    std::pair<bool, std::pair<const char *, std::size_t>> readlink_sync(const std::string &path);
 
    void realpath(const std::string &path);
 
    std::pair<bool, const char *> realpath_sync(const std::string &path);
 
    void chown(const std::string &path, uid_type uid, gid_type gid);
 
    bool chown_sync(const std::string &path, uid_type uid, gid_type gid);
 
    void lchown(const std::string &path, uid_type uid, gid_type gid);
 
    bool lchown_sync(const std::string &path, uid_type uid, gid_type gid);
 
    void opendir(const std::string &path);
 
    bool opendir_sync(const std::string &path);
 
    void closedir();
 
    bool closedir_sync();
 
    void readdir();
 
    std::pair<bool, std::pair<entry_type, const char *>> readdir_sync();
 
private:
    uv_dirent_t dirents[1];
};
 
struct fs_helper {
    static os_file_descriptor handle(file_handle file) noexcept;
 
    static file_handle open(os_file_descriptor descriptor) noexcept;
};
 
} // namespace uvw
 
#ifndef UVW_AS_LIB
#    include "fs.cpp"
#endif
 
#endif // UVW_FS_INCLUDE_H