ArchiveNode.hpp

// <ArchiveNode> -*- C++ -*-
 
#pragma once
 
#include "sparta/app/ReportDescriptor.hpp"
 
#include <boost/serialization/vector.hpp>
 
namespace sparta {
namespace statistics {
 
class ArchiveNode;
class ArchiveDataSeries;
class RootArchiveNode;
 
class ArchiveNode
{
public:
    ArchiveNode() = default;
 
    ArchiveNode(const std::string & name);
 
    ArchiveNode(const std::string & name,
                const StatisticInstance *) :
        ArchiveNode(name)
    {}
 
    ArchiveNode(const std::string & name,
                const Report *) :
        ArchiveNode(name)
    {}
 
    virtual ~ArchiveNode();
 
    const std::string & getName() const {
        return name_;
    }
 
    void setLeafIndex(const size_t index) {
        leaf_index_ = index;
    }
 
    std::vector<std::shared_ptr<ArchiveNode>> & getChildren() {
        return children_;
    }
 
    const std::vector<std::shared_ptr<ArchiveNode>> & getChildren() const {
        return children_;
    }
 
    void setParent(std::shared_ptr<ArchiveNode> & parent) {
        setParent(parent.get());
    }
 
    void setParent(ArchiveNode * parent) {
        sparta_assert(parent_ == nullptr, "Cannot reassign parent archive nodes");
        parent_ = parent;
    }
 
    RootArchiveNode * getRoot();
 
    bool isLeaf() const {
        return children_.empty();
    }
 
    bool canAccessDataSeries() const {
        return isLeaf() && leaf_index_.isValid();
    }
 
    ArchiveDataSeries * createDataSeries();
 
    size_t getTotalNumLeaves() const {
        size_t num_leaves = (children_.empty() ? 1 : 0);
        for (const auto & child : children_) {
            recursGetTotalNumLeaves_(*child, num_leaves);
        }
        return num_leaves;
    }
 
protected:
    std::string name_;
 
    std::vector<std::shared_ptr<ArchiveNode>> children_;
 
private:
    void recursGetTotalNumLeaves_(
        const ArchiveNode & node, size_t & num_leaves) const
    {
        if (node.children_.empty()) {
            ++num_leaves;
        } else {
            for (const auto & child : node.children_) {
                recursGetTotalNumLeaves_(*child, num_leaves);
            }
        }
    }
 
    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive & ar, const unsigned int) {
        //Simple data types like strings and ints can
        //call the operator& method directly
        ar & name_;
 
        //Our children variable is a vector<shared_ptr<ArchiveNode>>
        //and Boost will call the serialize() method for each of those
        //shared_ptr's. That method is at the bottom of this file. Shortly
        //after calling serialize(Archive & ar, std::shared_ptr<ArchiveNode> & node)
        //Boost will call this method we are in right now.
        ar & children_;
 
        //There are only so many serialization routines that you
        //get for free (std::string, vectors/lists/maps of simple
        //types, PODs, etc.) but ValidValue<T> is not one of them.
        //This serialize() method is at the bottom of this file.
        ar & leaf_index_;
    }
 
    RootArchiveNode * cached_root_ = nullptr;
    ArchiveNode * parent_ = nullptr;
    utils::ValidValue<size_t> leaf_index_;
    std::unique_ptr<ArchiveDataSeries> ar_data_series_;
};
 
class ArchiveDataSeries
{
public:
    ArchiveDataSeries(const size_t leaf_index,
                      RootArchiveNode * root) :
        leaf_index_(leaf_index),
        root_(root)
    {
        sparta_assert(root_ != nullptr);
    }
 
    inline double getValueAt(const size_t idx) {
        synchronize_();
        return data_values_.at(idx);
    }
 
    const std::vector<double> & getDataReference() {
        synchronize_();
        return data_values_;
    }
 
    size_t size() {
        synchronize_();
        return data_values_.size();
    }
 
    bool empty() {
        synchronize_();
        return size() == 0;
    }
 
private:
    //Read in the data archive and flip the dirty flag
    //back to "not dirty"
    void synchronize_();
    void readAllDataFromArchive_();
 
    std::vector<double> data_values_;
    const size_t leaf_index_;
    RootArchiveNode * root_ = nullptr;
};
 
} // namespace statistics
} // namespace sparta
 
namespace boost {
namespace serialization {
 
template <class Archive>
void serialize(Archive & ar,
               std::shared_ptr<sparta::statistics::ArchiveNode> & node,
               const unsigned int)
{
    if (node == nullptr) {
        node.reset(new sparta::statistics::ArchiveNode);
    }
    ar & *node;
}
 
template <class Archive>
void serialize(Archive & ar,
               sparta::utils::ValidValue<size_t> & vv,
               const unsigned int)
{
    if (vv.isValid()) {
        ar & vv.getValue();
    } else {
        size_t value = 0;
        ar & value;
        vv = value;
    }
}
 
} // namespace serialization
} // namespace boost