File.hpp

Go to the documentation of this file.

#ifndef DONUT_FILE_HPP
#define DONUT_FILE_HPP
 
#include <donut/UniqueHandle.hpp>
 
#include <cstddef>   // std::size_t, std::ptrdiff_t, std::byte
#include <cstdint>   // std::int64_t, std::uint8_t
#include <span>      // std::span
#include <stdexcept> // std::runtime_error
#include <string>    // std::string
#include <vector>    // std::vector
 
namespace donut {
 
class Filesystem; // Forward declaration, to avoid a circular include of Filesystem.hpp.
 
class File {
public:
    struct Error : std::runtime_error {
        explicit Error(const std::string& message)
            : std::runtime_error(message) {}
 
        explicit Error(const char* message)
            : std::runtime_error(message) {}
    };
 
    enum class Kind : std::uint8_t {
        REGULAR,   
        DIRECTORY, 
        SYMLINK,   
        OTHER,     
    };
 
    struct Metadata {
        std::size_t size;                  
        std::int64_t creationTime;         
        std::int64_t lastAccessTime;       
        std::int64_t lastModificationTime; 
        Kind kind;                         
        bool readOnly;                     
    };
 
    static constexpr std::size_t NPOS = static_cast<std::size_t>(-1);
 
    constexpr File() noexcept = default;
 
    constexpr explicit operator bool() const noexcept {
        return isOpen();
    }
 
    void close();
 
    [[nodiscard]] constexpr bool isOpen() const noexcept {
        return static_cast<bool>(file);
    }
 
    [[nodiscard]] bool eof() const noexcept;
 
    [[nodiscard]] std::size_t size() const noexcept;
 
    [[nodiscard]] std::size_t tellg() const noexcept;
 
    [[nodiscard]] std::size_t tellp() const noexcept;
 
    void seekg(std::size_t position);
 
    void seekp(std::size_t position);
 
    void skipg(std::ptrdiff_t offset);
 
    void skipp(std::ptrdiff_t offset);
 
    [[nodiscard]] std::vector<std::byte> readAll() &&;
 
    [[nodiscard]] std::string readAllIntoString() &&;
 
    [[nodiscard]] std::size_t read(std::span<std::byte> data);
 
    std::size_t write(std::span<const std::byte> data);
 
    void flush();
 
private:
    friend Filesystem;
 
    constexpr explicit File(void* handle) noexcept
        : file(handle) {}
 
    struct FileDeleter {
        void operator()(void* handle) const noexcept;
    };
 
    UniqueHandle<void*, FileDeleter> file{};
};
 
} // namespace donut
 
#endif