Parameter.hpp

Go to the documentation of this file.

// <Parameter> -*- C++ -*-
 
 
#pragma once
 
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <ios>
#include <iomanip>
#include <string>
#include <ostream>
#include <stdexcept>
#include <vector>
#include <functional>
#include <type_traits>
#include <typeinfo>
 
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/utils/Utils.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/kernel/SpartaHandler.hpp"
#include "sparta/utils/KeyValue.hpp"
#include "sparta/utils/LexicalCast.hpp"
#include "sparta/utils/SmartLexicalCast.hpp"
#include "sparta/utils/Printing.hpp"
#include "sparta/utils/VectorUtils.hpp"
#include "sparta/kernel/PhasedObject.hpp"
 
namespace sparta
{
    class ParameterBase;
    class ParameterSet;
 
    template <typename T>
    inline T smartLexicalCast(const ParameterBase* p,
                              const std::string& s,
                              size_t& end_pos,
                              bool allow_recursion=true,
                              bool allow_prefix=true);
 
    class ParameterException : public SpartaException
    {
    public:
 
        ParameterException() = default;
 
        ParameterException(const ParameterException &) = default;
 
        ParameterException(const std::string & reason) :
            SpartaException(reason)
        { }
 
        virtual ~ParameterException() noexcept {}
 
        template<class T>
        ParameterException & operator<<(const T & msg) {
            SpartaException::operator<<(msg);
            return *this;
        }
    };
 
    class ParameterBase : public TreeNode
    {
    public:
 
        static constexpr char PARAMETER_NODE_TAG[] = "SPARTA_Parameter";
 
        typedef class ParameterValueIterator
        {
        public:
 
            ParameterValueIterator(const ParameterBase* pb, size_t idx) :
                p_(pb),
                idx_(idx)
            {
                sparta_assert(pb);
            }
 
            ParameterValueIterator(const ParameterValueIterator& rhp) :
                p_(rhp.p_),
                idx_(rhp.idx_)
            { }
 
            bool operator==(const ParameterValueIterator& rhp) {
                return (idx_ == rhp.idx_) && (p_ == rhp.p_);
            }
 
            bool operator!=(const ParameterValueIterator& rhp) {
                return !(*this == rhp);
            }
 
            const std::string operator*() const {
                if(idx_ >= p_->getNumValues()){
                    throw ParameterException("Tried to dereference invalid ParameterBase iterator");
                }
                return p_->getValueAsStringAt(idx_);
            }
 
            const ParameterValueIterator& operator++() {
                if(idx_ >= p_->getNumValues()){
                    throw ParameterException("Tried to increment past end of ParameterBase iterator");
                }
                ++idx_;
                return *this;
            }
 
            const ParameterValueIterator operator++(int i){
                (void) i;
                ParameterValueIterator current = *this;
                ++(*this);
                return current;
            }
 
        private:
            const ParameterBase* p_; 
            size_t idx_; 
 
        } const_iterator;
 
 
        ParameterBase(const std::string & name,
                      const std::string & desc) :
            TreeNode(name, desc),
            modifier_callback_(name.c_str()),
            ignored_(false),
            string_quote_(""),
            name_(name),
            desc_(desc),
            writes_(0),
            reads_(0),
            is_volatile_(false)
        {
            addTag(PARAMETER_NODE_TAG); // Tag for quick searching
        }
 
        virtual ~ParameterBase() {}
 
        void setIsVolatile() {
            sparta_assert(getPhase() <= TREE_FINALIZED, "Cannot set volatile state on a Parameter after finalization");
            sparta_assert(getReadCount() == 0, "Cannot set volatile state on a Parameter after it has been read");
            is_volatile_ = true;
        }
 
        bool isVolatile() const {return is_volatile_;}
 
        virtual const std::string getTypeName() const = 0;
 
        virtual std::string getDefaultAsString() const = 0;
 
        virtual bool isDefault() const {
            if(getValueAsString() == getDefaultAsString()){
                return true;
            }
            return false;
        }
 
        virtual std::string getValueAsString() const = 0;
 
        virtual std::string getValueAsStringAt(size_t idx, bool peek=false) const = 0;
 
 
        virtual std::string getItemValueFromString(const std::vector<uint32_t>& indices,
                                                   bool peek=false) const = 0;
 
        std::string peekItemValueFromString(const std::vector<uint32_t>& indices) const {
            return getItemValueFromString(indices, true);
        }
 
        template <class T>
        const T getValueAs() const;
 
        virtual bool isVector() const = 0;
 
 
        virtual uint32_t getDimensionality() const = 0;
 
        virtual uint32_t getVectorSizeAt(const std::vector<uint32_t>& indices,
                                         bool peek=false) const = 0;
 
        uint32_t peekVectorSizeAt(const std::vector<uint32_t>& indices) const {
            return getVectorSizeAt(indices, true);
        }
 
        virtual size_t getNumValues(bool peek=false) const = 0;
 
        size_t peekNumValues() const {
            return getNumValues(true);
        }
 
        virtual double getDoubleValue() const = 0;
 
        virtual const_iterator begin() const = 0;
 
        virtual const_iterator end() const = 0;
 
 
        virtual bool isDefaultOverridden() const = 0;
 
        virtual void overrideDefaultFromString(const std::string& val) = 0;
 
        virtual void overrideDefaultFromStringVector(const std::vector<std::string>& val) = 0;
 
        virtual void overrideDefaultItemValueFromString(const std::vector<uint32_t>& indices,
                                                        const std::string& str) = 0;
 
        virtual void overrideDefaultResizeVectorsFromString(const std::vector<uint32_t>& indices) = 0;
 
        virtual void overrideDefaultClearVectorValue() = 0;
 
        void restoreValueFromDefault();
 
        void setValueFromString(const std::string& str, bool poke=false);
 
