Checkpoint.hpp

// <Checkpoint> -*- C++ -*-
 
#pragma once
 
#include "sparta/serialization/checkpoint/CheckpointBase.hpp"
 
namespace sparta::serialization::checkpoint
{
    class Checkpoint : public CheckpointBase
    {
    public:
 
 
        Checkpoint() = delete;
 
        Checkpoint(const Checkpoint&) = delete;
 
        Checkpoint& operator=(const Checkpoint&) = delete;
 
        Checkpoint(Checkpoint&&) = delete;
 
        Checkpoint& operator=(Checkpoint&&) = delete;
 
    protected:
 
        Checkpoint(chkpt_id_t id,
                   tick_t tick,
                   Checkpoint* prev) :
            CheckpointBase(id, tick),
            prev_(prev)
        { }
 
    public:
 
        virtual ~Checkpoint() {
            if(getPrev()){
                getPrev()->removeNext(this);
            }
 
            // Reconnect deltas from this checkpoint to the prev (even if nullptr)
            for(auto& d : getNexts()){
                d->setPrev(getPrev());
                if(getPrev()){
                    getPrev()->addNext(d);
                }
            }
        }
 
 
        Checkpoint* getPrev() const noexcept {
            return prev_;
        }
 
        void setPrev(Checkpoint* prev) noexcept {
            prev_ = prev;
        }
 
        chkpt_id_t getPrevID() const override {
            return prev_ ? prev_->getID() : UNIDENTIFIED_CHECKPOINT;
        }
 
        void addNext(Checkpoint* next) {
            if(!next){
                throw CheckpointError("Cannot specify nullptr in addNext");
            }
            if(next->getPrev() != this){
                throw CheckpointError("Attempting to add a next checkpoint whose previous checkpoint pointer is not 'this'");
            }
            if(next->getTick() < getTick()){
                throw CheckpointError("Attempting to add a next checkpoint whose tick number (")
                    << next->getTick() << " is less than this checkpoint's tick: " << getTick();
            }
            if(std::find(nexts_.begin(), nexts_.end(), next) != nexts_.end()){
                throw CheckpointError("Next argument already present in this checkpoint's nexts_ list. Cannot re-add");
            }
            nexts_.push_back(next);
        }
 
        void removeNext(Checkpoint* next) {
            if(!next){
                throw CheckpointError("Cannot specify nullptr in removeNext");
            }
            if(next->getPrev() != this){
                throw CheckpointError("Attempting to remove a next checkpoint whose previous pointer is not 'this'");
            }
            auto itr = std::find(nexts_.begin(), nexts_.end(), next);
            if(itr == nexts_.end()){
                throw CheckpointError("Next argument was not present in this checkpoint's nexts_ list. Cannot remove");
            }
            nexts_.erase(itr);
        }
 
        const std::vector<Checkpoint*>& getNexts() const noexcept { return nexts_; }
 
        std::vector<chkpt_id_t> getNextIDs() const override {
            std::vector<chkpt_id_t> next_ids;
            for (const auto chkpt : getNexts()) {
                next_ids.push_back(chkpt->getID());
            }
            return next_ids;
        }
 
 
    private:
 
        std::vector<Checkpoint*> nexts_;
 
        Checkpoint* prev_; 
    };
 
} // namespace sparta::serialization::checkpoint