GPM_PatternFunction.h

Go to the documentation of this file.

#ifndef GPM_PatternFunction_H
#define GPM_PatternFunction_H

#include "GPM_Object.h"

#include "CORE_Out.h"

#include "GPM_Function.h"
#include "GPM_Node.h"
#include "GPM_PortGraph.h"

DEFINE_SPTR(GPM_PatternFunction);
DEFINE_SVPTR(GPM_PatternFunction);

class GPM_PatternFunction : public GPM_Function {
    SP_OBJECT(GPM_PatternFunction);  
    // ATTRIBUTES
    
private:

    // the list of vertices to remove from the pattern graph with
    // id of the pattern vertex -> true or false
    map<int ,tBoolean> mPVerticesToRemove;

    // id of pattern vertex to keep
    map<int ,tBoolean> mPVerticesToKeep;
    
    // the list of edge to remove from the pattern graph
    // id of the pattern edge -> true of false
    map<int,tBoolean> mPEdgesToRemove;

    // id of pattern edge to keep
    map<int ,tBoolean> mPEdgesToKeep;
    
    // the list of vertices pair to add between Pattern & Transformer graph
    // add an edge form Pattern vertex with id to transform index with id
    SV::GPM_Edge mPTEdgesToAdd;


    //variable name to build the group id
    vector<tString> mNodeGroupIds;
    vector<tString> mPortGroupIds;

    tBoolean mIsUpToAutomorphism;
    tFlag mUpToAutomorphismType;
   
    
    
    
protected: 
    // METHODS
    
    // CONSTRUCTORS 
    
    GPM_PatternFunction(void);
    
    
    
    // DESTRUCTORS 
  
  
    virtual ~GPM_PatternFunction(void);   
    
    
public:
    
    // NEW methods

  
    
    // SET & GET methods
  
    virtual void copy(const GPM_Function&  rule);
    
    virtual void clear() {
        GPM_Function::clear();
        mPVerticesToRemove.clear();
        mPVerticesToKeep.clear();
        mPEdgesToRemove.clear();
        mPEdgesToKeep.clear();
        mPTEdgesToAdd.clear();
        mNodeGroupIds.clear();
        mPortGroupIds.clear();
        mIsUpToAutomorphism=false;
        mUpToAutomorphismType=0;
    }
    inline void setIsUpToAutomorphism(const tBoolean& isUpToAutomorphism) {
        mIsUpToAutomorphism=isUpToAutomorphism;
    }
    inline void setUpToAutomorphismType( const tFlag& upToAutomorphismType) {
        mUpToAutomorphismType=upToAutomorphismType;
    }
    

    inline tBoolean isUpToAutomorphism() const {
        return mIsUpToAutomorphism;
    }
    inline tFlag getUpToAutomorphismType() const {
        return mUpToAutomorphismType;
    }
    inline void addPVertexToRemove(const int& vid) {
        mPVerticesToRemove[vid]=true;
    }
    inline void removePVertexToRemove(const int& vid) {
        mPVerticesToRemove.erase(vid);
    }
    inline void addPVertexToKeep(const int& vid) {
        mPVerticesToKeep[vid]=true;
    }
    inline void removePVertexToKeep(const int& vid) {
        mPVerticesToKeep.erase(vid);
    }

    inline tBoolean isPVertexToRemove(const int& id) const {
        return (mPVerticesToRemove.find(id)!=mPVerticesToRemove.end());
    }
    inline tBoolean isPVertexToKeep(const int& id) const {
        return (mPVerticesToKeep.find(id)!=mPVerticesToKeep.end());
    }
    inline tBoolean isPVertexMustBeKept(const int& id) const {
        int n=mPTEdgesToAdd.getSize();
        for (int i=0;i<n;i++) {
            if (mPTEdgesToAdd[i]->getSource()->getId()==id) return true;
        }
        return false;
    }
    