        void setValueFromStringVector(const std::vector<std::string>& str, bool poke=false);
 
        void setItemValueFromString(const std::vector<uint32_t>& indices,
                                    const std::string& str);
 
        virtual bool equals(const ParameterBase &other) = 0;
 
        virtual void resizeVectorsFromString(const std::vector<uint32_t>& indices) = 0;
 
        virtual void clearVectorValue() = 0;
 
        virtual std::string stringize(bool pretty=false) const override {
            (void) pretty;
            std::stringstream ss;
            ss << "[" << TreeNode::stringize(pretty) << "]<param " << getTypeName() << " " << getName() << "="
               << getValueAsString() << ", def=" << getDefaultAsString() << ", write=" << getWriteCount()
               << " read: " << getReadCount() << " ignored: " << isIgnored();
            if(isVolatile()){
                ss << " VOLATILE";
            }
            ss << ">";
            return ss.str();
        }
 
        virtual bool validateIndependently(std::string& err_names) const = 0;
 
        virtual bool validateDependencies(const TreeNode* node,
                                          std::string& err_names) const = 0;
 
        void associateParametersForModification(std::vector<const ParameterBase *> params,
                                                const sparta::SpartaHandler& modifier_callback);
 
 
        uint32_t getWriteCount() const {
            return writes_;
        }
 
        uint32_t getReadCount() const {
            return reads_;
        }
 
        bool isReadOrIgnored() const {
            return ignored_ || reads_ > 0;
        }
 
        bool isIgnored() const {
            return ignored_;
        }
 
        virtual bool supportsCompression() const {
            return false;
        }
 
        virtual bool isVisibilityAllowed() const = 0;
 
        std::string setStringQuote(const std::string& s) {
            auto old = string_quote_;
            string_quote_ = s;
            return old;
        }
 
    protected:
 
        virtual void restoreValueFromDefaultImpl_() = 0;
 
        virtual void setValueFromStringImpl_(const std::string& s, bool poke=false) = 0;
 
        virtual void setValueFromStringVectorImpl_(const std::vector<std::string>& str, bool poke=false) = 0;
 
        virtual void setItemValueFromStringImpl_(const std::vector<uint32_t>& indices,
                                                 const std::string& str) = 0;
 
        void unread_() const {
            resetReadCount_();
            ignored_ = false;
        }
 
        void invokeModifierCB_();
 
        void incrementReadCount_() const {
            ++reads_;
        }
 
        friend class detail::ExtensionsBase;
 
        void resetReadCount_() const {
            reads_ = 0;
        }
 
        void resetWriteCount_() {
            writes_ = 0;
        }
 
        void ignore_() const {
            ignored_ = true;
        }
 
        bool usingFinalConfig_();
 
        void incrementWriteCount_() {
            // Writing is illegal if the owning node already has a resource.
            // This is not how this SHOULD work - all configuration should be
            // done during configuration. However, dynamically created nodes
            // need to be configured
            //TreeNode* pset = getParent();
            //sparta_assert(//                pset != nullptr, "Cannot write a parameter that does not belong to a ParameterSet");
            //TreeNode* owner = pset->getParent();
            //if(owner){
            //    if(owner->getPhase() > TREE_CONFIGURING
            //       && owner->hasResource()){
            //        throw SpartaException("Cannot write to Parameter ")
            //            << getLocation() << " because the associated TreeNode ("
            //            << owner->getLocation() << ") has already created a resource";
            //    }
            //}
 
            // Write-after read is prohibited
            if(isVolatile() == false && reads_ > 0){
                throw SpartaException("Cannot write parameter ") << getLocation()
                      << " after reading it unless it is a volatile parameter";
            }
 
            // Writing is illegal once tree is configured
            if(getPhase() > TREE_FINALIZED){
                throw SpartaException("Cannot write to Parameter ")
                    << getLocation() << " because it is already finalized";
            }
 
            resetReadCount_();
            ++writes_;
        }
 
        void logLoadedDefaultValue_() const;
 
        void logAssignedValue_() const;
 
        static void logCurrentBackTrace_();
 
        void addToSet_(ParameterSet* ps);
 
        friend class ParameterSet;
 
        sparta::SpartaHandler modifier_callback_;
 
        mutable bool ignored_;
 
        std::string string_quote_;
 
    private:
 
        std::string name_;
 
        std::string desc_;
 
        uint32_t writes_;
 
        mutable uint32_t reads_;
 
        std::vector<const ParameterBase *> associated_params_;
 
        bool is_volatile_;
 
 
    }; // class ParameterBase
 
    template<class ValueType>
    class ValidationCheckCallback
    {
        std::function<bool(ValueType&, const sparta::TreeNode*)> callback_;
 
        std::string name_;
 
    public:
 
        template<class T, bool (T::*TMethod)(ValueType&, const sparta::TreeNode*)>
        static ValidationCheckCallback<ValueType> from_method(T* obj,
                                                              const std::string& name)
        {
            (void) obj;
            ValidationCheckCallback<ValueType> vcc(name);
            vcc.callback_ = std::bind(TMethod, obj, std::placeholders::_1, std::placeholders::_2);
            return vcc;
 
            // This is not valid because the template parameter TMethod cannot be deduced
            //return ValidationCheckCallback<ValueType>(obj, name);
        }
 
        /*
        template<class T, bool (T::*TMethod)(ValueType)>
        ValidationCheckCallback(T* obj, const std::string& name) :
            callback_(std::bind(TMethod, obj, std::placeholders::_1)),
            name_(name)
        {
            validateName(name_);
        }*/
 
        ValidationCheckCallback(bool (*method)(ValueType&, const sparta::TreeNode*),
                                const std::string& name) :
            callback_(std::bind(method, std::placeholders::_1, std::placeholders::_2)),
            name_(name)
        {
            validateName(name_);
        }
 
