21 #ifndef Tulip_SUPERGRAPHIMPL_H 
   22 #define Tulip_SUPERGRAPHIMPL_H 
   24 #ifndef DOXYGEN_NOTFOR_USER 
   30 #include <tulip/GraphAbstract.h> 
   31 #include <tulip/GraphStorage.h> 
   32 #include <tulip/IdManager.h> 
   35 template<
class itType >
 
   38 class GraphUpdatesRecorder;
 
   41 class TLP_SCOPE GraphImpl:
public GraphAbstract {
 
   43   friend class GraphUpdatesRecorder;
 
   44   friend class TLPExport;
 
   51   bool isElement(
const node ) 
const;
 
   52   bool isElement(
const edge ) 
const;
 
   53   edge existEdge(
const node source, 
const node target,
 
   54                  bool directed = 
true) 
const;
 
   56   void addNodes(
unsigned int nb, std::vector<node>& addedNodes);
 
   57   void addNode(
const node);
 
   58   void addNodes(Iterator<node>* nodes);
 
   59   edge addEdge(
const node ,
const node);
 
   60   void addEdges(
const std::vector<std::pair<node, node> >& edges,
 
   61                 std::vector<edge>& addedEdges);
 
   62   void addEdge(
const edge);
 
   63   void addEdges(Iterator<edge>* edges);
 
   64   void delNode(
const tlp::node n, 
bool deleteInAllGraphs = 
false);
 
   65   void delEdge(
const tlp::edge e, 
bool deleteInAllGraphs = 
false);
 
   66   void setEdgeOrder(
const node,
const std::vector<edge> & );
 
   67   void swapEdgeOrder(
const node,
const edge , 
const edge );
 
   69   Iterator<node>* getNodes() 
const;
 
   70   Iterator<node>* getInNodes(
const node )
const;
 
   71   Iterator<node>* getOutNodes(
const node )
const;
 
   72   Iterator<node>* getInOutNodes(
const node )
const;
 
   73   Iterator<edge>* getEdges()
const;
 
   74   Iterator<edge>* getInEdges(
const node )
const;
 
   75   Iterator<edge>* getOutEdges(
const node )
const;
 
   76   Iterator<edge>* getInOutEdges(
const node )
const;
 
   77   std::vector<edge> getEdges(
const node source, 
const node target,
 
   78                              bool directed = 
true) 
const;
 
   79   bool getEdges(
const node source, 
const node target, 
bool directed,
 
   80                 std::vector<edge>& edges)
 const {
 
   81     return storage.getEdges(source, target, directed, edges);
 
   84   void getInOutEdges(
const node, std::vector<edge>& edges,
 
   85                      bool loopsOnlyOnce = 
false)
const;
 
   87   unsigned int deg(
const node ) 
const;
 
   88   unsigned int indeg(
const node) 
const;
 
   89   unsigned int outdeg(
const node) 
const;
 
   91   virtual node source(
const edge) 
const;
 
   92   virtual node target(
const edge) 
const;
 
   93   virtual node opposite(
const edge, 
const node n) 
const;
 
   94   virtual const std::pair<node, node>& ends(
const edge e) 
const;
 
   95   virtual void setEnds(
const edge, 
const node, 
const node);
 
   96   virtual void reverse(
const edge);
 
   98   unsigned int numberOfEdges()
const;
 
   99   unsigned int numberOfNodes()
const;
 
  102   virtual void push(
bool unpopAllowed = 
true,
 
  103                     std::vector<PropertyInterface*>* propertiesToPreserveOnPop= NULL);
 
  104   virtual void pop(
bool unpopAllowed = 
true);
 
  105   virtual void unpop();
 
  106   virtual bool canPop();
 
  107   virtual bool canUnpop();
 
  108   virtual bool canPopThenUnpop();
 
  111   void treatEvents(
const std::vector<Event> &);
 
  114   unsigned int getSubGraphId(
unsigned int id);
 
  115   void freeSubGraphId(
unsigned int id);
 
  119   virtual void reserveNodes(
unsigned int nbNodes);
 
  120   virtual void reserveEdges(
unsigned int nbEdges);
 
  125   virtual node restoreNode(node);
 
  126   virtual void restoreNodes(
const std::vector<node>&);
 
  127   virtual edge restoreEdge(edge, node source, node target);
 
  128   virtual void restoreEdges(
const std::vector<edge>& edges,
 
  129                             const std::vector<std::pair<node, node> >& ends);
 
  132   virtual void removeNode(
const node);
 
  133   virtual void removeEdge(
const edge);
 
  135   virtual bool canDeleteProperty(Graph* g, PropertyInterface *prop);
 
  138   GraphStorage storage;
 
  140   std::list<GraphUpdatesRecorder*> previousRecorders;
 
  141   std::list<Graph *> observedGraphs;
 
  142   std::list<PropertyInterface*> observedProps;
 
  143   std::list<GraphUpdatesRecorder*> recorders;
 
  145   void restoreAdj(node, std::vector<edge>&);
 
  146   void observeUpdates(Graph*);
 
  147   void unobserveUpdates();
 
  148   void delPreviousRecorders();