Mille.h

Go to the documentation of this file.

#pragma once
#include "MilleEntry.h"
#include <cstddef>
#include <cstdint>
#include <fstream>
#include <string_view>
#include <utility>
#include <vector>
 
namespace R3B
{
    constexpr auto DEFAULT_BUFFER_SIZE = std::size_t{ 10000 };
    template <typename IndexType = int, typename ValueType = float>
    class MilleBuffer
    {
      public:
        MilleBuffer() = default;
        void clear()
        {
            index_buffer_.clear();
            value_buffer_.clear();
        }
        auto get_current_size() -> std::size_t { return index_buffer_.size() + value_buffer_.size(); }
        inline void add_entry(IndexType index, ValueType value) // NOLINT
        {
            index_buffer_.emplace_back(index);
            value_buffer_.emplace_back(value);
        }
        auto is_empty() -> bool { return get_current_size() == 0; }
 
        auto get_indices() -> const auto& { return index_buffer_; }
        auto get_values() -> const auto& { return value_buffer_; }
 
      private:
        std::vector<IndexType> index_buffer_; // buffer to store local and global indices
        std::vector<ValueType> value_buffer_; // buffer to store local and global derivatives
    };
 
    class Mille
    {
      public:
        explicit Mille(std::string_view outFileName, bool asBinary = true, bool writeZero = false);
        void set_buffer_size(std::size_t buffer_size) { max_buffer_size_ = buffer_size; }

        void mille(const MilleDataPoint& data_point);
        void special(const std::vector<std::pair<int, float>>& special_data);
        void reset();

        void end();
        void close();
 
        auto get_n_entries() const -> uint64_t { return num_of_entries_; }
 
      private:
        bool has_special_done_ = false;                     
        bool is_binary_ = true;                             
        bool is_zero_written_ = false;                      
        MilleBuffer<int, float> buffer_;                    
        std::size_t max_buffer_size_ = DEFAULT_BUFFER_SIZE; 
        std::ofstream output_file_;                         
        uint64_t num_of_entries_ = 0;
 
        static constexpr unsigned int max_label_size_ = (0xFFFFFFFF - (1U << 31U));
 
        void check_buffer_size(std::size_t nLocal, std::size_t nGlobal);
        void write_to_binary();
        void write_to_non_binary();
    };
} // namespace R3B