CollectableTreeNode.hpp

Go to the documentation of this file.

// <CollectableTreeNode> -*- C++ -*-
 
 
#pragma once
 
#include <string>
#include <inttypes.h>
 
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/collection/Collector.hpp"
#include "simdb/apps/argos/ArgosCollector.hpp"
 
namespace sparta{
namespace collection
{
 
    class CollectableTreeNode : public sparta::TreeNode
    {
    public:
        CollectableTreeNode(sparta::TreeNode* parent, const std::string& name,
                            const std::string& group, uint32_t index,
                            const std::string& desc = "CollectableTreeNode <no desc>") :
            sparta::TreeNode(parent, name, group, index, desc)
        {
            markHidden(); // Mark self as hidden from the default
                          // printouts (to reduce clutter)
        }
 
        CollectableTreeNode(sparta::TreeNode* parent, const std::string& name,
                            const std::string& desc= "CollectableTreeNode <no desc>") :
            CollectableTreeNode(parent, name, sparta::TreeNode::GROUP_NAME_NONE,
                                sparta::TreeNode::GROUP_IDX_NONE, desc)
        {}
 
        virtual ~CollectableTreeNode()
        {}
 
        bool isIterableCollectorBin() const {
            return dynamic_cast<const CollectableTreeNode*>(getParent()) != nullptr;
        }
 
        virtual void createSimDbEntryPoint(simdb::argos::ArgosCollector*) = 0;
 
        virtual void serializeStructSchema(simdb::DatabaseManager*, std::set<std::string>& serialized_types) {
            (void)serialized_types;
        }
 
        virtual std::string encodeCollectedType(bool human_readable = false) const = 0;
 
        void startCollecting(Collector * collector) {
            is_collected_ = true;
            if (!isIterableCollectorBin()) {
                setCollecting_(true, collector);
            }
        }
 
        void stopCollecting(Collector * collector)
        {
            if (!isIterableCollectorBin()) {
                setCollecting_(false, collector);
            }
            is_collected_ = false;
        }
 
        bool isCollected() const { return is_collected_; }
 
        virtual void collect() = 0;
 
        virtual void restartRecord() {}
 
        virtual void closeRecord(const bool & simulation_ending = false) { (void) simulation_ending; }
 
    protected:
 
        virtual void setCollecting_(bool collect, Collector *) { (void) collect; }
 
        simdb::argos::EntryPoint* entry_point_ = nullptr;
 
    private:
 
        bool is_collected_ = false;
 
    };
 
}
}