        ValidationCheckCallback() :
            callback_(std::bind(&ValidationCheckCallback<ValueType>::doNothing_, std::placeholders::_1, std::placeholders::_2)),
            name_("<uninitialized>")
        {
            validateName(name_);
        }
 
        ValidationCheckCallback(const std::string& name) :
            callback_(std::bind(&ValidationCheckCallback<ValueType>::doNothing_, std::placeholders::_1, std::placeholders::_2)),
            name_(name)
        {
            validateName(name_);
        }
 
        ValidationCheckCallback(const ValidationCheckCallback<ValueType>& rhp) :
            callback_(rhp.callback_),
            name_(rhp.name_)
        {
            validateName(name_);
        }
 
        void operator=(const ValidationCheckCallback<ValueType>& rhp)
        {
            callback_ = rhp.callback_;
            name_ = rhp.name_;
        }
 
        std::string getName() const
        {
            return name_;
        }
 
        bool operator()(ValueType& val, const TreeNode* node) const
        {
            return callback_(val, node);
        }
 
        static void validateName(const std::string& nm)
        {
            if(nm.find(',') != std::string::npos){
                ParameterException ex("ValidationCheckCallback name \"");
                ex << nm << "\" contains a comma, which is not permitted";
                throw ex;
            }
        }
 
    private:
 
        static bool doNothing_(ValueType& val, const TreeNode* node)
        {
            (void) val;
            (void) node;
            return true;
        }
    };
 
    template <typename ValueType>
    class Parameter : public ParameterBase
    {
    public:
 
        enum class ParameterAttribute : std::uint8_t {
            DEFAULT = 0,
            __FIRST = DEFAULT,
            LOCKED = 1,
            HIDDEN = 2,
            __LAST
        };
 
    private:
        OneWayBool<false> default_override_; 
        ParameterAttribute param_attr_ {ParameterAttribute::DEFAULT}; 
        ValueType def_val_; 
        ValueType val_; 
        sparta::utils::DisplayBase disp_base_; 
        std::vector<ValidationCheckCallback<ValueType> > bounds_; 
        std::vector<ValidationCheckCallback<ValueType> > dependencies_; 
 
    public:
        using type = ValueType;
        using value_type = ValueType; // only for passing regression
 
        Parameter(const std::string& name,
                  const ValueType& def,
                  const std::string& doc,
                  bool isvolatile = false) :
            ParameterBase(name, doc),
            def_val_(def),
            val_(def),
            disp_base_(sparta::utils::BASE_DEC)
        {
            //std::cout << name << " = " << typeid(ValueType).name() << std::endl;
 
            logLoadedDefaultValue_();
 
            if(isvolatile){
                setIsVolatile();
            }
        }
 
        Parameter(const std::string& name,
                  const ValueType& def,
                  const std::string& doc,
                  ParameterSet * ps,
                  bool isvolatile = false) :
            Parameter (name, def, doc, isvolatile)
        {
            sparta_assert(ps, "Must construct parameter " << name << " with valid ParameterSet");
            addToSet_(ps);
        }
 
        Parameter(const std::string& name,
                  const ValueType& def,
                  const std::string& doc,
                  const ParameterAttribute& attr,
                  ParameterSet* ps,
                  bool isvolatile = false) :
            Parameter(name, def, doc, isvolatile)
        {
            sparta_assert(ps, "Must construct parameter " << name << " with valid ParameterSet");
            param_attr_ = attr;
            if(param_attr_ == ParameterAttribute::HIDDEN) {
                markHidden(true);
            }
            addToSet_(ps);
        }
 
        virtual ~Parameter() = default;
 
        template<class T, bool (T::*TMethod)(ValueType&, const sparta::TreeNode*)>
        void addDependentValidationCallback(T* obj, const std::string& name)
        {
            dependencies_.push_back(ValidationCheckCallback<ValueType>::template from_method<T, TMethod>(obj, name));
 
            // Not allowed: Cannot resolve template arguments
            //dependencies_.push_back(ValidationCheckCallback<ValueType>(obj, name));
        }
 
        void addDependentValidationCallback(bool (*method)(ValueType&, const sparta::TreeNode*),
                                            const std::string& name)
        {
            dependencies_.push_back(ValidationCheckCallback<ValueType>(method, name));
        }
 
 
        virtual const std::string getTypeName() const override final{
            return Parameter::template getTypeName_<ValueType>();
        }
 
        ValueType getDefault() const {
            return def_val_;
        }
 
        virtual std::string getDefaultAsString() const override final {
            return sparta::utils::stringize_value(def_val_, disp_base_, string_quote_);
        }
 
        std::string getValueAsString() const override final {
            if(sparta::utils::is_vector<ValueType>{} && string_quote_.empty()){
                return sparta::utils::stringize_value(val_, disp_base_, "\"");
            }
            return sparta::utils::stringize_value(val_, disp_base_, string_quote_);
        }
 
        std::string getValueAsStringAt(size_t idx, bool peek=false) const override final {
            return Parameter::template getValueAsStringAt_<ValueType, ValueType>(idx, peek);
        }
 
        std::string getItemValueFromString(const std::vector<uint32_t>& indices,
                                           bool peek=false) const override final {
            if(indices.size() == 0){
                // No indices given. This must be a non-vector type
                return getFinalVectorItemValueFromString_(val_, indices, 0, peek);
            }
 
            // Handle if this is a vector
            return getVectorItemValueFromString_(val_, indices, 0, peek);
        }
 
        uint32_t getVectorSizeAt(const std::vector<uint32_t>& indices,
                                 bool peek=false) const override final {
            if(indices.size() == 0){
                // No indices given. This must be a non-vector type
                return getFinalVectorSize_(val_, indices, 0, peek);
            }
 
            // Handle if this is a vector
            return getVectorSize_(val_, indices, 0, peek);
        }
 
        operator const ValueType&() const {
            return getValue();
        }
 