    inline void addPEdgeToRemove(const int& eid) {
        mPEdgesToRemove[eid]=true;
    }
    inline void removePEdgeToRemove(const int& eid) {
        mPEdgesToRemove.erase(eid);
    }
    inline void addPEdgeToKeep(const int& eid) {
        mPEdgesToKeep[eid]=true;
    }
    inline void removePEdgeToKeep(const int& eid) {
        mPEdgesToKeep.erase(eid);
    }
 
    inline void addPEdgeToKeep(const int& source,const int& target) {
        tEdgeIID eiid;
        if (getPatternGraph().getEdgeFromIds(source,target,eiid)) {
            SPC::GPM_Edge edge=getPatternGraph().getEdge(eiid);
            if (edge.get()!=null) 
                addPEdgeToKeep(edge->getId());
        }
    }
    inline void addPEdgeToRemove(const int& source,const int& target) {
        tEdgeIID eiid;
        if (getPatternGraph().getEdgeFromIds(source,target,eiid)) {
            SPC::GPM_Edge edge=getPatternGraph().getEdge(eiid);
            if (edge.get()!=null) 
                addPEdgeToRemove(edge->getId());
        }
    }
    inline const map<int,tBoolean>& getPatternEdgesToRemove() const {
        return mPEdgesToRemove;
    }
    inline const map<int,tBoolean>& getPatternEdgesToKeep() const {
        return mPEdgesToKeep;
    }
    inline const map<int,tBoolean>& getPatternVerticesToRemove() const {
        return mPVerticesToRemove;
    }
    inline const map<int,tBoolean>& getPatternVerticesToKeep() const {
        return mPVerticesToKeep;
    }
    inline tBoolean isPEdgeToRemove(const int& id) {
        return (mPEdgesToRemove.find(id)!=mPEdgesToRemove.end());
    }
    inline tBoolean isPEdgeToKeep(const int& id) const {
        return (mPEdgesToKeep.find(id)!=mPEdgesToKeep.end());
    }
    inline void addPTEdgeToAdd(const int& source,const int& target) {
        const GPM_PortGraph& patternGraph=getPatternGraph();
        const GPM_PortGraph& transformerGraph=getTransformerGraph();
        SP::GPM_Vertex sourceNode=patternGraph.getVertex(patternGraph.getVertexIID(source));
        SP::GPM_Vertex targetNode=transformerGraph.getVertex(transformerGraph.getVertexIID(target));
        addPTEdgeToAdd(sourceNode,targetNode);
    }
    
    inline void addPTEdgeToAdd(SP::GPM_Vertex source,SP::GPM_Vertex target) {
        SP::GPM_Edge edge=getPatternGraph().newEdge(source,target);
        addPTEdgeToAdd(edge);
    }
    inline void addPTEdgeToAdd(SP::GPM_Edge edge) {
        mPTEdgesToAdd.add(edge);
        edge->setId(mPTEdgesToAdd.getSize()-1);
        addPVertexToKeep(edge->getSource()->getId());
    }
    
    inline int getPTEdgesNumber() const {
        return mPTEdgesToAdd.size();
    }
    inline SP::GPM_Edge getPTEdge(const int& index) const {
        return mPTEdgesToAdd[index];
    }
    
    inline void removeLastPTEdge() {
        SP::GPM_Edge edge=mPTEdgesToAdd[mPTEdgesToAdd.size()-1];
        removePTEdgeToAdd(edge);
    }
    inline void removePTEdgeToAdd(SP::GPM_Edge edge) {
        removePTEdgeToAdd(edge->getSource()->getId(),edge->getTarget()->getId());
    }
    
    void removePTEdgeToAdd(const int& source,const int& target);

    void clearPTEdgesToAdd() {
        mPTEdgesToAdd.clear();
    }
    void removePTEdgeToAddWithSource(const int& sourceId);
    
    void removePTEdgeToAddWithTarget(const int& targetId);


