file.hpp

// Copyright Take Vos 2019-2020.
// 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 "URL.hpp"
#include "byte_string.hpp"
#include "architecture.hpp"
#include "cast.hpp"
#include <mutex>
#include <cstdint>
#include <map>
#include <span>
 
namespace hi::inline 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));
}
 
bool operator>=(access_mode const& lhs, access_mode const& rhs) = delete;
 
[[nodiscard]] constexpr bool any(access_mode const& rhs) noexcept
{
    return static_cast<bool>(to_underlying(rhs));
}
 
[[nodiscard]] inline bool operator>=(access_mode lhs, access_mode rhs) noexcept
{
    return (lhs & rhs) == rhs;
}
 
class file {
public:
    file(URL const& location, access_mode accessMode);
 
    ~file() noexcept;
 
    file(file const& other) = delete;
    file(file&& other) = delete;
    file& operator=(file const& other) = delete;
    file& operator=(file&& other) = delete;
 
    void close();
 
    void flush();
 
    void rename(URL const& destination, bool overwrite_existing = true);
 
    std::size_t size() const;
 
    std::size_t seek(ssize_t offset, seek_whence whence = seek_whence::begin);
 
    std::size_t get_seek()
    {
        return seek(0, seek_whence::current);
    }
 
    std::size_t write(std::byte const *data, std::size_t size, ssize_t offset = -1);
 
    std::size_t write(void const *data, std::size_t size, ssize_t offset = -1)
    {
        return write(reinterpret_cast<std::byte const *>(data), size, offset);
    }
 
    ssize_t write(char const *data, std::size_t size, ssize_t offset = -1)
    {
        return write(reinterpret_cast<std::byte const *>(data), size, offset);
    }
 
    ssize_t write(std::span<std::byte const> bytes, std::size_t offset = -1)
    {
        return write(bytes.data(), ssize(bytes), offset);
    }
 
    ssize_t write(bstring_view text, ssize_t offset = -1)
    {
        return write(text.data(), ssize(text), offset);
    }
 
    ssize_t write(bstring const& text, ssize_t offset = -1)
    {
        return write(text.data(), ssize(text), offset);
    }
 
    ssize_t write(std::string_view text)
    {
        return write(text.data(), ssize(text));
    }
 
    ssize_t read(std::byte *data, std::size_t size, ssize_t offset = -1);
 
    ssize_t read(void *data, std::size_t size, ssize_t offset = -1)
    {
        return read(reinterpret_cast<std::byte *>(data), size, offset);
    }
 
    bstring read_bstring(std::size_t size = 10'000'000, ssize_t offset = -1);
 
    std::string read_string(std::size_t max_size = 10'000'000);
 
    std::u8string read_u8string(std::size_t max_size = 10'000'000);
 
    [[nodiscard]] static std::size_t file_size(URL const& url);
 
    static void create_directory(URL const& url, bool hierarchy = false);
 
    static void create_directory_hierarchy(URL const& url);
 
private:
    access_mode _access_mode;
 
    URL _location;
 
    file_handle _file_handle;
 
    friend class file_mapping;
    friend class file_view;
};
 
} // namespace hi::inline v1