        const ValueType& operator()() const {
            return getValue();
        }
 
        void ignore() const {
            ignore_();
        }
 
        void unread() const {
            unread_();
        }
 
        const ValueType& getValue() const {
            incrementReadCount_();
            return getValue_();
        }
 
        const ValueType& peekValue() const {
            return getValue_();
        }
 
        double getDoubleValue() const override final {
            return getDoubleValue_<ValueType>();
        }
 
        virtual size_t getNumValues(bool peek=false) const override final {
            return Parameter::template getNumValues_<ValueType, ValueType>(peek);
        }
 
        virtual bool isVector() const override final {
            return is_vector<ValueType>::value;
        }
 
        // Implements ParameterBase::getDimensionality
        virtual uint32_t getDimensionality() const override final {
            return Dimensionality<ValueType>::value;
        }
 
        virtual ParameterBase::const_iterator begin() const override final{
            return ParameterBase::const_iterator(this, 0);
        }
 
        virtual ParameterBase::const_iterator end() const override final{
            return ParameterBase::const_iterator(this, getNumValues());
        }
 
        template <class T>
        bool operator==(const Parameter<T>& rhp) const {
            return getValue() == rhp.getValue();
        }
 
        template <class T>
        bool operator!=(const Parameter<T>& rhp) const {
            return getValue() != rhp.getValue();
        }
 
        bool operator>(const Parameter<type>& rhp) const {
            return getValue() > rhp.getValue();
        }
 
        template <class T>
        bool operator>=(const Parameter<T>& rhp) const {
            return getValue() >= rhp.getValue();
        }
 
        bool operator<(const Parameter<type>& rhp) const {
            return getValue() < rhp.getValue();
        }
 
        bool operator<=(const Parameter<type>& rhp) const {
            return getValue() <= rhp.getValue();
        }
 
        template <class T>
        typename std::enable_if<!std::is_base_of<ParameterBase, T>::value, bool>::type
        operator==(const T rhp) const {
            return getValue() == (ValueType)rhp;
        }
 
        template <class T>
        typename std::enable_if<!std::is_base_of<ParameterBase, T>::value, bool>::type
        operator!=(const T rhp) const {
            return getValue() != (ValueType)rhp;
        }
 
        template <class T>
        typename std::enable_if<!std::is_base_of<ParameterBase, T>::value, bool>::type
        operator>(const T rhp) const {
            return getValue() > (ValueType)rhp;
        }
 
        template <class T>
        typename std::enable_if<!std::is_base_of<ParameterBase, T>::value, bool>::type
        operator>=(const T rhp) const {
            return getValue() >= (ValueType)rhp;
        }
 
        template <class T>
        typename std::enable_if<!std::is_base_of<ParameterBase, T>::value, bool>::type
        operator<(const T rhp) const {
            return getValue() < (ValueType)rhp;
        }
 
        template <class T>
        typename std::enable_if<!std::is_base_of<ParameterBase, T>::value, bool>::type
        operator<=(const T rhp) const {
            return getValue() <= (ValueType)rhp;
        }
 
        void operator=(const Parameter& p) = delete;
 
        void operator=(const ValueType& v) {
            checkModificationPermission_();
            // if the simulator was setup using --read-final-config
            // we do not allow the simulator to override values
            // so just return out and warn that we are skipping this.
            if (usingFinalConfig_() && (false == isHidden()))
            {
                static bool been_warned = false;
                if(!been_warned) {
                    std::cout << "WARNING: A simulator override for parameter " << getLocation()
                              << " (using operator=) was performed and ignored. This is because"
                              << " the simulator is using --read-final-config.  This is your"
                              << " first and last warning." << std::endl;
                    been_warned = true;
                }
                return;
            }
 
            incrementWriteCount_();
            ValueType old_val = val_;
            val_ = v;
            logAssignedValue_();
            try {
                invokeModifierCB_();
            }
            catch(sparta::SpartaException & e) {
                val_ = old_val;
                throw;
            }
        }
 
        virtual bool isDefaultOverridden() const override final {
            return default_override_;
        }
 
        virtual void overrideDefaultFromString(const std::string& str) override final {
            Parameter::template overrideDefaultFromString_<ValueType, ValueType>(str);
            sparta_assert(getReadCount() == 0,
                        "Cannot override default on parameter if read count is > 0. "
                        "Problem on parameter " << getLocation());
            default_override_ = true;
        }
 
        virtual void overrideDefaultFromStringVector(const std::vector<std::string>& vec) override final {
            Parameter::template overrideDefaultFromStringVector_<ValueType, ValueType>(vec);
            sparta_assert(getReadCount() == 0,
                        "Cannot override default on parameter if read count is > 0. "
                        "Problem on parameter " << getLocation());
            default_override_ = true;
        }
 
        virtual void overrideDefaultItemValueFromString(const std::vector<uint32_t>& indices,
                                                        const std::string& str) override final {
            if(indices.size() == 0){
                // No indices given. This must be a non-vector type
                Parameter::template overrideDefaultFromString_<ValueType, ValueType>(str);
            }else{
                // handle if this is a vector
                const bool incr_write_count = false;
                setVectorItemValueFromString_(def_val_, indices, 0, str, incr_write_count);
            }
            default_override_ = true;
        }
 
        virtual void overrideDefaultResizeVectorsFromString(const std::vector<uint32_t>& indices) override final {
            if(indices.size() == 0){
                return; // No effect
            }
 
            resizeVectorsFromString_(def_val_, indices, 0);
        }
 
        virtual void overrideDefaultClearVectorValue() override final {
            clearVectorValue_(def_val_);
        }
 
 
        virtual void restoreValueFromDefaultImpl_() override final {
            checkModificationPermission_();
            sparta_assert(getReadCount() == 0,
                        "Parameter " << getLocation() << " must not have been read when restoring "
                        "a value from the default. This is a write");
 
            incrementWriteCount_();
 
            val_ = def_val_;
        }
 
