MetaTreeNode.hpp

Go to the documentation of this file.

// <MetaTreeNode.hpp> -*- C++ -*-
 
 
#pragma once
 
#include <memory>
#include "sparta/kernel/Scheduler.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/simulation/Parameter.hpp"
#include "sparta/simulation/ParameterSet.hpp"
 
 
namespace sparta {
namespace app {
 
class ParameterTemplate
{
    class FactoryIF
    {
    public:
        virtual ParameterBase* create() const = 0;
 
        virtual ~FactoryIF()
        {;}
    };
 
    template <typename T>
    class Factory : public FactoryIF
    {
        std::string name_;
        T def_val_;
        std::string docstring_;
 
    public:
        Factory(const std::string& name, const T& def_val, const std::string& docstring)
          : name_(name),
            def_val_(def_val),
            docstring_(docstring)
        {;}
 
        ParameterBase* create() const override { return new Parameter<T>(name_, def_val_, docstring_); }
    };
 
    std::shared_ptr<FactoryIF> fact_;
 
public:
 
    template <typename T>
    ParameterTemplate(const std::string& name, const T& def_val, const std::string& docstring)
      : fact_(new Factory<T>(name, def_val, docstring))
    {;}
 
    ParameterTemplate(const std::string& name, const char* def_val, const std::string& docstring)
      : fact_(new Factory<std::string>(name, def_val, docstring))
    {;}
 
    ParameterTemplate(const ParameterTemplate&) = default;
    ParameterTemplate(ParameterTemplate&&) = default;
 
    ParameterTemplate& operator=(const ParameterTemplate&) = default;
 
    ParameterBase* create() const { return fact_->create(); }
};
 
class MetaTreeNode : public RootTreeNode
{
 
    class ParameterSet : public sparta::ParameterSet
    {
        std::vector<ParameterBase*> owned_params_;
 
    public:
 
        ParameterSet(TreeNode *n, const std::list<ParameterTemplate>& plist)
          : sparta::ParameterSet(n)
        {
            for(auto& pt: plist){
                ParameterBase* pb = pt.create();
                addParameter_(pb);
                owned_params_.push_back(pb);
            }
        }
 
        ParameterSet(TreeNode *n)
          : sparta::ParameterSet(n)
        {;}
 
        ~ParameterSet()
        {
            for(ParameterBase*& p : owned_params_){
                delete p;
                p = nullptr;
            }
        }
 
        // Built-in parameters
 
        PARAMETER (std::string, architecture, "NONE", "Name of architecture being simulated")
        PARAMETER (bool, is_final_config, false, "True if this config was generated using --write-final-config. "
                   "This value is checked during --read-final-config to validate we are "
                   "loading a full config.")
 
    } params_;
 
public:
 
    MetaTreeNode(app::Simulation* sim, GlobalTreeNode* search_scope, const std::list<ParameterTemplate>& plist)
        : RootTreeNode("meta", "Meta-Data gloabl node", sim, search_scope),
          params_(this, plist)
    {
    }
};
 
} // namespace app
} // naemspace sparta