lemon-0.x: comparison src/hugo/list

equal deleted inserted replaced

-:881ca2541925
+:90202268e2c4
 class NodeIt;
 class EdgeIt;
 class OutEdgeIt;
 class InEdgeIt;
-template <typename T> class NodeMap;
-template <typename T> class EdgeMap;
 public:
 ListGraph() : nodes(), first_node(-1),
 		  first_free_node(-1), edges(), first_free_edge(-1) {}
 ListGraph(const ListGraph &_g) : nodes(_g.nodes), first_node(_g.first_node),
 friend class ListGraph;
 public:
 NodeIt() : Node() { }
 NodeIt(Invalid i) : Node(i) { }
 NodeIt(const ListGraph& G) : Node(G.first_node) { }
+///\todo Undocumented conversion Node -\> NodeIt.
+NodeIt(const ListGraph& G, const Node &n) : Node(n) { }
 };
 class Edge {
 friend class ListGraph;
 template <typename T> friend class EdgeMap;
 void update(T a) {}  //Useless for Dynamic Maps
 };
 template <typename T> class EdgeMap : public DynMapBase<Edge>
 {
+protected:
 std::vector<T> container;
 public:
 typedef T ValueType;
 typedef Edge KeyType;
 };
 class NodeIt : public Node {
 friend class NodeSet;
 public:
+NodeIt() : Node() { }
+NodeIt(Invalid i) : Node(i) { }
 NodeIt(const NodeSet& G) : Node(G.first_node) { }
-NodeIt() : Node() { }
+///\todo Undocumented conversion Node -\> NodeIt.
+NodeIt(const NodeSet& G, const Node &n) : Node(n) { }
 };
 class Edge {
 //friend class NodeSet;
 //template <typename T> friend class EdgeMap;
 NodeIt() : NodeGraphType::NodeIt() { }
 NodeIt (Invalid i) : NodeGraphType::NodeIt(i) {}
 NodeIt(const EdgeSet& _G) : NodeGraphType::NodeIt(_G.G) { }
 NodeIt(const typename NodeGraphType::NodeIt &n)
 	: NodeGraphType::NodeIt(n) {}
+///\todo Undocumented conversion Node -\> NodeIt.
+NodeIt(const EdgeSet& _G, const Node &n)
+	: NodeGraphType::NodeIt(_G.G,n) { }
 operator Node() { return Node(*this);}
 };
 private:
 //Edges are double linked.
 EdgeIt& next(EdgeIt& it) const {
 if(edges[it.n].next_in!=-1) {
 	it.n=edges[it.n].next_in;
 }
 else {
-	NodeIt n;
+	NodeIt n(*this,edges[it.n].head);
-	for(n=next(edges[it.n].head);
+	for(n=next(n);
 	    valid(n) && nodes[n].first_in == -1;
 	    next(n)) ;
 	it.n = (valid(n))?-1:nodes[n].first_in;
 }
 return it;
 }
 int id(Edge e) const { return e.n; }
 /// Adds a new node to the graph.
-Node addNode() { return G.AddNode(); }
+Node addNode() { return G.addNode(); }
 Edge addEdge(Node u, Node v) {
 int n;
 if(first_free_edge==-1)
 //       while((m=nodes[n].first_out)!=-1) eraseEdge(m);
 //     }
 void erase(Edge e) { eraseEdge(e.n); }
+///Clear all edges. (Doesn't clear the nodes!)
+void clear() {
+edges.clear();
+first_free_edge=-1;
+}
 //     //\bug Dynamic maps must be updated!
 //     //
 //     void clear() {
 //       nodes.clear();edges.clear();
 //       first_node=first_free_node=first_free_edge=-1;
 //     }
+public:
+template <typename T> class EdgeMap;
+///
 class Edge {
+public:
 friend class EdgeSet;
 template <typename T> friend class EdgeMap;
-//template <typename T> friend class SymEdgeSet::SymEdgeMap;
-//friend Edge SymEdgeSet::opposite(Edge) const;
 friend class Node;
 friend class NodeIt;
+public:
+///\bug It shoud be at least protected
+///
+int n;
 protected:
-int n;
 friend int EdgeSet::id(Edge e) const;
 Edge(int nn) {n=nn;}
 public:
 Edge() { }
 const int &idref() const {return n;}
 };
 class EdgeIt : public Edge {
 friend class EdgeSet;
+template <typename T> friend class EdgeMap;
 public:
 EdgeIt(const EdgeSet& G) : Edge() {
 	//      	typename NodeGraphType::Node m;
 NodeIt m;
 	for(G.first(m);
 friend class EdgeSet;
 public:
 OutEdgeIt() : Edge() { }
 OutEdgeIt (Invalid i) : Edge(i) { }
-OutEdgeIt(const EdgeSet& G,const Node v) : Edge(nodes[v].first_out) { }
+OutEdgeIt(const EdgeSet& G,const Node v) : Edge(G.nodes[v].first_out) { }
 };
 class InEdgeIt : public Edge {
 friend class EdgeSet;
 public:
 InEdgeIt() : Edge() { }
 InEdgeIt (Invalid i) : Edge(i) { }
-InEdgeIt(const EdgeSet& G,Node v) :Edge(nodes[v].first_in) { }
+InEdgeIt(const EdgeSet& G,Node v) :Edge(G.nodes[v].first_in) { }
 };
 template <typename T> class NodeMap :
 public NodeGraphType::template NodeMap<T>
 {
-public:
+//This is a must, the constructors need it.
-NodeMap(const EdgeSet &_G) :
+typedef typename NodeGraphType::template NodeMap<T> ParentNodeMap;
-NodeGraphType::NodeMap(_G.G) { } //AJAJJ <T> would be wrong!!!
+public:
-NodeMap(const EdgeSet &_G,const T &t) :
+NodeMap(const EdgeSet &_G) : ParentNodeMap(_G.G) { }
-	NodeGraphType::NodeMap(_G.G,t) { }
+NodeMap(const EdgeSet &_G,const T &t) : ParentNodeMap(_G.G,t) { }
 //It is unnecessary
 NodeMap(const typename NodeGraphType::template NodeMap<T> &m) :
-	NodeGraphType::NodeMap(m) { }
+	ParentNodeMap(m) { }
 ///\todo It can copy between different types.
 ///
 template<typename TT>
 NodeMap(const typename NodeGraphType::template NodeMap<TT> &m)
-	: NodeGraphType::NodeMap(m) { }
+	: ParentNodeMap(m) { }
 };
+///
 template <typename T> class EdgeMap : public DynMapBase<Edge>
 {
+protected:
+public:
+///\bug It should be at least protected
+///
 std::vector<T> container;
 public:
 typedef T ValueType;
 typedef Edge KeyType;
 {
 	if(k.n>=int(container.size())) container.resize(k.n+1);
 }
 void erase(const Edge) { }
-void set(Edge n, T a) { container[n.n]=a; }
+///\bug This doesn't work. Why?
+///      void set(Edge n, T a) { container[n.n]=a; }
+void set(Edge n, T a) { container[G->id(n)]=a; }
 //T get(Edge n) const { return container[n.n]; }
 typename std::vector<T>::reference
-operator[](Edge n) { return container[n.n]; }
+///\bug This doesn't work. Why?
+///      operator[](Edge n) { return container[n.n]; }
+operator[](Edge n) { return container[G->id(n)]; }
 typename std::vector<T>::const_reference
-operator[](Edge n) const { return container[n.n]; }
+///\bug This doesn't work. Why?
+///      operator[](Edge n) const { return container[n.n]; }
+operator[](Edge n) const { return container[G->id(n)]; }
 ///\warning There is no safety check at all!
 ///Using operator = between maps attached to different graph may
 ///cause serious problem.
 ///\todo Is this really so?
 const EdgeMap<T>& operator=(const EdgeMap<T> &m)
 {
 	container = m.container;
 	return *this;
 }
+template<typename TT> friend class EdgeMap;
 template<typename TT>
 const EdgeMap<T>& operator=(const EdgeMap<TT> &m)
 {
 	std::copy(m.container.begin(), m.container.end(), container.begin());
 	return *this;
 void update(T a) {}  //Useless for DynMaps
 };
 };
-template< typename GG>
+template<typename GG>
-int EdgeSet<GG>::id(Node v) const { return G.id(v); }
+inline int EdgeSet<GG>::id(Node v) const { return G.id(v); }
 /// @}
 } //namespace hugo

changeset 579	859f8c7e2a40
parent 578	159f1cbf8a45
child 590	5c1465127b79