fs.h

#ifndef UVW_FS_INCLUDE_H
#define UVW_FS_INCLUDE_H
 
 
#include <utility>
#include <memory>
#include <string>
#include <chrono>
#include <uv.h>
#include "request.hpp"
#include "util.h"
#include "loop.h"
 
 
namespace uvw {
 
 
namespace details {
 
 
enum class UVFsType: 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 UVDirentTypeT: 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 UVFileOpenFlags: 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
};
 
 
enum class UVCopyFileFlags: int {
    EXCL = UV_FS_COPYFILE_EXCL,
    FICLONE = UV_FS_COPYFILE_FICLONE,
    FICLONE_FORCE = UV_FS_COPYFILE_FICLONE_FORCE
};
 
 
enum class UVSymLinkFlags: int {
    DIR = UV_FS_SYMLINK_DIR,
    JUNCTION = UV_FS_SYMLINK_JUNCTION
};
 
 
}
 
 
template<details::UVFsType e>
struct FsEvent {
    FsEvent(const char *pathname) noexcept: path{pathname} {}
 
    const char * path; 
};
 
 
template<>
struct FsEvent<details::UVFsType::READ> {
    FsEvent(const char *pathname, std::unique_ptr<const char[]> buf, std::size_t sz) noexcept
        : path{pathname}, data{std::move(buf)}, size{sz}
    {}
 
    const char * path; 
    std::unique_ptr<const char[]> data; 
    std::size_t size; 
};
 
 
template<>
struct FsEvent<details::UVFsType::WRITE> {
    FsEvent(const char *pathname, std::size_t sz) noexcept
        : path{pathname}, size{sz}
    {}
 
    const char * path; 
    std::size_t size; 
};
 
 
template<>
struct FsEvent<details::UVFsType::SENDFILE> {
    FsEvent(const char *pathname, std::size_t sz) noexcept
        : path{pathname}, size{sz}
    {}
 
    const char * path; 
    std::size_t size; 
};
 
 
template<>
struct FsEvent<details::UVFsType::STAT> {
    FsEvent(const char *pathname, Stat curr) noexcept
        : path{pathname}, stat{std::move(curr)}
    {}
 
    const char * path; 
    Stat stat; 
};
 
 
template<>
struct FsEvent<details::UVFsType::FSTAT> {
    FsEvent(const char *pathname, Stat curr) noexcept
        : path{pathname}, stat{std::move(curr)}
    {}
 
    const char * path; 
    Stat stat; 
};
 
 
template<>
struct FsEvent<details::UVFsType::LSTAT> {
    FsEvent(const char *pathname, Stat curr) noexcept
        : path{pathname}, stat{std::move(curr)}
    {}
 
    const char * path; 
    Stat stat; 
};
 
 
template<>
struct FsEvent<details::UVFsType::STATFS> {
    FsEvent(const char *pathname, Statfs curr) noexcept
        : path{pathname}, statfs{std::move(curr)}
    {}
 
    const char * path; 
    Statfs statfs; 
};
 
 
template<>
struct FsEvent<details::UVFsType::MKSTEMP> {
    FsEvent(const char *pathname, std::size_t desc) noexcept
        : path{pathname}, descriptor{desc}
    {}
 
    const char * path; 
    std::size_t descriptor; 
};
 
 
template<>
struct FsEvent<details::UVFsType::SCANDIR> {
    FsEvent(const char *pathname, std::size_t sz) noexcept
        : path{pathname}, size{sz}
    {}
 
    const char * path; 
    std::size_t size; 
};
 
 
template<>
struct FsEvent<details::UVFsType::READLINK> {
    explicit FsEvent(const char *pathname, const char *buf, std::size_t sz) noexcept
        : path{pathname}, data{buf}, size{sz}
    {}
 
    const char * path; 
    const char * data; 
    std::size_t size; 
};
 
 
template<>
struct FsEvent<details::UVFsType::READDIR> {
    using EntryType = details::UVDirentTypeT;
 
