GPM_GraphElement.h

Go to the documentation of this file.

#ifndef GPM_GraphElement_H
#define GPM_GraphElement_H

#include "GPM_Object.h"

#include "GPM_Variable.h"

DEFINE_SPTR(GPM_Graph);

DEFINE_SPTR(GPM_GraphElement);
DEFINE_SVPTR(GPM_GraphElement)
class GPM_GraphElement : public virtual GPM_Object{
    SP_OBJECT(GPM_GraphElement);  
    // ATTRIBUTES

    // topological actions
    static const tFlag REMOVE;
    static const tFlag KEEP;
    
    //variables action
    static const tFlag UNSET;
    static const tFlag SET;
    static const tFlag ADD;
    static const tFlag VALID;
  

private:

    int mId;
    tString mGroupName;
    
   
    //variable Name -> list of variables
    map<tString,SV::GPM_Variable> mVariables;

    //variable name of trigger variable --> trigger value
    map<tString,SV::GPM_Variable> mActionVariables;
    //variable name of trigger variable -> trigger action 
    map<tString,tFlag> mVariableActions;

    // toppological action for graph
    tFlag mTopologicalAction;

    //group name action
    tFlag mGroupNameAction;
    tString mTriggerGroupName;

    WP::GPM_Graph mGraph;
    
protected:
    // METHODS
  
    // CONSTRUCTORS 
  
    GPM_GraphElement(void);
  
  
  
    // DESTRUCTORS 
  
  
    virtual ~GPM_GraphElement(void);   
  
  
protected:
    virtual void toDoAfterThisSetting() {
        GPM_Object::toDoAfterThisSetting();
        clearActions();
    }


public:
    
    
    virtual SP::GPM_GraphElement NewInstance() const=0;
    
  

    // SET & GET methods

    inline void setGraph(SP::GPM_Graph graph) {
        mGraph=graph;
    }
    void setGraph(GPM_Graph& graph);
    
    void setGraph(GPM_Graph* graph);
    
    GPM_Graph*  getGraph() const;

    
    virtual void copy(const GPM_GraphElement& node);

    // VARIABLES
    // =========

    void setEnvironment(const map<tString,SP::GPM_Variable>& env);

    virtual void updateEnvironment(const map<tString,SP::GPM_Variable>& env);
    
    SV::GPM_Variable addToVariables(const tString &variableName,SP::GPM_Variable var);
    
    GPM_Variable& initVariable(const tString &variableName);
  
 
    void setVariable(const tString &variableName,const GPM_Variable& var);
    
    void setVariable(const tString &variableName,SP::GPM_Variable var);
    
    void setVariableValue(const tString &variableName,const tString& value);
    void setVariableValue(const tString &variableName,const double& value);
    void setVariableValue(const tString &variableName,const int& n,const double* value);
    void setVariableValue(const tString &variableName,const tFlag& type,const int& n,const double* value);
    tBoolean setVariableValuesFromString(const tString& variableName,const tFlag& type,const tString& values);

    void removeVariable(const tString& varName) {
        mVariables.erase(varName);
    }
    inline void getVariableNames(vector<tString>& names) const {
        names.clear();
        map<tString,SV::GPM_Variable>::const_iterator iter=mVariables.begin();
        while (iter!=mVariables.end()) {
            names.push_back(iter->first);
            iter++;
        }
    }
 
    inline tBoolean getVariables(const tString& variableName,SV::GPM_Variable& variable)  const {
        
        map<tString,SV::GPM_Variable>::const_iterator iter=mVariables.find(variableName);
        if (iter!=mVariables.end()) {
            variable=iter->second;
            return true;
        }
        return false;
    }
    tString getVariableValuesToString(const tString& variableName)  const;
    
    SP::GPM_Variable getVariable(const tString& variableName) const;
    
    tBoolean getVariableValue(const tString &variableName,tString& value) const;
    tBoolean getVariableValue(const tString &variableName,double& value) const;
    tBoolean getVariableValue(const tString &variableName,int& n,double* value) const;
    
    tFlag getVariableType(const tString& variableName) const;
    
    virtual void clearVariables() {
        mVariables.clear();
    }

  
    
    // GROUP ID
    // ========
public:
    
    virtual tString getGroupTypeName() const=0;

   
    
    inline void setGroupName(const tString& v) {
        mGroupName=v;
      
    }
    inline  tString getGroupName() const {
        return mGroupName;
      
    }
   

   
   

  
    // ACTIONS
    // ========
  
    
    virtual tBoolean setTopologicalAction(const tFlag& action);
    inline tFlag getTopologicalAction() const {
        return mTopologicalAction;
    }
    inline tBoolean hasTriggerCutAction() const {
        return (mTopologicalAction==REMOVE);
    }
    virtual tBoolean setTriggerGroupNameAction(const tFlag& action,const tString& value);
    
    virtual tBoolean setTriggerAction(const tFlag& action,const tString& varName,SP::GPM_Variable var); 
    virtual tBoolean setTriggerAction(const tFlag& action,const tString& varName,const tString& value); 
    virtual tBoolean setTriggerAction(const tFlag& action,const tString& varName,const double&  value);
    virtual tBoolean setTriggerAction(const tFlag& action,const tString& varName,const int& n,const double*  value);
    virtual tBoolean setTriggerAction(const tFlag& action,const tString& varName,const tFlag& type,const int& n,const double*  value);
   
    inline tBoolean getTriggerActionValues(const tString& variableName,SV::GPM_Variable& variable)  const {
        
        map<tString,SV::GPM_Variable>::const_iterator iter=mActionVariables.find(variableName);
        if (iter!=mActionVariables.end()) {
            variable=iter->second;
            return true;
        }
        return false;
    }
    inline tFlag getTriggerAction(const tString & varName)  const {
        map<tString,tFlag>::const_iterator  iter=mVariableActions.find(varName);
        if (iter!=mVariableActions.end()) {
            return iter->second;
        }
        return UNSET;
    }
    virtual void clearActions();

    virtual void executeTriggerActions();


    
protected:
   
   
public:

    // GRAPH
    // =====
    
    // /*! \brief set graph
    //  */
    // void setGraph(SP::GPM_Graph g) {
    //     mGraph=graph;
    // }
    // /*! \brief get graph
    //  */
    // SP::GPM_Graph getGraph() const {
    //     SP::GPM_Graph gr=mGraph.lock();
    //     return gr;
    // }
    inline void setId(const int& id) {
        mId=id;
    }
    inline int getId() const {
        return mId;
    }
  


    // IO
    // ==

    tBoolean parseValues(tString& f,vector<tString>& values) const;
    
    virtual void saveToStream(ofstream& f) const;
    virtual tBoolean loadFromStream(tString& f);
    
    virtual tString toString() const;

   
};

#endif