        virtual bool equals(const ParameterBase &other) override final {
            return *this == dynamic_cast<const Parameter<ValueType> &>(other);
        }
 
        virtual void resizeVectorsFromString(const std::vector<uint32_t>& indices) override final {
            if(indices.size() == 0){
                return; // No effect
            }
 
            resizeVectorsFromString_(val_, indices, 0);
        }
 
        virtual void clearVectorValue() override final {
            clearVectorValue_(val_);
        }
 
        sparta::utils::DisplayBase setNumericDisplayBase(sparta::utils::DisplayBase base) {
            checkModificationPermission_();
            sparta::utils::DisplayBase old = disp_base_;
            disp_base_ = base;
            return old;
        }
 
        sparta::utils::DisplayBase getNumericDisplayBase() const {
            return disp_base_;
        }
 
        bool validateIndependently(std::string& err_names) const override
        {
            (void) err_names;
 
            // \todo Implement independent validation
            //sparta_assert(0, "sparta::Parameter::validateIndependently is unimplemented");
 
            return true;
        }
 
        bool validateDependencies(const TreeNode* node, std::string& err_names) const override
        {
            bool success = true;
            ValueType val = getValue_(); // Does not count as a read
            for(const ValidationCheckCallback<ValueType>& vcb : dependencies_){
                if(!vcb(val, node)){
                    err_names += vcb.getName() + ",";
                    success = false;
                }
            }
            return success;
        }
 
        template <class U>
        Parameter<ValueType>& operator<< (U e) {
            return Parameter::template operator_insert_<U, ValueType>(e);
        }
 
        virtual bool isVisibilityAllowed() const override{
            return ((param_attr_ == ParameterAttribute::HIDDEN) and
                    (this->areParametersLocked_())) ? false : true;
        }
 
    protected:
 
        template <class U, class C1>
        typename std::enable_if<is_vector<C1>::value, Parameter<ValueType>&>::type
        operator_insert_(U e) {
            checkModificationPermission_();
            incrementWriteCount_();
            val_.push_back((typename ValueType::value_type) e);
            return *this;
        }
 
        virtual void setValueFromStringImpl_(const std::string& str, bool poke=false) override final {
            Parameter::template setValueFromString_<ValueType, ValueType>(str, poke);
        }
 
        virtual void setValueFromStringVectorImpl_(const std::vector<std::string>& vec, bool poke=false) override final {
            Parameter::template setValueFromStringVector_<ValueType, ValueType>(vec, poke);
        }
 
        virtual void setItemValueFromStringImpl_(const std::vector<uint32_t>& indices,
                                                 const std::string& str) override final {
            if(indices.size() == 0){
                // No indices given. This must be a non-vector type
                Parameter::template setValueFromString_<ValueType, ValueType>(str);
            }else{
                // handle if this is a vector
                const bool incr_write_count = true;
                setVectorItemValueFromString_(val_, indices, 0, str, incr_write_count);
            }
        }
 
        const ValueType& getValue_() const {
            return val_;
        }
 
        template <typename T>
        typename std::enable_if<std::is_arithmetic<T>::value, double>::type
        getDoubleValue_() const {
            return val_;
        }
 
        template <typename T>
        typename std::enable_if<!std::is_arithmetic<T>::value, double>::type
        getDoubleValue_() const {
            throw SpartaException("Cannot get 'double' type value from parameter ")
                  << getLocation() << " which is of type " << getTypeName();
        }
 
    private:
        void checkModificationPermission_() const{
            if(this->areParametersLocked_() and
                param_attr_ != ParameterAttribute::DEFAULT){
                throw ParameterException("Modifying special parameters after Lockdown phase is disallowed.");
            }
        }
 
        // Multi-dimensional parameter indexed writes
 
        template <typename T>
        typename std::enable_if<is_vector<typename std::remove_reference<T>::type>::value>::type
        setVectorItemValueFromString_(T& vec,
                                      const std::vector<uint32_t>& indices,
                                      uint32_t index_level,
                                      const std::string& str,
                                      bool increment_write_count) {
            checkModificationPermission_();
            assert(indices.size() > 0);
 
            uint32_t idx = indices.at(index_level);
            if(idx >= vec.size()){
                vec.resize(idx+1);
            }
 
            if(indices.size() - 1 == index_level){
                // Final index should place a value in a vector
                // Note that vec is a vector
                typename T::reference to_set = vec.at(idx);
                setFinalVectorItemValueFromString_(to_set, indices, index_level, str);
                if(increment_write_count){
                    incrementWriteCount_();
                }
            }else{
                // Non-final index should select a vector and recurse until the
                // last level of nested vectors is reached
                typename T::reference next_vec = vec.at(idx);
                setVectorItemValueFromString_(next_vec, indices, index_level+1, str, increment_write_count);
            }
        }
 
        template <typename T>
        typename std::enable_if<!is_vector<typename std::remove_reference<T>::type>::value>::type
        setVectorItemValueFromString_(T& vec,
                                      const std::vector<uint32_t>& indices,
                                      uint32_t index_level,
                                      const std::string& str,
                                      bool increment_write_count) {
            checkModificationPermission_();
            (void) vec;
            (void) index_level;
            (void) str;
            (void) increment_write_count;
 
            throw ParameterException("Cannot set value from string on parameter \"")
                << getName() << "\" which is of type \""
                << getTypeName() << "\" with indices: " << indices << " (" << indices.size()
                << " levels)" << " because this type only has " << index_level << " dimensions";
        }
 
