GPM_Rule.h

Go to the documentation of this file.

#ifndef GPM_Rule_H
#define GPM_Rule_H


#include "GPM_Object.h"
#include "GPM_PortGraph.h"
#include "GPM_GraphElement.h"
#include "GPM_CompositorFunction.h"

#include "CORE_IO.h"


DEFINE_SPTR(GPM_Rule);
DEFINE_SVPTR(GPM_Rule);
class GPM_Rule : public GPM_Object {
    
    SP_OBJECT(GPM_Rule);
    // ATTRIBUTES
    
public:
    
    
    
private:


    //action
    tFlag mAction;
    tString mName;
    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    GPM_Rule(void);
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~GPM_Rule(void);
    

public:

    // NEW Method
    //===========

    virtual SP::GPM_Rule NewInstance() const =0;
    virtual SP::GPM_Rule NewInstance(const tFlag& action,const tString& expr) const {
        SP::GPM_Rule rule=NewInstance();
        rule->setAction(action);
        rule->setExpression(expr);
        return rule;
    }
    
 

   
    // SET Methods
    // ===========

    virtual void copy(const GPM_Rule& rule) {
        setAction(rule.getAction());
        setExpression(rule.getExpression());
        setName(rule.getName());
    }

    inline void setName(const tString& name) {
        mName=name;
    }
    inline tString getName() const {
        return mName;
    }
    inline void setAction(const tFlag& action) {
        mAction=action;
    }

    virtual void clearEnvironment()=0;

    virtual void setExpression(const tString& expr)=0;
    tBoolean isDependentOn(const tString& varName) const;
    
    
    // GET Methods
    // ===========

 
    inline tFlag getAction() const {
        return mAction;
        
    }

    virtual const double* getValue(int& n) const =0;
    virtual double* getValue(int& n)=0;
    
    virtual tString getExpression() const=0;

    // BUILDER method

    virtual void buildEnvironment(const GPM_Graph& largeGraph,
                                  const GPM_Graph& patternGraph,
                                  const vector<tVertexIID>& mappingP2L,
                                  CORE_Out& io);
    virtual void buildEnvironment(const GPM_Graph& largeGraph,
                                  const GPM_PortGraph& transformerGraph,
                                  const map<tVertexIID,tVertexIID>& mappingT2L,
                                  CORE_Out& io);

    virtual void buildEnvironment(const GPM_Graph& graph,
                                  const tString& graphLetter,
                                  CORE_Out& io);

    virtual void buildEnvironment(const GPM_GraphElement& element,
                                  const tString& elementLetter,
                                  CORE_Out& io);
 
    
    virtual void buildEnvironment(const map<tString,SP::GPM_Variable>& gVariables,
                                  CORE_Out& io);
    virtual void buildEnvironment(const SV::GPM_CompositorFunction& functions,
                                  CORE_Out& io);

    virtual void setVariable(const tString& name,const tFlag& type,
                             const double* values,const int& n,const tBoolean& isGlobal)=0;
    virtual void setVariable(const tString& name,const tFlag& type,
                             const double& values)=0;
    
    inline void setVariable(const tString& name,const double* values,const int& n) {
        setVariable(name,GPM_Variable::REAL,values,n,false);
    }
    inline void addVariable(const tString& name,const tFlag& type,
                            const double* values,const int& n,const tBoolean& isGlobal) {
        setVariable(name,type,values,n,isGlobal);
    }
    inline void addVariable(const tString& name,
                            const double* values,const int& n) {
        setVariable(name,GPM_Variable::REAL,values,n,false);
    }
    virtual void clearFunctions()=0;
    virtual void addFunction(SP::GPM_CompositorFunction f)=0;
    
       
    // compute the method
    virtual void compute(SP::GPM_Rule commonRuleEnv)=0;
    // compute the method
    inline void compute() {
        compute(getThis());
    }

   
    virtual tString toString() const=0;

 
    
};

#endif