ReadOnlyCounter.hpp

// <Counter> -*- C++ -*-
 
 
#pragma once
 
#include "sparta/utils/ByteOrder.hpp"
#include "sparta/statistics/CounterBase.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
 
 
namespace sparta
{
    class ReadOnlyCounter : public CounterBase
    {
    public:
 
 
        ReadOnlyCounter(TreeNode* parent,
                        const std::string& name,
                        const std::string& group,
                        TreeNode::group_idx_type group_idx,
                        const std::string& desc,
                        CounterBehavior behave,
                        const counter_type* ref,
                        visibility_t visibility) :
            CounterBase(parent,
                        name,
                        group,
                        group_idx,
                        desc,
                        behave,
                        visibility),
            ref_(ref)
        { }
 
        ReadOnlyCounter(TreeNode* parent,
                        const std::string& name,
                        const std::string& group,
                        TreeNode::group_idx_type group_idx,
                        const std::string& desc,
                        CounterBehavior behave,
                        visibility_t visibility) :
            ReadOnlyCounter(parent,
                            name,
                            group,
                            group_idx,
                            desc,
                            behave,
                            nullptr,
                            visibility)
        {
            // Initialization handled in delegated constructor
        }
 
        // Alternate constructor
        ReadOnlyCounter(TreeNode* parent,
                        const std::string& name,
                        const std::string& desc,
                        CounterBehavior behave,
                        const counter_type* ref,
                        visibility_t visibility) :
            ReadOnlyCounter(parent,
                            name,
                            TreeNode::GROUP_NAME_NONE,
                            TreeNode::GROUP_IDX_NONE,
                            desc,
                            behave,
                            ref,
                            visibility)
        {
            // Initialization handled in delegated constructor
        }
 
        // Alternate constructor
        ReadOnlyCounter(TreeNode* parent,
                        const std::string& name,
                        const std::string& desc,
                        CounterBehavior behave,
                        visibility_t visibility) :
            ReadOnlyCounter(parent,
                            name,
                            TreeNode::GROUP_NAME_NONE,
                            TreeNode::GROUP_IDX_NONE,
                            desc,
                            behave,
                            nullptr,
                            visibility)
        {
            // Initialization handled in delegated constructor
        }
 
        // Alternate Constructor
        ReadOnlyCounter(TreeNode* parent,
                        const std::string& name,
                        const std::string& group,
                        TreeNode::group_idx_type group_idx,
                        const std::string& desc,
                        CounterBehavior behave,
                        const counter_type* ref) :
            ReadOnlyCounter(parent,
                            name,
                            group,
                            group_idx,
                            desc,
                            behave,
                            ref,
                            DEFAULT_VISIBILITY)
        { }
 
        ReadOnlyCounter(TreeNode* parent,
                        const std::string& name,
                        const std::string& group,
                        TreeNode::group_idx_type group_idx,
                        const std::string& desc,
                        CounterBehavior behave) :
            ReadOnlyCounter(parent,
                            name,
                            group,
                            group_idx,
                            desc,
                            behave,
                            nullptr,
                            DEFAULT_VISIBILITY)
        {
            // Initialization handled in delegated constructor
        }
 
        // Alternate constructor
        ReadOnlyCounter(TreeNode* parent,
                        const std::string& name,
                        const std::string& desc,
                        CounterBehavior behave,
                        const counter_type* ref) :
            ReadOnlyCounter(parent,
                            name,
                            TreeNode::GROUP_NAME_NONE,
                            TreeNode::GROUP_IDX_NONE,
                            desc,
                            behave,
                            ref,
                            DEFAULT_VISIBILITY)
        {
            // Initialization handled in delegated constructor
        }
 
        // Alternate constructor
        ReadOnlyCounter(TreeNode* parent,
                        const std::string& name,
                        const std::string& desc,
                        CounterBehavior behave) :
            ReadOnlyCounter(parent,
                            name,
                            TreeNode::GROUP_NAME_NONE,
                            TreeNode::GROUP_IDX_NONE,
                            desc,
                            behave,
                            nullptr,
                            DEFAULT_VISIBILITY)
        {
            // Initialization handled in delegated constructor
        }
 
        ReadOnlyCounter(ReadOnlyCounter&& rhp) :
            CounterBase(std::move(rhp)),
            ref_(rhp.ref_)
        {
            TreeNode* parent = rhp.getParent();
            if(parent != nullptr){
                parent->addChild(this);
            }
        }
 
        ~ReadOnlyCounter() {}
 
 
 
        virtual counter_type get() const override {
            sparta_assert(ref_ != nullptr,
                              "Canot 'get()' on ReadOnlyCounter "
                              << getLocation() << " because it has a null ref_ "
                              "pointer. If constructed without a variale "
                              "reference, the get() method must be overridden.");
            return *ref_;
        }
 
        operator counter_type() const {
            return get();
        }
 
        bool operator==(const CounterBase& rhp) const {
            return get() == rhp.get();
        }
 
 
        virtual bool supportsCompression() const override {
            return true;
        }
 
 
        // Override from TreeNode
        virtual std::string stringize(bool pretty=false) const override {
            (void) pretty;
            std::stringstream ss;
            ss << '<' << getLocation() << " val:" << std::dec;
            ss << get() << ' ';
            ss << getBehaviorName(getBehavior());
            ss << " vis:" << getVisibility() << '>';
            return ss.str();
        }
 
    protected:
 
        virtual void onAddingChild_(TreeNode* child) override {
            (void) child;
            throw SpartaException("Cannot add children to a ReadOnlyCounter");
        }
 
    private:
 
        const counter_type* const ref_;
 
    }; // class ReadOnlyCounter
 
} // namespace sparta