        template <typename T>
        typename std::enable_if<is_vector<typename std::remove_reference<T>::type>::value>::type
        setFinalVectorItemValueFromString_(T& to_set,
                                           const std::vector<uint32_t>& indices,
                                           uint32_t index_level,
                                           const std::string& str) {
            checkModificationPermission_();
            (void) to_set;
            (void) str;
 
            throw ParameterException("Cannot set value from string on parameter \"")
                << getName() << "\" which is of type \""
                << getTypeName() << "\" with indices: " << indices << " (" << indices.size()
                << " levels)" << " because this type has more than " << index_level << " dimensions";
        }
 
        template <typename T>
        typename std::enable_if<!is_vector<typename std::remove_reference<T>::type>::value>::type
        setFinalVectorItemValueFromString_(T& to_set,
                                           const std::vector<uint32_t>& indices,
                                           uint32_t index_level,
                                           const std::string& str) {
            checkModificationPermission_();
            sparta_assert(indices.size() == 0 || indices.size() - 1 == index_level);
 
            size_t end_pos;
            to_set = smartLexicalCast<typename bit_reference_to_bool<T>::type>(this, str, end_pos);
        }
 
 
        // Multi-dimensional parameter indexed enlargement
 
        template <typename T>
        typename std::enable_if<is_vector<typename std::remove_reference<T>::type>::value>::type
        resizeVectorsFromString_(T& vec,
                                 const std::vector<uint32_t>& indices,
                                 uint32_t index_level) {
            checkModificationPermission_();
            if(index_level == indices.size()){
                return; // Done. No further effect
            }
 
            uint32_t idx = indices.at(index_level);
            if(idx >= vec.size()){
                vec.resize(idx+1);
            }
 
            if(index_level < indices.size()){
                // Recurs to next index_level
                typename T::reference next_vec = vec.at(idx);
                resizeVectorsFromString_(next_vec, indices, index_level+1);
            }
        }
 
        template <typename T>
        typename std::enable_if<!is_vector<typename std::remove_reference<T>::type>::value>::type
        resizeVectorsFromString_(T& vec,
                                  const std::vector<uint32_t>& indices,
                                  uint32_t index_level) {
            checkModificationPermission_();
            (void) vec;
            (void) index_level;
 
            throw ParameterException("Cannot resize a vector in parameter \"")
                << getName() << "\" which is of type \""
                << getTypeName() << "\" to contain indices: " << indices << " (" << indices.size()
                << " levels)" << " because this type only has " << getDimensionality()
                << " dimensions. Therefore this index "
                   "would be within a vector of scalars and this method has no idea with what "
                   "value to initialize the new elements of said vector. Ues an indices vector "
                   "with less than " << getDimensionality() << " elements";
        }
 
        // Vector Clearing
 
        template <typename T>
        static
        typename std::enable_if<is_vector<typename std::remove_reference<T>::type>::value>::type
        clearVectorValue_(T& vec) {
            vec.clear();
        }
 
        template <typename T>
        static
        typename std::enable_if<!is_vector<typename std::remove_reference<T>::type>::value>::type
        clearVectorValue_(T& vec) {
            (void) vec;
 
            // No effect
        }
 
 
        // Multi-dimensional parameter indexed reads
 
        template <typename T>
        typename std::enable_if<is_vector<typename std::remove_reference<T>::type>::value, std::string>::type
        getVectorItemValueFromString_(const T& vec,
                                      const std::vector<uint32_t>& indices,
                                      uint32_t index_level,
                                      bool peek) const {
            assert(indices.size() > 0);
 
            uint32_t idx = indices.at(index_level);
            if(idx >= vec.size()){
                throw ParameterException("Cannot get item from parameter \"")
                    << getName() << "\" as a vector which is of type \""
                    << getTypeName() << "\" with indices: " << indices << " (" << indices.size()
                    << " levels)" << " because this type has only " <<  vec.size()
                    << " elements at the vector located by indices[" << index_level << "]";
            }
 
            if(indices.size() - 1 == index_level){
                // Final index should place a value in a vector
                // Note that vec is a vector
                typename T::const_reference to_get = vec.at(idx);
                return getFinalVectorItemValueFromString_(to_get, indices, index_level, peek);
            }else{
                // Non-final index should select a vector and recurse
                typename T::const_reference next_vec = vec.at(idx);
                return getVectorItemValueFromString_(next_vec, indices, index_level+1, peek);
            }
        }
 
        template <typename T>
        typename std::enable_if<!is_vector<typename std::remove_reference<T>::type>::value, std::string>::type
        getVectorItemValueFromString_(const T& vec,
                                      const std::vector<uint32_t>& indices,
                                      uint32_t index_level,
                                      bool peek) const {
            (void) vec;
            (void) index_level;
            (void) peek;
 
            throw ParameterException("Cannot get item from parameter \"")
                << getName() << "\" which is of type \""
                << getTypeName() << "\" with indices: " << indices << " (" << indices.size()
                << " levels)" << " because this type only has " << index_level << " dimensions";
        }
 
        template <typename T>
        typename std::enable_if<is_vector<typename std::remove_reference<T>::type>::value, std::string>::type
        getFinalVectorItemValueFromString_(const T& to_get,
                                           const std::vector<uint32_t>& indices,
                                           uint32_t index_level,
                                           bool peek) const {
            (void) to_get;
            (void) peek;
 
            throw ParameterException("Cannot get value from string on parameter \"")
                << getName() << "\" which is of type \""
                << getTypeName() << "\" with indices: " << indices << " (" << indices.size()
                << " levels)" << " because this type has more than " << index_level << " dimensions";
        }
 
        template <typename T>
        typename std::enable_if<!is_vector<typename std::remove_reference<T>::type>::value, std::string>::type
        getFinalVectorItemValueFromString_(const T& to_get,
                                           const std::vector<uint32_t>& indices,
                                           uint32_t index_level,
                                           bool peek) const {
            sparta_assert(indices.size() == 0 || indices.size() - 1 == index_level);
 
            if(!peek){
                incrementReadCount_();
            }
 
            return sparta::utils::stringize_value(to_get, disp_base_, string_quote_);
        }
 
 
        // Nested Vector size queries
 
