file_file_intf.hpp

// 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 "file_file_win32_impl.hpp"
#include "../container/module.hpp"
#include "../utility/utility.hpp"
#include "../macros.hpp"
#include "access_mode.hpp"
#include "seek_whence.hpp"
#include <mutex>
#include <cstdint>
#include <map>
#include <span>
#include <filesystem>
 
hi_export_module(hikogui.file.file : intf);
 
namespace hi { inline namespace v1 {
 
hi_export class file {
public:
    ~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;
 
    file(std::filesystem::path const& path, access_mode access_mode = access_mode::open_for_read) :
        _pimpl(std::make_shared<detail::file_impl>(path, access_mode))
    {
    }
 
    [[nodiscard]] hi::access_mode access_mode() const noexcept
    {
        return _pimpl->access_mode();
    }
 
    [[nodiscard]] std::shared_ptr<detail::file_impl> pimpl() const noexcept
    {
        return _pimpl;
    }
 
    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;
};
 
}} // namespace hi::v1