binary_file_io_internal.h

#pragma once
 
#include "pixelbullet/filesystem/native_path.h"
 
#include <filesystem>
#include <fstream>
#include <limits>
#include <span>
#include <string>
#include <string_view>
#include <system_error>
#include <type_traits>
#include <utility>
 
namespace pixelbullet::serialization_internal
{
inline void set_binary_io_error(std::string* error_message, std::string message)
{
    if (error_message != nullptr)
    {
        *error_message = std::move(message);
    }
}
 
[[nodiscard]] inline bool streamsize_fits(const std::size_t byte_count) noexcept
{
    return byte_count <= static_cast<std::size_t>(std::numeric_limits<std::streamsize>::max());
}
 
[[nodiscard]] inline std::ifstream open_binary_input_file(const std::filesystem::path& path, const std::string_view label,
                                                          std::string* error_message = nullptr)
{
    if (path.empty())
    {
        set_binary_io_error(error_message, "Failed to open " + std::string(label) + " for reading: path is empty.");
        return {};
    }
 
    std::ifstream stream(filesystem::to_native_file_io_path(path), std::ios::binary);
    if (!stream)
    {
        set_binary_io_error(error_message, "Failed to open " + std::string(label) + " for reading: " + path.string());
    }
    return stream;
}
 
[[nodiscard]] inline std::ofstream open_binary_output_file(const std::filesystem::path& path, const std::string_view label,
                                                           std::string* error_message = nullptr)
{
    if (path.empty())
    {
        set_binary_io_error(error_message, "Failed to open " + std::string(label) + " for writing: path is empty.");
        return {};
    }
 
    const std::filesystem::path native_path = filesystem::to_native_file_io_path(path);
    const std::filesystem::path parent = native_path.parent_path();
    if (!parent.empty())
    {
        std::error_code error_code;
        std::filesystem::create_directories(parent, error_code);
        if (error_code)
        {
            set_binary_io_error(error_message, "Failed to create " + std::string(label) + " output directory '" + parent.string() +
                                                   "': " + error_code.message());
            return {};
        }
    }
 
    std::ofstream stream(native_path, std::ios::binary | std::ios::trunc);
    if (!stream)
    {
        set_binary_io_error(error_message, "Failed to open " + std::string(label) + " for writing: " + path.string());
    }
    return stream;
}
 
[[nodiscard]] inline bool finish_binary_output_file(std::ofstream& stream, const std::filesystem::path& path, const std::string_view label,
                                                    std::string* error_message = nullptr)
{
    stream.flush();
    if (!stream)
    {
        set_binary_io_error(error_message, "Failed to flush " + std::string(label) + ": " + path.string());
        return false;
    }
 
    stream.close();
    if (!stream)
    {
        set_binary_io_error(error_message, "Failed to close " + std::string(label) + ": " + path.string());
        return false;
    }
    return true;
}
 
[[nodiscard]] inline bool read_bytes(std::istream& stream, void* bytes, const std::size_t byte_count)
{
    if (byte_count == 0u)
    {
        return true;
    }
    if (bytes == nullptr || !streamsize_fits(byte_count))
    {
        return false;
    }
    return static_cast<bool>(stream.read(static_cast<char*>(bytes), static_cast<std::streamsize>(byte_count)));
}
 
[[nodiscard]] inline bool write_bytes(std::ostream& stream, const void* bytes, const std::size_t byte_count)
{
    if (byte_count == 0u)
    {
        return true;
    }
    if (bytes == nullptr || !streamsize_fits(byte_count))
    {
        return false;
    }
    return static_cast<bool>(stream.write(static_cast<const char*>(bytes), static_cast<std::streamsize>(byte_count)));
}
 
template <typename T>
[[nodiscard]] bool read_trivial(std::istream& stream, T& value)
{
    static_assert(std::is_trivially_copyable_v<T>);
    return read_bytes(stream, &value, sizeof(T));
}
 
template <typename T>
[[nodiscard]] bool write_trivial(std::ostream& stream, const T& value)
{
    static_assert(std::is_trivially_copyable_v<T>);
    return write_bytes(stream, &value, sizeof(T));
}
 
template <typename T>
[[nodiscard]] bool read_trivial_span(std::istream& stream, const std::span<T> values)
{
    static_assert(std::is_trivially_copyable_v<T>);
    return read_bytes(stream, values.data(), values.size_bytes());
}
 
template <typename T>
[[nodiscard]] bool write_trivial_span(std::ostream& stream, const std::span<const T> values)
{
    static_assert(std::is_trivially_copyable_v<T>);
    return write_bytes(stream, values.data(), values.size_bytes());
}
} // namespace pixelbullet::serialization_internal