    FsEvent(const char *name, EntryType type, bool eos) noexcept
        : name{name}, type{type}, eos{eos}
    {}
 
    const char * name; 
    EntryType type; 
    bool eos; 
};
 
 
template<typename T>
class FsRequest: public Request<T, uv_fs_t> {
protected:
    template<details::UVFsType e>
    static void fsGenericCallback(uv_fs_t *req) {
        auto ptr = Request<T, uv_fs_t>::reserve(req);
        if(req->result < 0) { ptr->publish(ErrorEvent{req->result}); }
        else { ptr->publish(FsEvent<e>{req->path}); }
    }
 
    template<details::UVFsType e>
    static void fsResultCallback(uv_fs_t *req) {
        auto ptr = Request<T, uv_fs_t>::reserve(req);
        if(req->result < 0) { ptr->publish(ErrorEvent{req->result}); }
        else { ptr->publish(FsEvent<e>{req->path, static_cast<std::size_t>(req->result)}); }
    }
 
    template<details::UVFsType e>
    static void fsStatCallback(uv_fs_t *req) {
        auto ptr = Request<T, uv_fs_t>::reserve(req);
        if(req->result < 0) { ptr->publish(ErrorEvent{req->result}); }
        else { ptr->publish(FsEvent<e>{req->path, req->statbuf}); }
    }
 
    static void fsStatfsCallback(uv_fs_t *req) {
        auto ptr = Request<T, uv_fs_t>::reserve(req);
        if(req->result < 0) { ptr->publish(ErrorEvent{req->result}); }
        else { ptr->publish(FsEvent<Type::STATFS>{req->path, *static_cast<Statfs *>(req->ptr)}); }
    }
 
    template<typename... Args>
    void cleanupAndInvoke(Args&&... args) {
        uv_fs_req_cleanup(this->get());
        this->invoke(std::forward<Args>(args)...);
    }
 
    template<typename F, typename... Args>
    void cleanupAndInvokeSync(F &&f, Args&&... args) {
        uv_fs_req_cleanup(this->get());
        std::forward<F>(f)(std::forward<Args>(args)..., nullptr);
    }
 
public:
    using Time = std::chrono::duration<double>;
    using Type = details::UVFsType;
    using EntryType = details::UVDirentTypeT;
 
    using Request<T, uv_fs_t>::Request;
};
 
 
class FileReq final: public FsRequest<FileReq> {
    static constexpr uv_file BAD_FD = -1;
 
    static void fsOpenCallback(uv_fs_t *req);
    static void fsCloseCallback(uv_fs_t *req);
    static void fsReadCallback(uv_fs_t *req);
 
public:
    using FileOpen = details::UVFileOpenFlags;
 
    using FsRequest::FsRequest;
 
    ~FileReq() noexcept;
 
    void close();
 
    bool closeSync();
 
    void open(std::string path, Flags<FileOpen> flags, int mode);
 
    bool openSync(std::string path, Flags<FileOpen> flags, int mode);
 
    void read(int64_t offset, unsigned int len);
 
    std::pair<bool, std::pair<std::unique_ptr<const char[]>, std::size_t>> readSync(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> writeSync(std::unique_ptr<char[]> buf, unsigned int len, int64_t offset);
 
    void stat();
 
    std::pair<bool, Stat> statSync();
 
    void sync();
 
    bool syncSync();
 
    void datasync();
 
    bool datasyncSync();
 
    void truncate(int64_t offset);
 
    bool truncateSync(int64_t offset);
 
    void sendfile(FileHandle out, int64_t offset, std::size_t length);
 
    std::pair<bool, std::size_t> sendfileSync(FileHandle out, int64_t offset, std::size_t length);
 
    void chmod(int mode);
 
    bool chmodSync(int mode);
 
    void futime(Time atime, Time mtime);
 
    bool futimeSync(Time atime, Time mtime);
 
    void chown(Uid uid, Gid gid);
 
    bool chownSync(Uid uid, Gid gid);
 
    operator FileHandle() const noexcept;
 
private:
    std::unique_ptr<char[]> current{nullptr};
    uv_buf_t buffer{};
    uv_file file{BAD_FD};
};
 
 
class FsReq final: public FsRequest<FsReq> {
    static void fsReadlinkCallback(uv_fs_t *req);
    static void fsReaddirCallback(uv_fs_t *req);
 
public:
    using CopyFile = details::UVCopyFileFlags;
    using SymLink = details::UVSymLinkFlags;
 
