binary.hpp

#pragma once
 
#include "centipede/data/entry.hpp"
#include "centipede/util/error_types.hpp"
#include "centipede/util/return_types.hpp"
 
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <expected>
#include <fstream>
#include <ranges>
#include <string>
#include <utility>
#include <vector>
 
namespace centipede::writer
{
    class Binary
    {
      public:
        struct Config
        {
            static constexpr auto DEFAULT_BUFFER_SIZE = std::size_t{ 10000 };
 
            std::string out_filename = "output.bin";             
            uint32_t max_bufferpoint_size = DEFAULT_BUFFER_SIZE; 
        };
 
        using BufferType = std::pair<std::vector<uint32_t>, std::vector<float>>; 
        using BufferPoint = std::pair<uint32_t, float>; 

        Binary() = default;

        constexpr explicit Binary(Config config)
            : config_{ std::move(config) }
        {
        }

        [[nodiscard]] auto init() -> EnumError<>;

        template <std::size_t NLocals, std::size_t NGlobals>
        [[nodiscard]] auto add_entrypoint(const EntryPoint<NLocals, NGlobals>& entry_point) -> EnumError<>;

        auto write_current_entry() -> EnumError<std::size_t>;

        void close() { output_file_.close(); };

        constexpr auto get_config() const -> const Config& { return config_; }

        constexpr auto get_buffer() const -> const BufferType& { return data_buffer_; }
 
      private:
        bool has_entry_ = false;
        Config config_;             
        BufferType data_buffer_;    
        std::ofstream output_file_; 
 
        auto check_buffer_size(std::size_t size_to_add) const -> bool;
        auto write_to_binary() -> std::size_t;
        void reset();
        void resize_data_buffer(std::size_t size);
        auto fill_entrypoint_to_buffer(BufferPoint buffer_point, bool has_check_value = false) -> bool;
    };
 
    template <std::size_t NLocals, std::size_t NGlobals>
    auto Binary::add_entrypoint(const EntryPoint<NLocals, NGlobals>& entry_point) -> EnumError<>
    {
        assert(data_buffer_.first.size() == data_buffer_.second.size());
 
        if (entry_point.sigma <= 0.)
        {
            return std::unexpected{ ErrorCode::writer_neg_or_zero_sigma };
        }
        if (data_buffer_.first.empty())
        {
            return std::unexpected{ ErrorCode::writer_uninitialized };
        }
        if (not check_buffer_size(NLocals + NGlobals + 2))
        {
            return std::unexpected{ ErrorCode::writer_buffer_overflow };
        }
 
        auto old_size = data_buffer_.first.size();
        auto has_entry = false;
 
        fill_entrypoint_to_buffer(BufferPoint{ 0, entry_point.measurement });
 
        // NOTE: Can be changed to concat in C++26
 
        for (const auto& [idx, local_deriv] : std::views::zip(std::views::iota(0), entry_point.local_derivs))
        {
            has_entry |= fill_entrypoint_to_buffer(BufferPoint{ idx + 1, local_deriv }, true);
        }
 
        fill_entrypoint_to_buffer(BufferPoint{ 0, entry_point.sigma });
 
        for (const auto& [idx, global_deriv] : entry_point.global_derivs)
        {
            has_entry |= fill_entrypoint_to_buffer(BufferPoint{ idx + 1, global_deriv }, true);
        }
 
        has_entry_ |= has_entry;
        if (not has_entry)
        {
            resize_data_buffer(old_size);
            return std::unexpected{ ErrorCode::writer_entrypoint_rejected };
        }
        return {};
    }
} // namespace centipede::writer
 
namespace centipede
{
    using BinaryWriter = writer::Binary;
}