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 <mutex>
#include <cstdint>
#include <map>
#include <span>
 
namespace tt {
 
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]] inline access_mode operator|(access_mode lhs, access_mode rhs) noexcept
{
    return static_cast<access_mode>(static_cast<int>(lhs) | static_cast<int>(rhs));
}
 
[[nodiscard]] inline access_mode operator&(access_mode lhs, access_mode rhs) noexcept
{
    return static_cast<access_mode>(static_cast<int>(lhs) & static_cast<int>(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);
 
    size_t size() const;
 
    ssize_t seek(ssize_t offset, seek_whence whence = seek_whence::begin);
 
    ssize_t get_seek() {
        return seek(0, seek_whence::current);
    }
 
    ssize_t write(std::byte const *data, ssize_t size, ssize_t offset=-1);
 
    ssize_t write(void const *data, ssize_t size, ssize_t offset=-1) {
        return write(reinterpret_cast<std::byte const *>(data), size, offset);
    }
 
    ssize_t write(char const *data, ssize_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, ssize_t offset = -1)
    {
        return write(bytes.data(), std::ssize(bytes), offset);
    }
 
    ssize_t write(bstring_view text, ssize_t offset = -1)
    {
        return write(text.data(), std::ssize(text), offset);
    }
 
    ssize_t write(bstring const &text, ssize_t offset = -1)
    {
        return write(text.data(), std::ssize(text), offset);
    }
 
    ssize_t write(std::string_view text)
    {
        return write(text.data(), std::ssize(text));
    }
 
    ssize_t read(std::byte *data, ssize_t size, ssize_t offset = -1);
 
    ssize_t read(void *data, ssize_t size, ssize_t offset = -1)
    {
        return read(reinterpret_cast<std::byte *>(data), size, offset);
    }
 
    bstring read_bstring(ssize_t size = 10'000'000, ssize_t offset = -1);
 
    std::string read_string(ssize_t max_size = 10'000'000);
 
    std::u8string read_u8string(ssize_t max_size = 10'000'000);
 
    [[nodiscard]] static 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;
};
 
 
}