        template <typename T>
        typename std::enable_if<is_vector<typename std::remove_reference<T>::type>::value, uint32_t>::type
        getVectorSize_(const T& vec,
                       const std::vector<uint32_t>& indices,
                       uint32_t index_level,
                       bool peek) const
        {
            sparta_assert(indices.size() > 0);
 
            uint32_t idx = indices.at(index_level);
            if(idx >= vec.size()){
                throw ParameterException("Cannot get size of vector from parameter \"")
                    << getName() << "\" as a vector which is of type \""
                    << getTypeName() << "\" with indices: " << indices << " (" << indices.size()
                    << " levels)" << " because this type has only " <<  vec.size()
                    << " elements at the vector located by indices[" << index_level << "]";
            }
 
            if(indices.size() - 1 == index_level){
                // Final index should place a value in a vector
                // Note that vec is a vector
                typename T::const_reference to_get = vec.at(idx);
                return getFinalVectorSize_(to_get, indices, index_level, peek);
            }else{
                // Non-final index should select a vector and recurse
                typename T::const_reference next_vec = vec.at(idx);
                return getVectorSize_(next_vec, indices, index_level+1, peek);
            }
        }
 
        template <typename T>
        typename std::enable_if<!is_vector<typename std::remove_reference<T>::type>::value, uint32_t>::type
        getVectorSize_(const T& vec,
                       const std::vector<uint32_t>& indices,
                       uint32_t index_level,
                       bool peek) const {
            (void) vec;
            (void) index_level;
            (void) peek;
 
            throw ParameterException("Cannot get size of vector from parameter \"")
                << getName() << "\" which is of type \""
                << getTypeName() << "\" with indices: " << indices << " (" << indices.size()
                << " levels)" << " because this type only has " << index_level << " dimensions";
        }
 
        template <typename T>
        typename std::enable_if<!is_vector<typename std::remove_reference<T>::type>::value, uint32_t>::type
        getFinalVectorSize_(const T& to_get,
                            const std::vector<uint32_t>& indices,
                            uint32_t index_level,
                            bool peek) const {
            (void) to_get;
            (void) peek;
 
            throw ParameterException("Cannot get size of vector from parameter \"")
                << getName() << "\" which is of type \""
                << getTypeName() << "\" with indices: " << indices << " (" << indices.size()
                << " levels)" << " because the in dimension " << index_level
                << " is a a scalar (not a vector)";
        }
 
        template <typename T>
        typename std::enable_if<is_vector<typename std::remove_reference<T>::type>::value, uint32_t>::type
        getFinalVectorSize_(const T& to_get,
                            const std::vector<uint32_t>& indices,
                            uint32_t index_level,
                            bool peek) const
        {
            sparta_assert(indices.size() == 0 || indices.size() - 1 == index_level);
 
            if(!peek){
                incrementReadCount_(); // This is considered a read because this information can be useful
            }
 
            return to_get.size();
        }
 
 
        // Type string computation
 
        template <class T>
        typename std::enable_if<is_vector<T>::value, std::string>::type
        getTypeName_() const {
            std::stringstream ss;
            ss << "std::vector<";
            ss << getTypeName_<typename T::value_type>();
            ss << ">";
            return ss.str();
        }
 
        template <class T>
        typename std::enable_if<!is_vector<T>::value, std::string>::type
        getTypeName_() const {
            if(KeyValue::hasTypeNameFor<T>()){
                return KeyValue::lookupTypeName<T>();
            }else{
                return demangle(typeid(T).name());
            }
        }
 
 
        // Vector value writes
        template <class T, class C1>
        typename std::enable_if<is_vector<C1>::value >::type
        setValueFromString_(const std::string& str, bool poke=false) {
            checkModificationPermission_();
            (void) str;
            (void) poke;
            throw ParameterException("Cannot set value from string on parameter \"")
                << getName() << "\" which is a vector type \""
                << getTypeName() << "\"";
        }
 
        // Scalar value writes
        template <class T, class C1>
        typename std::enable_if<!is_vector<C1>::value >::type
        setValueFromString_(const std::string& str, bool poke=false) {
            checkModificationPermission_();
            ValueType tmp;
 
            size_t end_pos;
            tmp = smartLexicalCast<ValueType>(this, str, end_pos);
 
            if (!poke) {
                incrementWriteCount_();
            }
 
            ValueType old_val = val_;
            val_ = tmp;
            try {
                invokeModifierCB_();
            }
            catch(sparta::SpartaException & e) {
                val_ = old_val;
                throw;
            }
        }
 
 
        // Vector value writes for DEFAULT value
        template <class T, class C1>
        typename std::enable_if<is_vector<C1>::value >::type
        overrideDefaultFromString_(const std::string& str) {
            checkModificationPermission_();
            (void) str;
            throw ParameterException("Cannot set default from string on parameter \"")
                << getName() << "\" which is a vector type \""
                << getTypeName() << "\"";
        }
 
        // Scalar value writes for DEFAULT value
        template <class T, class C1>
        typename std::enable_if<!is_vector<C1>::value >::type
        overrideDefaultFromString_(const std::string& str) {
            checkModificationPermission_();
            ValueType tmp;
 
            size_t end_pos;
            tmp = smartLexicalCast<ValueType>(this, str, end_pos);
            def_val_ = tmp;
        }
 
 
        // 1-d vector writes
 
        template <class T, class C1> // C1=ValueType
        typename std::enable_if<!is_vector<C1>::value >::type
        setValueFromStringVector_(const std::vector<std::string>& vec, bool poke=false) {
            checkModificationPermission_();
            (void) vec;
            (void) poke;
            throw ParameterException("Cannot directly set value from string vector on parameter \"")
                << getName() << "\" which is a scalar (or string) type \""
                << getTypeName() << "\"";
        }
 
