ExpressionNode.hpp

// <ExpressionNode> -*- C++ -*-
 
#pragma once
 
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/SpartaException.hpp"
 
namespace sparta {
 
    class StatisticInstance;
 
    namespace statistics {
        namespace expression {
 
enum operation_t {
    OP_NULL     = 0,   
    OP_ADD      = '+', 
    OP_SUB      = '-', 
    OP_MUL      = '*', 
    OP_DIV      = '/', 
    OP_NEGATE   = 'n', 
    OP_PROMOTE  = 'p', 
    OP_FORWARD  = 'f'  
 
};
 
class ExpressionNode
{
public:
 
    ExpressionNode(const ExpressionNode&) = delete;
 
    ExpressionNode() {
        //std::cout << "EI Con  " << this << std::endl;
    }
 
    virtual ~ExpressionNode() {
        //std::cout << "EI Des ~" << this << std::endl;
    }
 
    ExpressionNode* clone() const {
        ExpressionNode* item = clone_();
        //std::cout << "cloned " << item << " <- " << this << std::endl;
        return item;
    }
 
    uint32_t getStats(std::vector<const StatisticInstance*>& results) const {
        return getStats_(results);
    }
 
    double evaluate(){
        double val = evaluate_();
 
        // trace
        //dump(std::cout);
        //std::cout << " => " << val << std::endl;
 
        return val;
    }
 
    virtual void start() = 0;
    virtual void end() = 0;
 
    virtual bool supportsCompression() const = 0;
 
    virtual void dump(std::ostream& o,
                      bool show_range=true,
                      bool resolve_subexprs=true) const = 0;
 
    virtual void getClocks(std::vector<const Clock*>& clocks) const = 0;
 
private:
 
    virtual double evaluate_() const = 0;
 
    virtual uint32_t getStats_(std::vector<const StatisticInstance*>& results) const = 0;
 
    virtual ExpressionNode* clone_() const = 0;
 
};
 
        } // namespace expression
    } // namespace statistics
} // namespace sparta