GPM_Graph.h

Go to the documentation of this file.

#ifndef GPM_Graph_H
#define GPM_Graph_H

#include "GPM_Object.h"

#include "CORE_Out.h"

#include "GPM_Vertex.h"
#include "GPM_Node.h"
#include "GPM_Edge.h"

// boost include
DEFINE_SPTR(GPM_Graph);

class GPM_Graph : public GPM_Object {
    SP_OBJECT(GPM_Graph);  
// ATTRIBUTES

public:
    static const tVertexIID NULL_VERTEX;
    static const tFlag UP_TO_AUTOMORPHISM_ALL;
    static const tFlag UP_TO_AUTOMORPHISM_NODE;
    static const tFlag UP_TO_AUTOMORPHISM_PORT;
    
    
private:
   
    int mVertexIdGenerator;
    int mEdgeIdGenerator;
    tFlag mGroupId;
    
    
    // ASSOCIATIONS
    
   

    
    tGraph mGraph;

    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    GPM_Graph(void);
  
  
  
    // DESTRUCTORS 
  
  
    virtual ~GPM_Graph(void);   
  
  
public:

    // NEW methods
    
    static inline SP::GPM_Graph New() {
        SP::GPM_Graph p(new GPM_Graph(),GPM_Graph::Delete());
        p->setThis(p);
        return p;
    }

    // SET & GET methods

    //internal
    inline const tGraph& getGraphImplement() const {
        return mGraph;
    }
    
    inline tGraph& getGraphImplement()  {
        return mGraph;
    }

    // Vertices
    // --------

    

public:
    virtual SP::GPM_GraphElement newInstance(const tString& className) const;
    
    virtual SP::GPM_Node newNode() const {
        return GPM_Node::New();
    }


    virtual void copy(const GPM_Graph& graph);
    
    tVertexIID addVertex(SP::GPM_Vertex vertex);
    
  
    inline tVertexIID addNode() {
        SP::GPM_Vertex vertex=newNode();
        vertex->setId(generateVertexId());
        return addVertex(vertex);
    }
    
    inline tVertexIID addNode(const int& id) {
        SP::GPM_Vertex vertex=newNode();
        vertex->setId(id);
        return addVertex(vertex);
    }
   
    

    void removeVertex(const tVertexIID& iid);
    
     
    int getVerticesNumber() const;
    
    SP::GPM_Vertex getVertex(const tVertexIID& iid) const;
    
    
    int getVertexId(const tVertexIID& iid) const;
    
    tVertexIID getVertexIID(const int& id) const;
    
    
public:
    
    void getVertices(vector<tVertexIID>& vertexIIDs) const;
    void getVertices(SV::GPM_Vertex& vertexIIDs) const;

    void getConnectedVertices(const tVertexIID& iid,vector<tVertexIID>& vertexIIDs) const;
    
    int getDegree(const tVertexIID& id) const;
    

    // EDGES
    // -----
private:
    //tBoolean getEdgeIID(const int& id,tEdgeIID& iid) const;

    //void updateEdgeIIDs();

public:
    virtual SP::GPM_Edge newEdge() const {
        return GPM_Edge::New();
    }
    virtual SP::GPM_Edge newEdge(const int& id) const {
        SP::GPM_Edge p=GPM_Edge::New(id);
        return p;
    }
    virtual SP::GPM_Edge newEdge(SP::GPM_Vertex source,SP::GPM_Vertex target) const {
        SP::GPM_Edge p=GPM_Edge::New(source,target);
        return p;
    }
    
    inline tBoolean addEdgeFromIds(const int& source,const int& target,tEdgeIID& iid) {
        tVertexIID sourceIID,targetIID;
        sourceIID=getVertexIID(source);
        if (sourceIID==NULL_VERTEX) sourceIID=addNode(source);
        targetIID=getVertexIID(target);
        if (targetIID==NULL_VERTEX) targetIID=addNode(target);
        int id=generateEdgeId();
        SP::GPM_Edge edge=newEdge();
        edge->setId(id);
        return addEdge(sourceIID,targetIID,edge,iid);
    }
    inline tBoolean addEdgeFromIds(const int& source,const int& target) {
        tEdgeIID eiid;
        return addEdgeFromIds(source,target,eiid);
    }
    virtual tBoolean addEdge(const tVertexIID& from,const tVertexIID& to,SP::GPM_Edge edge,tEdgeIID& iid);
   
    virtual SP::GPM_Edge addEdge(const tVertexIID& from,const tVertexIID& to) {
        tEdgeIID eiid;
        SP::GPM_Edge edge=newEdge();
        edge->setId(generateEdgeId());
        if (!addEdge(from,to,edge,eiid)) edge.reset();
        return edge;
    }
    virtual tBoolean addEdge(const tVertexIID& from,const tVertexIID& to,tEdgeIID& eiid) {
        SP::GPM_Edge edge=newEdge();
        edge->setId(generateEdgeId());
        tBoolean succeeds=addEdge(from,to,edge,eiid);
        if (!succeeds) edge.reset();
        return succeeds;
    }
protected:
    tBoolean addEdge_(const tVertexIID& from,const tVertexIID& to,SP::GPM_Edge edge,tEdgeIID& iid);
   

public:
    tBoolean removeEdge(const tEdgeIID& edgeId);
    tBoolean removeEdges(const tVertexIID& vertexIID);
    