    using FsRequest::FsRequest;
 
    ~FsReq() noexcept;
 
    void unlink(std::string path);
 
    bool unlinkSync(std::string path);
 
    void mkdir(std::string path, int mode);
 
    bool mkdirSync(std::string path, int mode);
 
    void mkdtemp(std::string tpl);
 
    std::pair<bool, const char *> mkdtempSync(std::string tpl);
 
    void mkstemp(std::string tpl);
 
    std::pair<bool, std::pair<std::string, std::size_t>> mkstempSync(std::string tpl);
 
    void lutime(std::string path, Time atime, Time mtime);
 
    bool lutimeSync(std::string path, Time atime, Time mtime);
 
    void rmdir(std::string path);
 
    bool rmdirSync(std::string path);
 
    void scandir(std::string path, int flags);
 
    std::pair<bool, std::size_t> scandirSync(std::string path, int flags);
 
    std::pair<bool, std::pair<EntryType, const char *>> scandirNext();
 
    void stat(std::string path);
 
    std::pair<bool, Stat> statSync(std::string path);
 
    void lstat(std::string path);
 
    std::pair<bool, Stat> lstatSync(std::string path);
 
    void statfs(std::string path);
 
    std::pair<bool, Statfs> statfsSync(std::string path);
 
    void rename(std::string old, std::string path);
 
    bool renameSync(std::string old, std::string path);
 
    void copyfile(std::string old, std::string path, Flags<CopyFile> flags = Flags<CopyFile>{});
 
    bool copyfileSync(std::string old, std::string path, Flags<CopyFile> flags = Flags<CopyFile>{});
 
    void access(std::string path, int mode);
 
    bool accessSync(std::string path, int mode);
 
    void chmod(std::string path, int mode);
 
    bool chmodSync(std::string path, int mode);
 
    void utime(std::string path, Time atime, Time mtime);
 
    bool utimeSync(std::string path, Time atime, Time mtime);
 
    void link(std::string old, std::string path);
 
    bool linkSync(std::string old, std::string path);
 
    void symlink(std::string old, std::string path, Flags<SymLink> flags = Flags<SymLink>{});
 
    bool symlinkSync(std::string old, std::string path, Flags<SymLink> flags = Flags<SymLink>{});
 
    void readlink(std::string path);
 
    std::pair<bool, std::pair<const char *, std::size_t>> readlinkSync(std::string path);
 
    void realpath(std::string path);
 
    std::pair<bool, const char *> realpathSync(std::string path);
 
    void chown(std::string path, Uid uid, Gid gid);
 
    bool chownSync(std::string path, Uid uid, Gid gid);
 
    void lchown(std::string path, Uid uid, Gid gid);
 
    bool lchownSync(std::string path, Uid uid, Gid gid);
 
    void opendir(std::string path);
 
    bool opendirSync(std::string path);
 
    void closedir();
 
    bool closedirSync();
 
    void readdir();
 
    std::pair<bool, std::pair<EntryType, const char *>> readdirSync();
 
private:
    uv_dirent_t dirents[1];
};
 
 
struct FsHelper {
    static OSFileDescriptor handle(FileHandle file) noexcept;
 
    static FileHandle open(OSFileDescriptor descriptor) noexcept;
};
 
 
}
 
 
#ifndef UVW_AS_LIB
#include "fs.cpp"
#endif
 
#endif // UVW_FS_INCLUDE_H