        template <class T, class C1> // C1=ValueType
        typename std::enable_if<is_vector<C1>::value && !is_vector<typename C1::value_type>::value>::type
        setValueFromStringVector_(const std::vector<std::string>& vec, bool poke=false) {
            checkModificationPermission_();
            ValueType tmpvec;
            for(const std::string& s : vec){
                size_t end_pos;
                tmpvec.push_back(smartLexicalCast<typename ValueType::value_type>(this, s, end_pos));
            }
            if (!poke) {
                incrementWriteCount_();
            }
            ValueType old_val = val_;
            val_ = tmpvec;
            try {
                invokeModifierCB_();
            }
            catch(sparta::SpartaException & e) {
                val_ = old_val;
                throw;
            }
        }
 
        template <class T, class C1> // C1=ValueType
        typename std::enable_if<is_vector<C1>::value && is_vector<typename C1::value_type>::value>::type
        setValueFromStringVector_(const std::vector<std::string>& vec, bool poke=false) {
            checkModificationPermission_();
            (void) vec;
            (void) poke;
            throw ParameterException("Cannot directly set value from string vector on parameter \"")
                << getName() << "\" which has " << getDimensionality() << " dimensions. Type is \""
                << getTypeName() << "\". Only 1-dimensional parameters can be set using this method";
        }
 
 
        // 1-d vector writes for DEFAULT value
 
        template <class T, class C1> // C1=ValueType
        typename std::enable_if<!is_vector<C1>::value >::type
        overrideDefaultFromStringVector_(const std::vector<std::string>& vec) {
            checkModificationPermission_();
            (void) vec;
 
            throw ParameterException("Cannot directly override default value from string vector on parameter \"")
                << getName() << "\" which is a scalar (or string) type \""
                << getTypeName() << "\"";
        }
 
        template <class T, class C1> // C1=ValueType
        typename std::enable_if<is_vector<C1>::value && !is_vector<typename C1::value_type>::value>::type
        overrideDefaultFromStringVector_(const std::vector<std::string>& vec) {
            checkModificationPermission_();
            ValueType tmpvec;
            for(const std::string& s : vec){
                size_t end_pos;
                tmpvec.push_back(smartLexicalCast<typename ValueType::value_type>(this, s, end_pos));
            }
            def_val_ = tmpvec;
        }
 
        template <class T, class C1> // C1=ValueType
        typename std::enable_if<is_vector<C1>::value && is_vector<typename C1::value_type>::value>::type
        overrideDefaultFromStringVector_(const std::vector<std::string>& vec) {
            checkModificationPermission_();
            (void) vec;
 
            throw ParameterException("Cannot directly set value from string vector on parameter \"")
                << getName() << "\" which has " << getDimensionality() << " dimensions. Type is \""
                << getTypeName() << "\". Only 1-dimensional parameters can be set using this method";
        }
 
 
        // 1-d vector reads
 
        template <class T, class C1> // C1=ValueType
        typename std::enable_if<!is_vector<C1>::value, std::string>::type
        getValueAsStringAt_(size_t idx, bool peek) const {
            if(idx != 0){
                ParameterException ex("Cannot get value as string at index other than 0 on parameter \"");
                ex << getName() << "\" which is a scalar (or string) type \""
                   << getTypeName() << "\"";
                throw ex;
            }
            if(!peek){
                incrementReadCount_();
            }
            return getValueAsString();
        }
 
        template <class T, class C1> // C1=ValueType
        typename std::enable_if<is_vector<C1>::value, std::string>::type
        getValueAsStringAt_(size_t idx, bool peek) const {
            if(!peek){
                incrementReadCount_();
            }
            return sparta::utils::stringize_value(val_.at(idx), disp_base_, string_quote_);
        }
 
 
        // 1-d vector inspection
 
        template <class T, class C1> // C1=ValueType
        typename std::enable_if<!is_vector<C1>::value, size_t>::type
        getNumValues_(bool peek) const {
            (void) peek;
            // DO NOT count this as a read access. Nothing can be deduced about
            // the parameter from this information since this is a scalar
            return 1;
        }
 
        template <class T, class C1> // C1=ValueType
        typename std::enable_if<is_vector<C1>::value, size_t>::type
        getNumValues_(bool peek) const {
            // Getting number of values counts as reading since it *might* be
            // informative
            if(!peek){
                incrementReadCount_();
            }
            return val_.size();
        }
 
        // Parameter Dimensionality
 
        template<typename T, typename Enable = void>
        struct Dimensionality {
        };
 
        template<typename T>
        struct Dimensionality<T, typename std::enable_if<is_vector<T>::value>::type> {
            enum { value = Dimensionality<typename T::value_type>::value + 1};
        };
 
        template<typename T>
        struct Dimensionality<T, typename std::enable_if<!is_vector<T>::value>::type> {
            enum { value = 0 }; // T is a scalar type, with 0 dimensions
        };
 
    }; // class Parameter
 
 
    // Implementation
 
    template <class T>
    inline const T ParameterBase::getValueAs() const {
        const Parameter<T>* p = dynamic_cast<const Parameter<T>*>(this);
        if(nullptr == p){
            throw ParameterException("Cannot get value from Parameter \"")
                << getName() << "\" as a " << demangle(typeid(T).name())
                << " because it is internally a " << getTypeName()
                << ". getValueAs must be exact";
        }
        return *p;
    }
 
    template <typename T>
    inline T smartLexicalCast(const ParameterBase* p,
                              const std::string& s,
                              size_t& end_pos,
                              bool allow_recursion,
                              bool allow_prefix)
    {
        try{
            return utils::smartLexicalCast<T>(s, end_pos, allow_recursion, allow_prefix);
        }catch(SpartaException& ex){
            ex << " in parameter " << p->getLocation();
            throw;
        }
    }
 
} // namespace sparta