Directory.hxx

#pragma once
 
// cosmos
#include <cosmos/fs/DirFD.hxx>
#include <cosmos/fs/types.hxx>
#include <cosmos/SysString.hxx>
 
namespace cosmos {
 
 
class COSMOS_API Directory {
public: // functions
 
        Directory() = default;
 
        explicit Directory(DirFD fd, const AutoCloseFD auto_close) {
                open(fd, auto_close);
        }
 
 
        explicit Directory(const SysString path, const OpenMode mode = OpenMode::READ_ONLY) :
                        Directory{path, mode, {OpenFlag::CLOEXEC}} {}
 
 
        explicit Directory(const SysString path, const OpenMode mode, const OpenFlags flags) {
                open(path, mode, flags);
        }
 
        Directory(const DirFD dir_fd, const SysString path, const OpenMode mode = OpenMode::READ_ONLY) :
                        Directory{dir_fd, path, mode, {OpenFlag::CLOEXEC}} {}
 
        Directory(const DirFD dir_fd, const SysString path, const OpenMode mode,
                        const OpenFlags flags) {
                open(dir_fd, path, mode, flags);
        }
 
        // Prevent copying due to the DirFD ownership.
        Directory(const Directory&) = delete;
        Directory& operator=(const Directory&) = delete;
 
        Directory(Directory &&other) noexcept {
                *this = std::move(other);
        }
 
        Directory& operator=(Directory &&other) noexcept {
                m_auto_close = other.m_auto_close;
                m_fd = other.m_fd;
 
                other.m_auto_close = AutoCloseFD{true};
                other.m_fd.reset();
                return *this;
        }
 
        virtual ~Directory();
 
        void open(const SysString path, const OpenMode mode = OpenMode::READ_ONLY) {
                return open(path, mode, {OpenFlag::CLOEXEC});
        }
 
 
        void open(const SysString path, const OpenMode mode, OpenFlags flags);
 
        void open(const DirFD dir_fd, const SysString path, const OpenMode mode) {
                open(dir_fd, path, mode, {OpenFlag::CLOEXEC});
        }
 
        void open(const DirFD dir_fd, const SysString path, const OpenMode mode,
                        const OpenFlags flags);
 
 
        void open(DirFD fd, const AutoCloseFD auto_close) {
                m_fd = fd;
                m_auto_close = auto_close;
        }
 
        bool isOpen() const { return m_fd.valid(); }
 
 
        void close() {
                if (!isOpen())
                        return;
 
                if (m_auto_close) {
                        m_fd.close();
                } else {
                        m_fd.reset();
                }
 
                m_auto_close = AutoCloseFD{true};
        }
 
        DirFD fd() const { return m_fd; }
 
        // \see fs::unlink_file_at()
        inline void unlinkFileAt(const SysString path) const;
 
        // \see fs::make_dir_at()
        inline void makeDirAt(const SysString path, const FileMode mode) const;
 
        // \see fs::remove_dir_at()
        inline void removeDirAt(const SysString path) const;
 
        // \see fs::read_symlink_at()
        inline std::string readSymlinkAt(const SysString path) const;
 
        // \see fs::make_symlink_at()
        inline void makeSymlinkAt(const SysString target, const SysString path) const;
 
protected: // data
 
        AutoCloseFD m_auto_close;
        DirFD m_fd;
};
 
} // end ns
 
// only include this here, because of dependency issues
#include <cosmos/fs/filesystem.hxx>
 
namespace cosmos {
 
void Directory::unlinkFileAt(const SysString path) const {
        fs::unlink_file_at(m_fd, path);
}
 
void Directory::makeDirAt(const SysString path, const FileMode mode) const {
        fs::make_dir_at(m_fd, path, mode);
}
 
void Directory::removeDirAt(const SysString path) const {
        fs::remove_dir_at(m_fd, path);
}
 
std::string Directory::readSymlinkAt(const SysString path) const {
        return fs::read_symlink_at(m_fd, path);
}
 
void Directory::makeSymlinkAt(const SysString target, const SysString path) const {
        fs::make_symlink_at(target, m_fd, path);
}
 
} // end ns