VectorStorage.hpp

// <VectorStorage> -*- C++ -*-
 
#pragma once
 
#include "sparta/functional/ArchData.hpp"
#include "sparta/utils/SpartaException.hpp"
 
namespace sparta::serialization::checkpoint::storage
{
 
class VectorStorage
{
    class Segment{
        ArchData::line_idx_type idx_;
        std::vector<char> data_;
        uint32_t bytes_;
    public:
 
        Segment(const Segment&) = default;
 
        Segment(Segment&& rhp) :
            idx_(rhp.idx_),
            data_(std::move(rhp.data_)),
            bytes_(rhp.bytes_)
        {
            rhp.idx_ = ArchData::INVALID_LINE_IDX;
            rhp.bytes_ = 0;
        }
 
        Segment() :
            idx_(ArchData::INVALID_LINE_IDX),
            bytes_(0)
        {;}
 
        Segment& operator=(const Segment& rhp) = delete;
 
        Segment(ArchData::line_idx_type idx, const char* data, size_t bytes) :
            idx_(idx), bytes_(bytes)
        {
            sparta_assert(idx != ArchData::INVALID_LINE_IDX,
                            "Attempted to create segment of " << bytes << " bytes with invalid line index");
            data_.resize(bytes);
            ::memcpy(data_.data(), data, bytes);
        }
 
        template <typename Archive>
        void serialize(Archive& ar, const unsigned int /*version*/) {
            ar & idx_;
            ar & data_;
            ar & bytes_;
        }
 
        ArchData::line_idx_type getLineIdx() const {
            return idx_;
        }
 
        uint32_t getSize() const {
            return sizeof(decltype(*this)) + bytes_;
        }
 
        void copyTo(char* buf, uint32_t size) const {
            sparta_assert(size == bytes_, \
                            "Attempted to restore checkpoint data for a line where the "
                            "data was " << bytes_ << " bytes but the loader requested "
                            << size << " bytes. The sizes must match up or something is "
                            "wrong");
            memcpy(buf, data_.data(), bytes_);
        }
 
        void dump(std::ostream& o) const {
            if(idx_ == ArchData::INVALID_LINE_IDX){
                std::cout << "\nEnd of ArchData";
                return;
            }
 
            std::cout << "\nLine: " << std::dec << idx_ << " (" << bytes_ << ") bytes";
            for(uint32_t off = 0; off < bytes_;){
                char chr = data_[off];
                if(off % 32 == 0){
                    o << std::endl << std::setw(7) << std::hex << off;
                }
                if(chr == 0){
                    o << ' ' << "..";
                }else{
                    o << ' ' << std::setfill('0') << std::setw(2) << std::hex << (0xff & (uint16_t)chr);
                }
                off++;
            }
        }
    };
 
    std::vector<Segment> data_;
 
    ArchData::line_idx_type next_idx_ = ArchData::INVALID_LINE_IDX;
 
    uint32_t next_restore_idx_ = 0;
 
    decltype(data_)::const_iterator cur_restore_itr_;
 
public:
    VectorStorage() {
    }
 
    ~VectorStorage() {
    }
 
    VectorStorage(const VectorStorage&) = default;
 
    template <typename Archive>
    void serialize(Archive& ar, const unsigned int /*version*/) {
        ar & data_;
    }
 
    void dump(std::ostream& o) const {
        for(auto const &seg : data_){
            seg.dump(o);
        }
    }
 
    uint32_t getSize() const {
        uint32_t bytes = sizeof(decltype(*this));
        for(Segment const & seg : data_){
            bytes += seg.getSize();
        }
        return bytes;
    }
 
    void prepareForLoad() {
        next_restore_idx_ = 0;
        cur_restore_itr_ = data_.begin();
    }
 
    void beginLine(ArchData::line_idx_type idx) {
        sparta_assert(idx != ArchData::INVALID_LINE_IDX,
                        "Cannot begin line with INVALID_LINE_IDX index");
        next_idx_ = idx;
    }
 
    void writeLineBytes(const char* data, size_t size) {
        sparta_assert(data_.size() == 0 || data_.back().getLineIdx() != next_idx_,
                        "Cannot store the same line idx twice in a checkpoint. Line "
                        << next_idx_ << " detected twice in a row");
        sparta_assert(next_idx_ != ArchData::INVALID_LINE_IDX,
                        "Cannot write line bytes with INVALID_LINE_IDX index");
        data_.emplace_back(next_idx_, data, size);
    }
 
    void endArchData() {
        data_.emplace_back();
    }
 
    bool good() const {
        return next_restore_idx_ <= data_.size(); // Not past end of stream
    }
 
    ArchData::line_idx_type getNextRestoreLine() {
        if(next_restore_idx_ == data_.size()){
            next_restore_idx_++; // Increment to detect errors
            return ArchData::INVALID_LINE_IDX; // Done with restore
        }else if(next_restore_idx_ > data_.size()){ // Past the end
            throw SpartaException("Failed to restore a checkpoint because ")
                << "caller tried to keep getting next line even after "
                "reaching the end of the restore data";
        }
        if(next_restore_idx_ != 0){
            cur_restore_itr_++;
        }
        next_restore_idx_++;
 
        const auto next_line_idx = cur_restore_itr_->getLineIdx(); // May be invalid to indicate end of ArchData
        return next_line_idx;
    };
 
    void copyLineBytes(char* buf, uint32_t size) {
        sparta_assert(cur_restore_itr_ != data_.end(),
                        "Attempted to copy line bytes from an invalid line iterator");
        sparta_assert(cur_restore_itr_->getLineIdx() != ArchData::INVALID_LINE_IDX,
                        "About to return line from checkpoint data segment with INVALID_LINE_IDX index");
        cur_restore_itr_->copyTo(buf, size);
    }
 
};
 
} // namespace sparta::serialization::checkpoint::storage