    tBoolean removeEdges(const tVertexIID& form,const tVertexIID& to);
    
    int getEdgesNumber() const;
    
    void getEdges(vector<tEdgeIID>& ids) const;
    
    void getEdges(SV::GPM_Edge& edges) const;
    
    void getEdges(const tVertexIID& v,vector<tEdgeIID>& edges) const;
    
    tBoolean getEdge(const tVertexIID& e1,const tVertexIID& e2,tEdgeIID& iid) const;  
  

    inline tBoolean getEdgeFromIds(const int& e1,const int& e2,tEdgeIID& iid) const {
        return getEdge(getVertexIID(e1),getVertexIID(e2),iid);
    }
    inline tBoolean getEdgeFromIds(const int& e1,const int& e2) const {
        tEdgeIID iid;
        return getEdge(getVertexIID(e1),getVertexIID(e2),iid);
    }

    
    SP::GPM_Edge getEdge(const tEdgeIID& id);
    SPC::GPM_Edge getEdge(const tEdgeIID& id) const;

    const GPM_Edge* getEdge(const tVertexIID& e1,const tVertexIID& e2) const;
    GPM_Edge* getEdge(const tVertexIID& e1,const tVertexIID& e2);

    void getEdgeVertices(const tEdgeIID& id,tVertexIID& source,tVertexIID& target) const;
  
    int getEdgeId(const tEdgeIID& iid) const;

    tBoolean getEdgeIID(const int& id,tEdgeIID& iid) const;
   

    // COMMON METHODS
    // ---------------
    
    void clear();

    void close();

    tBoolean merge(const tVertexIID& from,const tVertexIID& to,CORE_Out& io);

    void addSubGraph(const GPM_Graph& graph,map<tVertexIID,tVertexIID>& connections);
    

    // TRIGGAR Action
  

    void executeTriggerActions(CORE_Out& io);
    
    
    // IO methods
    // ----------
    
    tBoolean saveToFile(const tString& fileName) const;
    tBoolean loadFromFile(const tString& fileName,CORE_Out& io);

    virtual tBoolean exportToCurveFile(const tString& fileName,
                                       const tString& title,
                                       const tString& XLabel,
                                       const tString& YLabel) const;
    


    //  MORPHISM methods
    // -----------------
    void printGroupId(CORE_Out& io) const;

  
    void updateGroupId();

    

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

private:
    void updateGroupIdMap(map<tString,unsigned int>& groupIds) const;

public:
    tBoolean isIsomorph(const GPM_Graph& g,vector<tVertexIID>& verticesMap,CORE_Out& io) const;
    inline tBoolean isIsomorph(SPC::GPM_Graph g,vector<tVertexIID>& verticesMap,CORE_Out& io) const {
        if (g.get()==null) return false;
        return isIsomorph(*g.get(),verticesMap,io);
        
    }
    inline tBoolean isIsomorph(SPC::GPM_Graph g,CORE_Out& io) const {
        vector<tVertexIID> verticesMap;
        return isIsomorph(g,verticesMap,io);
    }
   
    inline tBoolean isIsomorph(const  GPM_Graph& g,CORE_Out& io) const {
        vector<tVertexIID> verticesMap;
        return isIsomorph(g,verticesMap,io);
    }
    
    void getPatterns(const GPM_Graph& pattern,const tBoolean& isUpToAutomorphism,const tFlag& upToAutomorphismType,
                     vector<vector<tVertexIID> >& homomorphisms,CORE_Out& io) const;
    
    inline void getPatterns(SPC::GPM_Graph pattern,const tBoolean& isUpToAutomorphism,const tFlag& upToAutomorphismType,
                            vector<vector<tVertexIID> >& homomorphisms,CORE_Out& io) const {
        if (pattern.get()==null) throw CORE_Exception("gpm/core","GPM_Graph::getPatterns","null graph pattern !");
        getPatterns(*pattern.get(),isUpToAutomorphism,upToAutomorphismType,homomorphisms,io);
    }
    inline void getPatterns(const GPM_Graph& pattern,vector<vector<tVertexIID> >& homomorphisms,CORE_Out& io) const {
        getPatterns(pattern,false,UP_TO_AUTOMORPHISM_ALL,homomorphisms,io);
    }
    inline void getPatterns(SPC::GPM_Graph pattern,vector<vector<tVertexIID> >& homomorphisms,CORE_Out& io) const {
        getPatterns(pattern,false,UP_TO_AUTOMORPHISM_ALL,homomorphisms,io);
    }


   

    virtual tString toString() const;
    
    
private:
    void saveToStream(ofstream& f) const;
    tBoolean loadFromStream(ifstream& f,CORE_Out& io);

public:
    int generateVertexId();
    
    int generateEdgeId();

    
    
  
   

};

#endif