file.hpp

Go to the documentation of this file.

// Copyright Take Vos 2019-2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "../byte_string.hpp"
#include "../utility/module.hpp"
#include <mutex>
#include <cstdint>
#include <map>
#include <span>
#include <filesystem>
 
namespace hi { inline namespace v1 {
 
enum class seek_whence {
    begin, 
    current, 
    end 
};
 
enum class access_mode {
    read = 0x1, 
    write = 0x2, 
    rename = 0x4, 
    read_lock = 0x10, 
    write_lock = 0x20, 
    open = 0x100, 
    create = 0x200, 
    truncate = 0x400, 
    random = 0x1000, 
    sequential = 0x2000, 
    no_reuse = 0x4000, 
    write_through = 0x8000, 
    create_directories = 0x10000, 
 
    open_for_read = open | read, 
    open_for_read_and_write = open | read | write, 
    truncate_or_create_for_write = create_directories | open | create | truncate | write
};
 
[[nodiscard]] constexpr access_mode operator|(access_mode const& lhs, access_mode const& rhs) noexcept
{
    return static_cast<access_mode>(to_underlying(lhs) | to_underlying(rhs));
}
 
[[nodiscard]] constexpr access_mode operator&(access_mode const& lhs, access_mode const& rhs) noexcept
{
    return static_cast<access_mode>(to_underlying(lhs) & to_underlying(rhs));
}
 
[[nodiscard]] constexpr bool to_bool(access_mode const& rhs) noexcept
{
    return to_bool(to_underlying(rhs));
}
 
namespace detail {
 
class file_impl {
public:
    virtual ~file_impl() = default;
    file_impl(file_impl const& other) = delete;
    file_impl(file_impl&& other) = delete;
    file_impl& operator=(file_impl const& other) = delete;
    file_impl& operator=(file_impl&& other) = delete;
 
    file_impl(access_mode access_mode) : _access_mode(access_mode) {}
 
    [[nodiscard]] hi::access_mode access_mode() const noexcept
    {
        return _access_mode;
    }
 
    [[nodiscard]] virtual bool closed() = 0;
    virtual void close() = 0;
    virtual void flush() = 0;
    virtual void rename(std::filesystem::path const& destination, bool overwrite_existing) = 0;
    [[nodiscard]] virtual std::size_t size() const = 0;
    [[nodiscard]] virtual std::size_t seek(std::ptrdiff_t offset, seek_whence whence) = 0;
    virtual void write(void const *data, std::size_t size) = 0;
    [[nodiscard]] virtual std::size_t read(void *data, std::size_t size) = 0;
 
protected:
    hi::access_mode _access_mode;
};
 
} // namespace detail
 
class file {
public:
    file(std::filesystem::path const& path, access_mode access_mode = access_mode::open_for_read);
 
    ~file() = default;
    file(file const& other) noexcept = default;
    file(file&& other) noexcept = default;
    file& operator=(file const& other) noexcept = default;
    file& operator=(file&& other) noexcept = default;
 
    [[nodiscard]] hi::access_mode access_mode() const noexcept
    {
        return _pimpl->access_mode();
    }
 
    void close()
    {
        return _pimpl->close();
    }
 
    void flush()
    {
        return _pimpl->flush();
    }
 
    void rename(std::filesystem::path const& destination, bool overwrite_existing = true)
    {
        return _pimpl->rename(destination, overwrite_existing);
    }
 
    [[nodiscard]] std::size_t size() const
    {
        return _pimpl->size();
    }
 
    std::size_t seek(std::ptrdiff_t offset, seek_whence whence = seek_whence::begin)
    {
        return _pimpl->seek(offset, whence);
    }
 
    std::size_t get_seek()
    {
        return seek(0, seek_whence::current);
    }
 
    void write(void const *data, std::size_t size)
    {
        return _pimpl->write(data, size);
    }
 
    [[nodiscard]] std::size_t read(void *data, std::size_t size)
    {
        return _pimpl->read(data, size);
    }
 
    void write(std::span<std::byte const> bytes)
    {
        return write(bytes.data(), ssize(bytes));
    }
 
    void write(bstring_view text)
    {
        return write(text.data(), ssize(text));
    }
 
    void write(bstring const& text)
    {
        return write(text.data(), ssize(text));
    }
 
    void write(std::string_view text)
    {
        return write(text.data(), ssize(text));
    }
 
    [[nodiscard]] bstring read_bstring(std::size_t max_size = 10'000'000)
    {
        hilet offset = get_seek();
        hilet size_ = std::min(max_size, this->size() - offset);
 
        auto r = bstring{};
        // XXX c++23 resize_and_overwrite()
        r.resize(size_);
        hilet bytes_read = read(r.data(), size_);
        r.resize(bytes_read);
        return r;
    }
 
    [[nodiscard]] std::string read_string(std::size_t max_size = 10'000'000)
    {
        hi_assert(get_seek() == 0);
 
        hilet size_ = size();
        if (size_ > max_size) {
            throw io_error("read_string() requires the file size to be smaler than max_size.");
        }
 
        auto r = std::string{};
        // XXX c++23 resize_and_overwrite()
        r.resize(size_);
        hilet bytes_read = read(r.data(), size_);
        r.resize(bytes_read);
        return r;
    }
 
private:
    std::shared_ptr<detail::file_impl> _pimpl;
 
    friend class file_view;
};
 
}} // namespace hi::v1