    void addVariableNameToNodeGroupId(const tString& name) {
        mNodeGroupIds.push_back(name);
    }
    void removeVariableNameToNodeGroupId(const int& index) {
        mNodeGroupIds.erase(mNodeGroupIds.begin()+index);
    }
    void addVariableNameToPortGroupId(const tString& name) {
        mPortGroupIds.push_back(name);
    }
    void removeVariableNameToPortGroupId(const int& index) {
        mPortGroupIds.erase(mPortGroupIds.begin()+index);
    }
    void initGroupNames(GPM_PortGraph& graph,CORE_Out& io) const;



    const vector<tString>& getNodeGroupIds() const {
        return mNodeGroupIds;
    }
    const vector<tString>& getPortGroupIds() const {
        return mPortGroupIds;
    }
    
public:
    void getPatternVerticesToRemove(vector<int>& ids) const {
        ids.clear();
        map<int,tBoolean>::const_iterator iter=mPVerticesToRemove.begin();
        while (iter!=mPVerticesToRemove.end()) {
            ids.push_back(iter->first);
            iter++;
        }
        
    }
    void getPatternVerticesToKeep(vector<int>& ids) const {
        ids.clear();
        map<int,tBoolean>::const_iterator iter=mPVerticesToKeep.begin();
        while (iter!=mPVerticesToKeep.end()) {
            ids.push_back(iter->first);
            iter++;
        }
        
    }

    
    void getPatternEdgesToRemove( vector<int>& ids) const {
        ids.clear();
        map<int,tBoolean>::const_iterator iter=mPEdgesToRemove.begin();
        while (iter!=mPEdgesToRemove.end()) {
            ids.push_back(iter->first);
            iter++;
        }
    }
    void getPatternEdgesToKeep( vector<int>& ids) const {
        ids.clear();
        map<int,tBoolean>::const_iterator iter=mPEdgesToKeep.begin();
        while (iter!=mPEdgesToKeep.end()) {
            ids.push_back(iter->first);
            iter++;
        }
    }
public:
    const SV::GPM_Edge& getPatternTransformEdgesToAdd() const {
        return mPTEdgesToAdd;
    }
    SV::GPM_Edge& getPatternTransformEdgesToAdd() {
        return mPTEdgesToAdd;
    }


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

    inline tBoolean isVertexCut(const int& id) const {
        return (mPVerticesToRemove.find(id)!=mPVerticesToRemove.end());
    }
    inline tBoolean isVertexKept(const int& id) const {
        return (mPVerticesToKeep.find(id)!=mPVerticesToKeep.end());
    }
    inline tBoolean isEdgeCut(const int& id) const {
        return (mPEdgesToRemove.find(id)!=mPEdgesToRemove.end());
    }
    inline tBoolean isEdgeKept(const int& id) const {
        return (mPEdgesToKeep.find(id)!=mPEdgesToKeep.end());
    }
    tBoolean isValid() const;
    
    virtual tBoolean apply(GPM_Graph& largeGraph,
                           const vector<tVertexIID>& mappingP2L,CORE_Out& io)  {
        return apply(getPatternGraph(),getTransformerGraph(),
                     largeGraph,mappingP2L,
                     io);
    }
public:
    virtual tBoolean updateTransformerGraphStates(GPM_Graph& largeGraph,
                                                  const vector<tVertexIID>& mappingP2L,
                                                  const map<tVertexIID,tVertexIID>& mappingT2L,CORE_Out& io)=0;
    virtual tBoolean updatePatternGraphStates(GPM_Graph& largeGraph,
                                              const vector<tVertexIID>& mappingP2L,CORE_Out& io)=0;
    
    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)=0;

    
    
private:

    tBoolean apply(const GPM_Graph& patternGraph,
                   const GPM_Graph& transformerGraph,
                   GPM_Graph& largeGraph,const vector<tVertexIID>& mapping,
                   CORE_Out& io) ;

public:
    virtual tString toString() const;
    
};

#endif