Some more docs.
3 #ifndef HUGO_LIST_GRAPH_H
4 #define HUGO_LIST_GRAPH_H
8 ///\brief ListGraph, SymListGraph, NodeSet and EdgeSet classes.
17 /// \addtogroup graphs
22 ///A list graph class.
24 ///This is a simple and fast erasable graph implementation.
26 ///It conforms to the graph interface documented under
27 ///the description of \ref GraphSkeleton.
28 ///\sa \ref GraphSkeleton.
31 //Nodes are double linked.
32 //The free nodes are only single linked using the "next" field.
35 int first_in,first_out;
39 //Edges are double linked.
40 //The free edges are only single linked using the "next_in" field.
44 int prev_in, prev_out;
45 int next_in, next_out;
46 //FIXME: is this necessary?
47 // EdgeT() : next_in(-1), next_out(-1) prev_in(-1), prev_out(-1) {}
50 std::vector<NodeT> nodes;
55 std::vector<EdgeT> edges;
61 template <typename Key> class DynMapBase
66 virtual void add(const Key k) = NULL;
67 virtual void erase(const Key k) = NULL;
68 DynMapBase(const ListGraph &_G) : G(&_G) {}
69 virtual ~DynMapBase() {}
70 friend class ListGraph;
74 template <typename T> class EdgeMap;
75 template <typename T> class NodeMap;
83 ///\bug It must be public because of SymEdgeMap.
85 mutable std::vector<DynMapBase<Node> * > dyn_node_maps;
86 ///\bug It must be public because of SymEdgeMap.
88 mutable std::vector<DynMapBase<Edge> * > dyn_edge_maps;
97 template <typename T> class NodeMap;
98 template <typename T> class EdgeMap;
102 ListGraph() : nodes(), first_node(-1),
103 first_free_node(-1), edges(), first_free_edge(-1) {}
104 ListGraph(const ListGraph &_g) : nodes(_g.nodes), first_node(_g.first_node),
105 first_free_node(_g.first_free_node),
107 first_free_edge(_g.first_free_edge) {}
111 for(std::vector<DynMapBase<Node> * >::iterator i=dyn_node_maps.begin();
112 i!=dyn_node_maps.end(); ++i) (**i).G=NULL;
113 for(std::vector<DynMapBase<Edge> * >::iterator i=dyn_edge_maps.begin();
114 i!=dyn_edge_maps.end(); ++i) (**i).G=NULL;
117 int nodeNum() const { return nodes.size(); } //FIXME: What is this?
118 int edgeNum() const { return edges.size(); } //FIXME: What is this?
120 ///\bug This function does something different than
121 ///its name would suggests...
122 int maxNodeId() const { return nodes.size(); } //FIXME: What is this?
123 ///\bug This function does something different than
124 ///its name would suggests...
125 int maxEdgeId() const { return edges.size(); } //FIXME: What is this?
127 Node tail(Edge e) const { return edges[e.n].tail; }
128 Node head(Edge e) const { return edges[e.n].head; }
130 Node aNode(OutEdgeIt e) const { return edges[e.n].tail; }
131 Node aNode(InEdgeIt e) const { return edges[e.n].head; }
133 Node bNode(OutEdgeIt e) const { return edges[e.n].head; }
134 Node bNode(InEdgeIt e) const { return edges[e.n].tail; }
136 NodeIt& first(NodeIt& v) const {
137 v=NodeIt(*this); return v; }
138 EdgeIt& first(EdgeIt& e) const {
139 e=EdgeIt(*this); return e; }
140 OutEdgeIt& first(OutEdgeIt& e, const Node v) const {
141 e=OutEdgeIt(*this,v); return e; }
142 InEdgeIt& first(InEdgeIt& e, const Node v) const {
143 e=InEdgeIt(*this,v); return e; }
145 // template< typename It >
146 // It first() const { It e; first(e); return e; }
148 // template< typename It >
149 // It first(Node v) const { It e; first(e,v); return e; }
151 bool valid(Edge e) const { return e.n!=-1; }
152 bool valid(Node n) const { return n.n!=-1; }
154 void setInvalid(Edge &e) { e.n=-1; }
155 void setInvalid(Node &n) { n.n=-1; }
157 template <typename It> It getNext(It it) const
158 { It tmp(it); return next(tmp); }
160 NodeIt& next(NodeIt& it) const {
161 it.n=nodes[it.n].next;
164 OutEdgeIt& next(OutEdgeIt& it) const
165 { it.n=edges[it.n].next_out; return it; }
166 InEdgeIt& next(InEdgeIt& it) const
167 { it.n=edges[it.n].next_in; return it; }
168 EdgeIt& next(EdgeIt& it) const {
169 if(edges[it.n].next_in!=-1) {
170 it.n=edges[it.n].next_in;
174 for(n=nodes[edges[it.n].head].next;
175 n!=-1 && nodes[n].first_in == -1;
177 it.n = (n==-1)?-1:nodes[n].first_in;
182 int id(Node v) const { return v.n; }
183 int id(Edge e) const { return e.n; }
185 /// Adds a new node to the graph.
187 /// \todo It adds the nodes in a reversed order.
188 /// (i.e. the lastly added node becomes the first.)
192 if(first_free_node==-1)
195 nodes.push_back(NodeT());
199 first_free_node = nodes[n].next;
202 nodes[n].next = first_node;
203 if(first_node != -1) nodes[first_node].prev = n;
207 nodes[n].first_in = nodes[n].first_out = -1;
211 //Update dynamic maps
212 for(std::vector<DynMapBase<Node> * >::iterator i=dyn_node_maps.begin();
213 i!=dyn_node_maps.end(); ++i) (**i).add(nn);
218 Edge addEdge(Node u, Node v) {
221 if(first_free_edge==-1)
224 edges.push_back(EdgeT());
228 first_free_edge = edges[n].next_in;
231 edges[n].tail = u.n; edges[n].head = v.n;
233 edges[n].next_out = nodes[u.n].first_out;
234 if(nodes[u.n].first_out != -1) edges[nodes[u.n].first_out].prev_out = n;
235 edges[n].next_in = nodes[v.n].first_in;
236 if(nodes[v.n].first_in != -1) edges[nodes[v.n].first_in].prev_in = n;
237 edges[n].prev_in = edges[n].prev_out = -1;
239 nodes[u.n].first_out = nodes[v.n].first_in = n;
243 //Update dynamic maps
244 for(std::vector<DynMapBase<Edge> * >::iterator i=dyn_edge_maps.begin();
245 i!=dyn_edge_maps.end(); ++i) (**i).add(e);
251 void eraseEdge(int n) {
253 if(edges[n].next_in!=-1)
254 edges[edges[n].next_in].prev_in = edges[n].prev_in;
255 if(edges[n].prev_in!=-1)
256 edges[edges[n].prev_in].next_in = edges[n].next_in;
257 else nodes[edges[n].head].first_in = edges[n].next_in;
259 if(edges[n].next_out!=-1)
260 edges[edges[n].next_out].prev_out = edges[n].prev_out;
261 if(edges[n].prev_out!=-1)
262 edges[edges[n].prev_out].next_out = edges[n].next_out;
263 else nodes[edges[n].tail].first_out = edges[n].next_out;
265 edges[n].next_in = first_free_edge;
266 first_free_edge = -1;
268 //Update dynamic maps
270 for(std::vector<DynMapBase<Edge> * >::iterator i=dyn_edge_maps.begin();
271 i!=dyn_edge_maps.end(); ++i) (**i).erase(e);
276 void erase(Node nn) {
280 while((m=nodes[n].first_in)!=-1) eraseEdge(m);
281 while((m=nodes[n].first_out)!=-1) eraseEdge(m);
283 if(nodes[n].next != -1) nodes[nodes[n].next].prev = nodes[n].prev;
284 if(nodes[n].prev != -1) nodes[nodes[n].prev].next = nodes[n].next;
285 else first_node = nodes[n].next;
287 nodes[n].next = first_free_node;
290 //Update dynamic maps
291 for(std::vector<DynMapBase<Node> * >::iterator i=dyn_node_maps.begin();
292 i!=dyn_node_maps.end(); ++i) (**i).erase(nn);
295 void erase(Edge e) { eraseEdge(e.n); }
297 ///\bug Dynamic maps must be updated!
300 nodes.clear();edges.clear();
301 first_node=first_free_node=first_free_edge=-1;
305 friend class ListGraph;
306 template <typename T> friend class NodeMap;
309 friend class OutEdgeIt;
310 friend class InEdgeIt;
311 friend class SymEdge;
315 friend int ListGraph::id(Node v) const;
319 Node (Invalid i) { n=-1; }
320 bool operator==(const Node i) const {return n==i.n;}
321 bool operator!=(const Node i) const {return n!=i.n;}
322 bool operator<(const Node i) const {return n<i.n;}
325 class NodeIt : public Node {
326 friend class ListGraph;
328 NodeIt() : Node() { }
329 NodeIt(Invalid i) : Node(i) { }
330 NodeIt(const ListGraph& G) : Node(G.first_node) { }
334 friend class ListGraph;
335 template <typename T> friend class EdgeMap;
337 //template <typename T> friend class SymListGraph::SymEdgeMap;
338 //friend Edge SymListGraph::opposite(Edge) const;
344 friend int ListGraph::id(Edge e) const;
349 Edge (Invalid) { n=-1; }
350 bool operator==(const Edge i) const {return n==i.n;}
351 bool operator!=(const Edge i) const {return n!=i.n;}
352 bool operator<(const Edge i) const {return n<i.n;}
353 ///\bug This is a workaround until somebody tells me how to
354 ///make class \c SymListGraph::SymEdgeMap friend of Edge
355 int &idref() {return n;}
356 const int &idref() const {return n;}
359 class EdgeIt : public Edge {
360 friend class ListGraph;
362 EdgeIt(const ListGraph& G) : Edge() {
365 m!=-1 && G.nodes[m].first_in == -1; m = G.nodes[m].next);
366 n = (m==-1)?-1:G.nodes[m].first_in;
368 EdgeIt (Invalid i) : Edge(i) { }
369 EdgeIt() : Edge() { }
370 ///\bug This is a workaround until somebody tells me how to
371 ///make class \c SymListGraph::SymEdgeMap friend of Edge
372 int &idref() {return n;}
375 class OutEdgeIt : public Edge {
376 friend class ListGraph;
378 OutEdgeIt() : Edge() { }
379 OutEdgeIt (Invalid i) : Edge(i) { }
381 OutEdgeIt(const ListGraph& G,const Node v)
382 : Edge(G.nodes[v.n].first_out) {}
385 class InEdgeIt : public Edge {
386 friend class ListGraph;
388 InEdgeIt() : Edge() { }
389 InEdgeIt (Invalid i) : Edge(i) { }
390 InEdgeIt(const ListGraph& G,Node v) :Edge(G.nodes[v.n].first_in){}
393 template <typename T> class NodeMap : public DynMapBase<Node>
395 std::vector<T> container;
399 typedef Node KeyType;
401 NodeMap(const ListGraph &_G) :
402 DynMapBase<Node>(_G), container(_G.maxNodeId())
404 G->dyn_node_maps.push_back(this);
406 NodeMap(const ListGraph &_G,const T &t) :
407 DynMapBase<Node>(_G), container(_G.maxNodeId(),t)
409 G->dyn_node_maps.push_back(this);
412 NodeMap(const NodeMap<T> &m) :
413 DynMapBase<Node>(*m.G), container(m.container)
415 G->dyn_node_maps.push_back(this);
418 template<typename TT> friend class NodeMap;
420 ///\todo It can copy between different types.
422 template<typename TT> NodeMap(const NodeMap<TT> &m) :
423 DynMapBase<Node>(*m.G)
425 G->dyn_node_maps.push_back(this);
426 typename std::vector<TT>::const_iterator i;
427 for(typename std::vector<TT>::const_iterator i=m.container.begin();
428 i!=m.container.end();
430 container.push_back(*i);
435 std::vector<DynMapBase<Node>* >::iterator i;
436 for(i=G->dyn_node_maps.begin();
437 i!=G->dyn_node_maps.end() && *i!=this; ++i) ;
438 //if(*i==this) G->dyn_node_maps.erase(i); //FIXME: Way too slow...
439 //A better way to do that: (Is this really important?)
441 *i=G->dyn_node_maps.back();
442 G->dyn_node_maps.pop_back();
447 void add(const Node k)
449 if(k.n>=int(container.size())) container.resize(k.n+1);
452 void erase(const Node) { }
454 void set(Node n, T a) { container[n.n]=a; }
455 //'T& operator[](Node n)' would be wrong here
456 typename std::vector<T>::reference
457 operator[](Node n) { return container[n.n]; }
458 //'const T& operator[](Node n)' would be wrong here
459 typename std::vector<T>::const_reference
460 operator[](Node n) const { return container[n.n]; }
462 ///\warning There is no safety check at all!
463 ///Using operator = between maps attached to different graph may
464 ///cause serious problem.
465 ///\todo Is this really so?
466 ///\todo It can copy between different types.
467 const NodeMap<T>& operator=(const NodeMap<T> &m)
469 container = m.container;
472 template<typename TT>
473 const NodeMap<T>& operator=(const NodeMap<TT> &m)
475 copy(m.container.begin(), m.container.end(), container.begin());
479 void update() {} //Useless for Dynamic Maps
480 void update(T a) {} //Useless for Dynamic Maps
483 template <typename T> class EdgeMap : public DynMapBase<Edge>
485 std::vector<T> container;
489 typedef Edge KeyType;
491 EdgeMap(const ListGraph &_G) :
492 DynMapBase<Edge>(_G), container(_G.maxEdgeId())
494 //FIXME: What if there are empty Id's?
495 //FIXME: Can I use 'this' in a constructor?
496 G->dyn_edge_maps.push_back(this);
498 EdgeMap(const ListGraph &_G,const T &t) :
499 DynMapBase<Edge>(_G), container(_G.maxEdgeId(),t)
501 G->dyn_edge_maps.push_back(this);
503 EdgeMap(const EdgeMap<T> &m) :
504 DynMapBase<Edge>(*m.G), container(m.container)
506 G->dyn_node_maps.push_back(this);
509 template<typename TT> friend class EdgeMap;
511 ///\todo It can copy between different types.
513 template<typename TT> EdgeMap(const EdgeMap<TT> &m) :
514 DynMapBase<Edge>(*m.G)
516 G->dyn_node_maps.push_back(this);
517 typename std::vector<TT>::const_iterator i;
518 for(typename std::vector<TT>::const_iterator i=m.container.begin();
519 i!=m.container.end();
521 container.push_back(*i);
526 std::vector<DynMapBase<Edge>* >::iterator i;
527 for(i=G->dyn_edge_maps.begin();
528 i!=G->dyn_edge_maps.end() && *i!=this; ++i) ;
529 //if(*i==this) G->dyn_edge_maps.erase(i); //Way too slow...
530 //A better way to do that: (Is this really important?)
532 *i=G->dyn_edge_maps.back();
533 G->dyn_edge_maps.pop_back();
538 void add(const Edge k)
540 if(k.n>=int(container.size())) container.resize(k.n+1);
542 void erase(const Edge) { }
544 void set(Edge n, T a) { container[n.n]=a; }
545 //T get(Edge n) const { return container[n.n]; }
546 typename std::vector<T>::reference
547 operator[](Edge n) { return container[n.n]; }
548 typename std::vector<T>::const_reference
549 operator[](Edge n) const { return container[n.n]; }
551 ///\warning There is no safety check at all!
552 ///Using operator = between maps attached to different graph may
553 ///cause serious problem.
554 ///\todo Is this really so?
555 ///\todo It can copy between different types.
556 const EdgeMap<T>& operator=(const EdgeMap<T> &m)
558 container = m.container;
561 template<typename TT>
562 const EdgeMap<T>& operator=(const EdgeMap<TT> &m)
564 copy(m.container.begin(), m.container.end(), container.begin());
568 void update() {} //Useless for DynMaps
569 void update(T a) {} //Useless for DynMaps
574 ///Graph for bidirectional edges.
576 ///The purpose of this graph structure is to handle graphs
577 ///having bidirectional edges. Here the function \c addEdge(u,v) adds a pair
578 ///of oppositely directed edges.
579 ///There is a new edge map type called
580 ///\ref SymListGraph::SymEdgeMap "SymEdgeMap"
581 ///that complements this
583 ///storing shared values for the edge pairs. The usual
584 ///\ref GraphSkeleton::EdgeMap "EdgeMap"
588 ///The oppositely directed edge can also be obtained easily
589 ///using \ref opposite.
591 ///Here erase(Edge) deletes a pair of edges.
593 ///\todo this date structure need some reconsiderations. Maybe it
594 ///should be implemented independently from ListGraph.
596 class SymListGraph : public ListGraph
599 template<typename T> class SymEdgeMap;
600 template<typename T> friend class SymEdgeMap;
602 SymListGraph() : ListGraph() { }
603 SymListGraph(const ListGraph &_g) : ListGraph(_g) { }
604 ///Adds a pair of oppositely directed edges to the graph.
605 Edge addEdge(Node u, Node v)
607 Edge e = ListGraph::addEdge(u,v);
608 ListGraph::addEdge(v,u);
612 void erase(Node n) { ListGraph::erase(n); }
613 ///The oppositely directed edge.
615 ///Returns the oppositely directed
616 ///pair of the edge \c e.
617 Edge opposite(Edge e) const
620 f.idref() = e.idref() - 2*(e.idref()%2) + 1;
624 ///Removes a pair of oppositely directed edges to the graph.
626 ListGraph::erase(opposite(e));
630 ///Common data storage for the edge pairs.
632 ///This map makes it possible to store data shared by the oppositely
633 ///directed pairs of edges.
634 template <typename T> class SymEdgeMap : public DynMapBase<Edge>
636 std::vector<T> container;
640 typedef Edge KeyType;
642 SymEdgeMap(const SymListGraph &_G) :
643 DynMapBase<Edge>(_G), container(_G.maxEdgeId()/2)
645 static_cast<const SymListGraph*>(G)->dyn_edge_maps.push_back(this);
647 SymEdgeMap(const SymListGraph &_G,const T &t) :
648 DynMapBase<Edge>(_G), container(_G.maxEdgeId()/2,t)
650 G->dyn_edge_maps.push_back(this);
653 SymEdgeMap(const SymEdgeMap<T> &m) :
654 DynMapBase<SymEdge>(*m.G), container(m.container)
656 G->dyn_node_maps.push_back(this);
659 // template<typename TT> friend class SymEdgeMap;
661 ///\todo It can copy between different types.
664 template<typename TT> SymEdgeMap(const SymEdgeMap<TT> &m) :
665 DynMapBase<SymEdge>(*m.G)
667 G->dyn_node_maps.push_back(this);
668 typename std::vector<TT>::const_iterator i;
669 for(typename std::vector<TT>::const_iterator i=m.container.begin();
670 i!=m.container.end();
672 container.push_back(*i);
678 std::vector<DynMapBase<Edge>* >::iterator i;
679 for(i=static_cast<const SymListGraph*>(G)->dyn_edge_maps.begin();
680 i!=static_cast<const SymListGraph*>(G)->dyn_edge_maps.end()
682 //if(*i==this) G->dyn_edge_maps.erase(i); //Way too slow...
683 //A better way to do that: (Is this really important?)
685 *i=static_cast<const SymListGraph*>(G)->dyn_edge_maps.back();
686 static_cast<const SymListGraph*>(G)->dyn_edge_maps.pop_back();
691 void add(const Edge k)
693 if(!k.idref()%2&&k.idref()/2>=int(container.size()))
694 container.resize(k.idref()/2+1);
696 void erase(const Edge k) { }
698 void set(Edge n, T a) { container[n.idref()/2]=a; }
699 //T get(Edge n) const { return container[n.idref()/2]; }
700 typename std::vector<T>::reference
701 operator[](Edge n) { return container[n.idref()/2]; }
702 typename std::vector<T>::const_reference
703 operator[](Edge n) const { return container[n.idref()/2]; }
705 ///\warning There is no safety check at all!
706 ///Using operator = between maps attached to different graph may
707 ///cause serious problem.
708 ///\todo Is this really so?
709 ///\todo It can copy between different types.
710 const SymEdgeMap<T>& operator=(const SymEdgeMap<T> &m)
712 container = m.container;
715 template<typename TT>
716 const SymEdgeMap<T>& operator=(const SymEdgeMap<TT> &m)
718 copy(m.container.begin(), m.container.end(), container.begin());
722 void update() {} //Useless for DynMaps
723 void update(T a) {} //Useless for DynMaps
730 ///A graph class containing only nodes.
732 ///This class implements a graph structure without edges.
733 ///The most useful application of this class is to be the node set of an
734 ///\ref EdgeSet class.
736 ///It conforms to the graph interface documented under
737 ///the description of \ref GraphSkeleton with the exception that you cannot
738 ///add (or delete) edges. The usual edge iterators are exists, but they are
739 ///always \ref INVALID.
740 ///\sa \ref GraphSkeleton
744 //Nodes are double linked.
745 //The free nodes are only single linked using the "next" field.
748 int first_in,first_out;
753 std::vector<NodeT> nodes;
756 //The first free node
761 template <typename Key> class DynMapBase
766 virtual void add(const Key k) = NULL;
767 virtual void erase(const Key k) = NULL;
768 DynMapBase(const NodeSet &_G) : G(&_G) {}
769 virtual ~DynMapBase() {}
770 friend class NodeSet;
774 template <typename T> class EdgeMap;
775 template <typename T> class NodeMap;
783 ///\bug It must be public because of SymEdgeMap.
785 mutable std::vector<DynMapBase<Node> * > dyn_node_maps;
786 //mutable std::vector<DynMapBase<Edge> * > dyn_edge_maps;
795 template <typename T> class NodeMap;
796 template <typename T> class EdgeMap;
800 ///Default constructor
801 NodeSet() : nodes(), first_node(-1),
802 first_free_node(-1) {}
804 NodeSet(const NodeSet &_g) : nodes(_g.nodes), first_node(_g.first_node),
805 first_free_node(_g.first_free_node) {}
809 for(std::vector<DynMapBase<Node> * >::iterator i=dyn_node_maps.begin();
810 i!=dyn_node_maps.end(); ++i) (**i).G=NULL;
811 //for(std::vector<DynMapBase<Edge> * >::iterator i=dyn_edge_maps.begin();
812 // i!=dyn_edge_maps.end(); ++i) (**i).G=NULL;
815 int nodeNum() const { return nodes.size(); } //FIXME: What is this?
816 int edgeNum() const { return 0; } //FIXME: What is this?
818 ///\bug This function does something different than
819 ///its name would suggests...
820 int maxNodeId() const { return nodes.size(); } //FIXME: What is this?
821 ///\bug This function does something different than
822 ///its name would suggests...
823 int maxEdgeId() const { return 0; } //FIXME: What is this?
825 Node tail(Edge e) const { return INVALID; }
826 Node head(Edge e) const { return INVALID; }
828 Node aNode(OutEdgeIt e) const { return INVALID; }
829 Node aNode(InEdgeIt e) const { return INVALID; }
831 Node bNode(OutEdgeIt e) const { return INVALID; }
832 Node bNode(InEdgeIt e) const { return INVALID; }
834 NodeIt& first(NodeIt& v) const {
835 v=NodeIt(*this); return v; }
836 EdgeIt& first(EdgeIt& e) const {
837 e=EdgeIt(*this); return e; }
838 OutEdgeIt& first(OutEdgeIt& e, const Node v) const {
839 e=OutEdgeIt(*this,v); return e; }
840 InEdgeIt& first(InEdgeIt& e, const Node v) const {
841 e=InEdgeIt(*this,v); return e; }
843 // template< typename It >
844 // It first() const { It e; first(e); return e; }
846 // template< typename It >
847 // It first(Node v) const { It e; first(e,v); return e; }
849 bool valid(Edge e) const { return false; }
850 bool valid(Node n) const { return n.n!=-1; }
852 void setInvalid(Edge &e) { }
853 void setInvalid(Node &n) { n.n=-1; }
855 template <typename It> It getNext(It it) const
856 { It tmp(it); return next(tmp); }
858 NodeIt& next(NodeIt& it) const {
859 it.n=nodes[it.n].next;
862 OutEdgeIt& next(OutEdgeIt& it) const { return it; }
863 InEdgeIt& next(InEdgeIt& it) const { return it; }
864 EdgeIt& next(EdgeIt& it) const { return it; }
866 int id(Node v) const { return v.n; }
867 int id(Edge e) const { return -1; }
869 /// Adds a new node to the graph.
871 /// \todo It adds the nodes in a reversed order.
872 /// (i.e. the lastly added node becomes the first.)
876 if(first_free_node==-1)
879 nodes.push_back(NodeT());
883 first_free_node = nodes[n].next;
886 nodes[n].next = first_node;
887 if(first_node != -1) nodes[first_node].prev = n;
891 nodes[n].first_in = nodes[n].first_out = -1;
895 //Update dynamic maps
896 for(std::vector<DynMapBase<Node> * >::iterator i=dyn_node_maps.begin();
897 i!=dyn_node_maps.end(); ++i) (**i).add(nn);
902 void erase(Node nn) {
905 if(nodes[n].next != -1) nodes[nodes[n].next].prev = nodes[n].prev;
906 if(nodes[n].prev != -1) nodes[nodes[n].prev].next = nodes[n].next;
907 else first_node = nodes[n].next;
909 nodes[n].next = first_free_node;
912 //Update dynamic maps
913 for(std::vector<DynMapBase<Node> * >::iterator i=dyn_node_maps.begin();
914 i!=dyn_node_maps.end(); ++i) (**i).erase(nn);
917 ///\bug Dynamic maps must be updated!
921 first_node = first_free_node = -1;
925 friend class NodeSet;
926 template <typename T> friend class NodeMap;
929 friend class OutEdgeIt;
930 friend class InEdgeIt;
934 friend int NodeSet::id(Node v) const;
938 Node (Invalid i) { n=-1; }
939 bool operator==(const Node i) const {return n==i.n;}
940 bool operator!=(const Node i) const {return n!=i.n;}
941 bool operator<(const Node i) const {return n<i.n;}
944 class NodeIt : public Node {
945 friend class NodeSet;
947 NodeIt(const NodeSet& G) : Node(G.first_node) { }
948 NodeIt() : Node() { }
952 //friend class NodeSet;
953 //template <typename T> friend class EdgeMap;
955 //template <typename T> friend class SymNodeSet::SymEdgeMap;
956 //friend Edge SymNodeSet::opposite(Edge) const;
958 // friend class Node;
959 // friend class NodeIt;
961 //friend int NodeSet::id(Edge e) const;
966 bool operator==(const Edge i) const {return true;}
967 bool operator!=(const Edge i) const {return false;}
968 bool operator<(const Edge i) const {return false;}
969 ///\bug This is a workaround until somebody tells me how to
970 ///make class \c SymNodeSet::SymEdgeMap friend of Edge
971 // int idref() {return -1;}
972 // int idref() const {return -1;}
975 class EdgeIt : public Edge {
976 //friend class NodeSet;
978 EdgeIt(const NodeSet& G) : Edge() { }
979 EdgeIt (Invalid i) : Edge(i) { }
980 EdgeIt() : Edge() { }
981 ///\bug This is a workaround until somebody tells me how to
982 ///make class \c SymNodeSet::SymEdgeMap friend of Edge
983 // int idref() {return -1;}
986 class OutEdgeIt : public Edge {
987 friend class NodeSet;
989 OutEdgeIt() : Edge() { }
990 OutEdgeIt (Invalid i) : Edge(i) { }
991 OutEdgeIt(const NodeSet& G,const Node v) : Edge() {}
994 class InEdgeIt : public Edge {
995 friend class NodeSet;
997 InEdgeIt() : Edge() { }
998 InEdgeIt (Invalid i) : Edge(i) { }
999 InEdgeIt(const NodeSet& G,Node v) :Edge() {}
1002 template <typename T> class NodeMap : public DynMapBase<Node>
1004 std::vector<T> container;
1007 typedef T ValueType;
1008 typedef Node KeyType;
1010 NodeMap(const NodeSet &_G) :
1011 DynMapBase<Node>(_G), container(_G.maxNodeId())
1013 G->dyn_node_maps.push_back(this);
1015 NodeMap(const NodeSet &_G,const T &t) :
1016 DynMapBase<Node>(_G), container(_G.maxNodeId(),t)
1018 G->dyn_node_maps.push_back(this);
1021 NodeMap(const NodeMap<T> &m) :
1022 DynMapBase<Node>(*m.G), container(m.container)
1024 G->dyn_node_maps.push_back(this);
1027 template<typename TT> friend class NodeMap;
1029 ///\todo It can copy between different types.
1031 template<typename TT> NodeMap(const NodeMap<TT> &m) :
1032 DynMapBase<Node>(*m.G)
1034 G->dyn_node_maps.push_back(this);
1035 typename std::vector<TT>::const_iterator i;
1036 for(typename std::vector<TT>::const_iterator i=m.container.begin();
1037 i!=m.container.end();
1039 container.push_back(*i);
1044 std::vector<DynMapBase<Node>* >::iterator i;
1045 for(i=G->dyn_node_maps.begin();
1046 i!=G->dyn_node_maps.end() && *i!=this; ++i) ;
1047 //if(*i==this) G->dyn_node_maps.erase(i); //FIXME: Way too slow...
1048 //A better way to do that: (Is this really important?)
1050 *i=G->dyn_node_maps.back();
1051 G->dyn_node_maps.pop_back();
1056 void add(const Node k)
1058 if(k.n>=int(container.size())) container.resize(k.n+1);
1061 void erase(const Node) { }
1063 void set(Node n, T a) { container[n.n]=a; }
1064 //'T& operator[](Node n)' would be wrong here
1065 typename std::vector<T>::reference
1066 operator[](Node n) { return container[n.n]; }
1067 //'const T& operator[](Node n)' would be wrong here
1068 typename std::vector<T>::const_reference
1069 operator[](Node n) const { return container[n.n]; }
1071 ///\warning There is no safety check at all!
1072 ///Using operator = between maps attached to different graph may
1073 ///cause serious problem.
1074 ///\todo Is this really so?
1075 ///\todo It can copy between different types.
1076 const NodeMap<T>& operator=(const NodeMap<T> &m)
1078 container = m.container;
1081 template<typename TT>
1082 const NodeMap<T>& operator=(const NodeMap<TT> &m)
1084 copy(m.container.begin(), m.container.end(), container.begin());
1088 void update() {} //Useless for Dynamic Maps
1089 void update(T a) {} //Useless for Dynamic Maps
1092 template <typename T> class EdgeMap
1095 typedef T ValueType;
1096 typedef Edge KeyType;
1098 EdgeMap(const NodeSet &) { }
1099 EdgeMap(const NodeSet &,const T &) { }
1100 EdgeMap(const EdgeMap<T> &) { }
1101 // template<typename TT> friend class EdgeMap;
1103 ///\todo It can copy between different types.
1105 template<typename TT> EdgeMap(const EdgeMap<TT> &) { }
1108 void add(const Edge ) { }
1109 void erase(const Edge) { }
1111 void set(Edge, T) { }
1112 //T get(Edge n) const { return container[n.n]; }
1113 ValueType &operator[](Edge) { return *((T*)(NULL)); }
1114 const ValueType &operator[](Edge) const { return *((T*)(NULL)); }
1116 const EdgeMap<T>& operator=(const EdgeMap<T> &) { return *this; }
1118 template<typename TT>
1119 const EdgeMap<T>& operator=(const EdgeMap<TT> &m) { return *this; }
1128 ///Graph structure using a node set of another graph.
1130 ///This structure can be used to establish another graph over a node set
1131 /// of an existing one. The node iterator will go through the nodes of the
1132 /// original graph, and the NodeMap's of both graphs will convert to
1135 ///\warning Adding or deleting nodes from the graph is not safe if an
1136 ///\ref EdgeSet is currently attached to it!
1138 ///\todo Make it possible to add/delete edges from the base graph
1139 ///(and from \ref EdgeSet, as well)
1141 ///\param GG The type of the graph which shares its node set with this class.
1142 ///Its interface must conform with \ref GraphSkeleton.
1144 ///It conforms to the graph interface documented under
1145 ///the description of \ref GraphSkeleton.
1146 ///\sa \ref GraphSkeleton.
1147 ///\sa \ref NodeSet.
1148 template<typename GG>
1151 typedef GG NodeGraphType;
1157 //Edges are double linked.
1158 //The free edges are only single linked using the "next_in" field.
1161 int first_in,first_out;
1162 NodeT() : first_in(-1), first_out(-1) { }
1168 int prev_in, prev_out;
1169 int next_in, next_out;
1173 typename NodeGraphType::NodeMap<NodeT> nodes;
1175 std::vector<EdgeT> edges;
1176 //The first free edge
1177 int first_free_edge;
1181 template <typename Key> class DynMapBase
1186 virtual void add(const Key k) = NULL;
1187 virtual void erase(const Key k) = NULL;
1188 DynMapBase(const EdgeSet &_G) : G(&_G) {}
1189 virtual ~DynMapBase() {}
1190 friend class EdgeSet;
1194 //template <typename T> class NodeMap;
1195 template <typename T> class EdgeMap;
1203 // mutable std::vector<DynMapBase<Node> * > dyn_node_maps;
1204 ///\bug It must be public because of SymEdgeMap.
1206 mutable std::vector<DynMapBase<Edge> * > dyn_edge_maps;
1215 template <typename T> class NodeMap;
1216 template <typename T> class EdgeMap;
1222 ///Construates a new graph based on the nodeset of an existing one.
1223 ///\param _G the base graph.
1224 ///\todo It looks like a copy constructor, but it isn't.
1225 EdgeSet(NodeGraphType &_G) : G(_G),
1227 first_free_edge(-1) { }
1230 ///Makes a copy of an EdgeSet.
1231 ///It will be based on the same graph.
1232 EdgeSet(const EdgeSet &_g) : G(_g.G), nodes(_g.G), edges(_g.edges),
1233 first_free_edge(_g.first_free_edge) { }
1237 // for(std::vector<DynMapBase<Node> * >::iterator i=dyn_node_maps.begin();
1238 // i!=dyn_node_maps.end(); ++i) (**i).G=NULL;
1239 for(typename std::vector<DynMapBase<Edge> * >::iterator
1240 i=dyn_edge_maps.begin();
1241 i!=dyn_edge_maps.end(); ++i) (**i).G=NULL;
1244 int nodeNum() const { return G.nodeNum(); } //FIXME: What is this?
1245 int edgeNum() const { return edges.size(); } //FIXME: What is this?
1247 ///\bug This function does something different than
1248 ///its name would suggests...
1249 int maxNodeId() const { return G.maxNodeId(); } //FIXME: What is this?
1250 ///\bug This function does something different than
1251 ///its name would suggests...
1252 int maxEdgeId() const { return edges.size(); } //FIXME: What is this?
1254 Node tail(Edge e) const { return edges[e.n].tail; }
1255 Node head(Edge e) const { return edges[e.n].head; }
1257 Node aNode(OutEdgeIt e) const { return edges[e.n].tail; }
1258 Node aNode(InEdgeIt e) const { return edges[e.n].head; }
1260 Node bNode(OutEdgeIt e) const { return edges[e.n].head; }
1261 Node bNode(InEdgeIt e) const { return edges[e.n].tail; }
1263 NodeIt& first(NodeIt& v) const {
1264 v=NodeIt(*this); return v; }
1265 EdgeIt& first(EdgeIt& e) const {
1266 e=EdgeIt(*this); return e; }
1267 OutEdgeIt& first(OutEdgeIt& e, const Node v) const {
1268 e=OutEdgeIt(*this,v); return e; }
1269 InEdgeIt& first(InEdgeIt& e, const Node v) const {
1270 e=InEdgeIt(*this,v); return e; }
1272 // template< typename It >
1273 // It first() const { It e; first(e); return e; }
1275 // template< typename It >
1276 // It first(Node v) const { It e; first(e,v); return e; }
1278 bool valid(Edge e) const { return e.n!=-1; }
1279 bool valid(Node n) const { return G.valid(n); }
1281 void setInvalid(Edge &e) { e.n=-1; }
1282 void setInvalid(Node &n) { G.setInvalid(n); }
1284 template <typename It> It getNext(It it) const
1285 { It tmp(it); return next(tmp); }
1287 NodeIt& next(NodeIt& it) const { G.next(it); return it; }
1288 OutEdgeIt& next(OutEdgeIt& it) const
1289 { it.n=edges[it.n].next_out; return it; }
1290 InEdgeIt& next(InEdgeIt& it) const
1291 { it.n=edges[it.n].next_in; return it; }
1292 EdgeIt& next(EdgeIt& it) const {
1293 if(edges[it.n].next_in!=-1) {
1294 it.n=edges[it.n].next_in;
1297 typename NodeGraphType::Node n;
1298 for(n=G.next(edges[it.n].head);
1299 G.valid(n) && nodes[n].first_in == -1;
1301 it.n = (G.valid(n))?-1:nodes[n].first_in;
1306 int id(Node v) const { return G.id(v); }
1307 int id(Edge e) const { return e.n; }
1309 /// Adds a new node to the graph.
1310 Node addNode() { return G.AddNode(); }
1312 Edge addEdge(Node u, Node v) {
1315 if(first_free_edge==-1)
1318 edges.push_back(EdgeT());
1321 n = first_free_edge;
1322 first_free_edge = edges[n].next_in;
1325 edges[n].tail = u; edges[n].head = v;
1327 edges[n].next_out = nodes[u].first_out;
1328 if(nodes[u].first_out != -1) edges[nodes[u].first_out].prev_out = n;
1329 edges[n].next_in = nodes[v].first_in;
1330 if(nodes[v].first_in != -1) edges[nodes[v].first_in].prev_in = n;
1331 edges[n].prev_in = edges[n].prev_out = -1;
1333 nodes[u].first_out = nodes[v].first_in = n;
1337 //Update dynamic maps
1338 for(typename std::vector<DynMapBase<Edge> * >::iterator
1339 i=dyn_edge_maps.begin();
1340 i!=dyn_edge_maps.end(); ++i) (**i).add(e);
1346 void eraseEdge(int n) {
1348 if(edges[n].next_in!=-1)
1349 edges[edges[n].next_in].prev_in = edges[n].prev_in;
1350 if(edges[n].prev_in!=-1)
1351 edges[edges[n].prev_in].next_in = edges[n].next_in;
1352 else nodes[edges[n].head].first_in = edges[n].next_in;
1354 if(edges[n].next_out!=-1)
1355 edges[edges[n].next_out].prev_out = edges[n].prev_out;
1356 if(edges[n].prev_out!=-1)
1357 edges[edges[n].prev_out].next_out = edges[n].next_out;
1358 else nodes[edges[n].tail].first_out = edges[n].next_out;
1360 edges[n].next_in = first_free_edge;
1361 first_free_edge = -1;
1363 //Update dynamic maps
1365 for(typename std::vector<DynMapBase<Edge> * >::iterator
1366 i=dyn_edge_maps.begin();
1367 i!=dyn_edge_maps.end(); ++i) (**i).erase(e);
1372 // void erase(Node nn) {
1375 // while((m=nodes[n].first_in)!=-1) eraseEdge(m);
1376 // while((m=nodes[n].first_out)!=-1) eraseEdge(m);
1379 void erase(Edge e) { eraseEdge(e.n); }
1381 // //\bug Dynamic maps must be updated!
1384 // nodes.clear();edges.clear();
1385 // first_node=first_free_node=first_free_edge=-1;
1388 class Node : public NodeGraphType::Node {
1389 friend class EdgeSet;
1390 // template <typename T> friend class NodeMap;
1393 friend class OutEdgeIt;
1394 friend class InEdgeIt;
1395 friend class SymEdge;
1398 friend int EdgeSet::id(Node v) const;
1399 // Node(int nn) {n=nn;}
1401 Node() : NodeGraphType::Node() {}
1402 Node (Invalid i) : NodeGraphType::Node(i) {}
1403 Node(const typename NodeGraphType::Node &n) : NodeGraphType::Node(n) {}
1406 class NodeIt : public NodeGraphType::NodeIt {
1407 friend class EdgeSet;
1409 NodeIt() : NodeGraphType::NodeIt() { }
1410 NodeIt (Invalid i) : NodeGraphType::NodeIt(i) {}
1411 NodeIt(const EdgeSet& _G) : NodeGraphType::NodeIt(_G.G) { }
1412 NodeIt(const typename NodeGraphType::NodeIt &n)
1413 : NodeGraphType::NodeIt(n) {}
1414 operator Node() { return Node(*this);}
1418 friend class EdgeSet;
1419 template <typename T> friend class EdgeMap;
1421 //template <typename T> friend class SymEdgeSet::SymEdgeMap;
1422 //friend Edge SymEdgeSet::opposite(Edge) const;
1425 friend class NodeIt;
1428 friend int EdgeSet::id(Edge e) const;
1430 Edge(int nn) {n=nn;}
1433 Edge (Invalid) { n=-1; }
1434 bool operator==(const Edge i) const {return n==i.n;}
1435 bool operator!=(const Edge i) const {return n!=i.n;}
1436 bool operator<(const Edge i) const {return n<i.n;}
1437 ///\bug This is a workaround until somebody tells me how to
1438 ///make class \c SymEdgeSet::SymEdgeMap friend of Edge
1439 int &idref() {return n;}
1440 const int &idref() const {return n;}
1443 class EdgeIt : public Edge {
1444 friend class EdgeSet;
1446 EdgeIt(const EdgeSet& G) : Edge() {
1447 typename NodeGraphType::Node m;
1449 G.valid(m) && nodes[m].first_in == -1; G.next[m]);
1450 n = G.valid(m)?-1:nodes[m].first_in;
1452 EdgeIt (Invalid i) : Edge(i) { }
1453 EdgeIt() : Edge() { }
1454 ///\bug This is a workaround until somebody tells me how to
1455 ///make class \c SymEdgeSet::SymEdgeMap friend of Edge
1456 int &idref() {return n;}
1459 class OutEdgeIt : public Edge {
1460 friend class EdgeSet;
1462 OutEdgeIt() : Edge() { }
1463 OutEdgeIt (Invalid i) : Edge(i) { }
1465 OutEdgeIt(const EdgeSet& G,const Node v) : Edge(nodes[v].first_out) { }
1468 class InEdgeIt : public Edge {
1469 friend class EdgeSet;
1471 InEdgeIt() : Edge() { }
1472 InEdgeIt (Invalid i) : Edge(i) { }
1473 InEdgeIt(const EdgeSet& G,Node v) :Edge(nodes[v].first_in) { }
1476 template <typename T> class NodeMap : public NodeGraphType::NodeMap<T>
1479 NodeMap(const EdgeSet &_G) :
1480 NodeGraphType::NodeMap<T>(_G.G) { }
1481 NodeMap(const EdgeSet &_G,const T &t) :
1482 NodeGraphType::NodeMap<T>(_G.G,t) { }
1484 NodeMap(const typename NodeGraphType::NodeMap<T> &m)
1485 : NodeGraphType::NodeMap<T>(m) { }
1487 ///\todo It can copy between different types.
1489 template<typename TT>
1490 NodeMap(const typename NodeGraphType::NodeMap<TT> &m)
1491 : NodeGraphType::NodeMap<T>(m) { }
1494 template <typename T> class EdgeMap : public DynMapBase<Edge>
1496 std::vector<T> container;
1499 typedef T ValueType;
1500 typedef Edge KeyType;
1502 EdgeMap(const EdgeSet &_G) :
1503 DynMapBase<Edge>(_G), container(_G.maxEdgeId())
1505 //FIXME: What if there are empty Id's?
1506 //FIXME: Can I use 'this' in a constructor?
1507 G->dyn_edge_maps.push_back(this);
1509 EdgeMap(const EdgeSet &_G,const T &t) :
1510 DynMapBase<Edge>(_G), container(_G.maxEdgeId(),t)
1512 G->dyn_edge_maps.push_back(this);
1514 EdgeMap(const EdgeMap<T> &m) :
1515 DynMapBase<Edge>(*m.G), container(m.container)
1517 G->dyn_node_maps.push_back(this);
1520 template<typename TT> friend class EdgeMap;
1522 ///\todo It can copy between different types.
1524 template<typename TT> EdgeMap(const EdgeMap<TT> &m) :
1525 DynMapBase<Edge>(*m.G)
1527 G->dyn_node_maps.push_back(this);
1528 typename std::vector<TT>::const_iterator i;
1529 for(typename std::vector<TT>::const_iterator i=m.container.begin();
1530 i!=m.container.end();
1532 container.push_back(*i);
1537 typename std::vector<DynMapBase<Edge>* >::iterator i;
1538 for(i=G->dyn_edge_maps.begin();
1539 i!=G->dyn_edge_maps.end() && *i!=this; ++i) ;
1540 //if(*i==this) G->dyn_edge_maps.erase(i); //Way too slow...
1541 //A better way to do that: (Is this really important?)
1543 *i=G->dyn_edge_maps.back();
1544 G->dyn_edge_maps.pop_back();
1549 void add(const Edge k)
1551 if(k.n>=int(container.size())) container.resize(k.n+1);
1553 void erase(const Edge) { }
1555 void set(Edge n, T a) { container[n.n]=a; }
1556 //T get(Edge n) const { return container[n.n]; }
1557 typename std::vector<T>::reference
1558 operator[](Edge n) { return container[n.n]; }
1559 typename std::vector<T>::const_reference
1560 operator[](Edge n) const { return container[n.n]; }
1562 ///\warning There is no safety check at all!
1563 ///Using operator = between maps attached to different graph may
1564 ///cause serious problem.
1565 ///\todo Is this really so?
1566 ///\todo It can copy between different types.
1567 const EdgeMap<T>& operator=(const EdgeMap<T> &m)
1569 container = m.container;
1572 template<typename TT>
1573 const EdgeMap<T>& operator=(const EdgeMap<TT> &m)
1575 copy(m.container.begin(), m.container.end(), container.begin());
1579 void update() {} //Useless for DynMaps
1580 void update(T a) {} //Useless for DynMaps
1589 #endif //HUGO_LIST_GRAPH_H