GPM_ModelFunction.h

Go to the documentation of this file.

#ifndef GPM_ModelFunction_H
#define GPM_ModelFunction_H

#include "GPM_PatternFunction.h"

#include "GPM_ModelGraph.h"

#include "GPM_Variable.h"
#include "GPM_Rule.h"


DEFINE_SPTR(GPM_ModelClassFactory);
DEFINE_SPTR(GPM_Graph);

DEFINE_SPTR(GPM_ModelFunction);
DEFINE_SVPTR(GPM_ModelFunction);

class GPM_ModelFunction : public GPM_PatternFunction {
    SP_OBJECT(GPM_ModelFunction);  
   
    
private:

 
    
    // ASSOCIATIONS
    
    //condition on pattern attributes to match mapping
    SV::GPM_Rule mMappingRules;
    map<tString,SP::GPM_Variable> mGlobalVariables;
    SV::GPM_CompositorFunction mGlobalFunctions;
  
protected: 
    // METHODS
    
    // CONSTRUCTORS 
    
    GPM_ModelFunction(void);
    
    
    
    // DESTRUCTORS 
  
  
    virtual ~GPM_ModelFunction(void);   
    
    
public:
    
    // NEW methods

    static inline SP::GPM_ModelFunction New() {
        SP::GPM_ModelFunction p(new GPM_ModelFunction(),
                                  GPM_ModelFunction::Delete());
        p->setThis(p);
        return p;
    }
    
protected:
    virtual void toDoAfterThisSetting() {
        GPM_PatternFunction::toDoAfterThisSetting();
        setPatternGraph(GPM_ModelGraph::New());
        setTransformerGraph(GPM_ModelGraph::New());
        
    }
    // SET & GET methods
public:

    
    virtual void copy(const GPM_Function&  rule);

    // GLOBAL VARIABLE
    // ===============
    void setGlobalVariables(const map<tString,SP::GPM_Variable>& variables);
    
    inline void addGlobalVariables(const tString& variableName,const tFlag& type,const double& value) {
        GPM_Variable &var=initGlobalVariable(variableName);
        var.setValue(value);
        var.setType(type);
    }
    inline void addGlobalVariables(const tString& variableName,const tFlag& type,const double* values,const int& n) {
        GPM_Variable &var=initGlobalVariable(variableName);
        var.setValue(n,values);
        var.setType(type);
    }
    inline void addGlobalVariables(const tString& variableName,const tString &value) {
        GPM_Variable &var=initGlobalVariable(variableName);
        var.setValue(value);
        var.setType(GPM_Variable::STRING);
    }

    void removeGlobalVariable(const tString& name);
    inline void clearGlobalVariables() {
        mGlobalVariables.clear();
    }

    inline const map<tString,SP::GPM_Variable>& getGlobalVariables() const {
        return mGlobalVariables;
    }
private:
    GPM_Variable&  initGlobalVariable(const tString& varName);
    void setGlobalVariable(const tString& varName,SP::GPM_Variable var);
    
public:
     // GLOBAL Functions
    // ================
    void setGlobalFunctions(const SV::GPM_CompositorFunction& fcts) {
        int i,n=fcts.getSize();
        mGlobalFunctions.setSize(n);
        for (i=0;i<n;i++) mGlobalFunctions[i]=fcts[i];
    }
    
    void addGlobalFunction(const GPM_ModelClassFactory& cf,
                           const tString& name,const vector<tString>& realParameters,const tString& body);
    
    void addGlobalFunction(const GPM_ModelClassFactory& cf,
                           const tString& name,
                           const vector<tString>& nameParameters,
                           const vector<tFlag>& typeParameters,
                           const vector<tFlag>& cardParameters,
                           const vector<tFlag>& isConstParameters,
                           const tString& body,
                           const tFlag& returnType);
    
    void addGlobalFunction(const GPM_ModelClassFactory& cf,
                           const tString& strFunction);
    
    inline void clearGlobalFunctions() {
        mGlobalFunctions.clear();
    }

    inline const SV::GPM_CompositorFunction& getGlobalFunctions() const {
        return mGlobalFunctions;
    }

    
    // RULES
public:
    
    virtual void clear();

    
    void clearRules();
    
    inline void addMappingRule(SP::GPM_Rule rule) {
        mMappingRules.add(rule);
    }

    inline void removeMappingRule(const int& index) {
        if (index<mMappingRules.getSize())
            mMappingRules.removeAtIndex(index);
    }
    inline  const SV::GPM_Rule& getMappingRules() const {
        return mMappingRules;
    }
    inline  SV::GPM_Rule& getMappingRules()  {
        return mMappingRules;
    }
    tBoolean readRulesFromFile(const tString& fileName,
                               const GPM_ModelClassFactory& cf,
                               CORE_Out& io);
    tBoolean saveRulesToFile(const tString& fileName) const;


   
    virtual tBoolean isMappingValid(const GPM_PortGraph& largeGraph,
                                    const SV::GPM_Vertex& smallGraphVertices,
                                    const vector<tVertexIID>& mapping,
                                    CORE_Out& io) const;

    void updateRules(const GPM_ModelClassFactory& cf);
    
protected:
  
    virtual tBoolean updateTransformerGraphStates(GPM_Graph& largeGraph,
                                                  const vector<tVertexIID>& mappingP2L,
                                                  const map<tVertexIID,tVertexIID>& mappingT2L,CORE_Out& io);
    virtual tBoolean updatePatternGraphStates(GPM_Graph& largeGraph,
                                             const vector<tVertexIID>& mappingP2L,CORE_Out& io);
    virtual tBoolean updatePTEdgesStates(SP::GPM_Edge PTedge,SP::GPM_Edge ledge,
                                         GPM_Graph& largeGraph,
                                         const vector<tVertexIID>& mappingP2L,
                                         const map<tVertexIID,tVertexIID>& mappingT2L,
                                         CORE_Out& io);


public:
    /* \brief return the string represantation of the class
     */
    tString toString() const;

    static void expandVariableNames(const vector<tString>& vars,const int& id,
                                    tString& value,const tString& graphLetter,const tString& elementLetter);
    static tBoolean parseVarName(tString& varName,tString& graphLetter,tString& elementLetter,int& id);
    static tString varNameToString(const tString& varName,const tString& graphLetter,const tString& elementLetter,const int& id);
    

private:
    static size_t findVariableName(const tString& varName,const tString& value,const int& fromIndex) ;

   
    
};

#endif