lemon-0.x: comparison src/lemon/concept/graph.h

equal deleted inserted replaced

-:688735676cae
+:6330f3c92b2d
 	NodeIt() { }
 	/// Copy constructor.
 	/// Copy constructor.
 	///
-	NodeIt(const NodeIt&) { }
+	NodeIt(const NodeIt& n) : Node(n) { }
 	/// Invalid constructor \& conversion.
 	/// Initialize the iterator to be invalid.
 	/// \sa Invalid for more details.
 	NodeIt(Invalid) { }
 	/// Sets the iterator to the first node.
 	/// Sets the iterator to the first node of \c g.
 	///
-	NodeIt(const StaticGraph& g) { }
+	NodeIt(const StaticGraph&) { }
 	/// Node -> NodeIt conversion.
 	/// Sets the iterator to the node of \c g pointed by the trivial
 	/// iterator n.
 	/// This feature necessitates that each time we
 	OutEdgeIt() { }
 	/// Copy constructor.
 	/// Copy constructor.
 	///
-	OutEdgeIt(const OutEdgeIt&) { }
+	OutEdgeIt(const OutEdgeIt& e) : Edge(e) { }
 	/// Initialize the iterator to be invalid.
 	/// Initialize the iterator to be invalid.
 	///
 	OutEdgeIt(Invalid) { }
 	/// This constructor set the iterator to the first outgoing edge of
 	/// node
 	///@param n the node
 	///@param g the graph
-	OutEdgeIt(const StaticGraph& g, const Node& n) { }
+	OutEdgeIt(const StaticGraph&, const Node&) { }
 	/// Edge -> OutEdgeIt conversion
 	/// Sets the iterator to the value of the trivial iterator \c e.
 	/// This feature necessitates that each time we
 	/// iterate the edge-set, the iteration order is the same.
 	InEdgeIt() { }
 	/// Copy constructor.
 	/// Copy constructor.
 	///
-	InEdgeIt(const InEdgeIt&) { }
+	InEdgeIt(const InEdgeIt& e) : Edge(e) { }
 	/// Initialize the iterator to be invalid.
 	/// Initialize the iterator to be invalid.
 	///
 	InEdgeIt(Invalid) { }
 	/// This constructor set the iterator to the first incoming edge of
 	/// node
 	///@param n the node
 	///@param g the graph
-	InEdgeIt(const StaticGraph& g, const Node& n) { }
+	InEdgeIt(const StaticGraph&, const Node&) { }
 	/// Edge -> InEdgeIt conversion
 	/// Sets the iterator to the value of the trivial iterator \c e.
 	/// This feature necessitates that each time we
 	/// iterate the edge-set, the iteration order is the same.
-	InEdgeIt(const StaticGraph& g, const Edge& n) { }
+	InEdgeIt(const StaticGraph&, const Edge&) { }
 	/// Next incoming edge
 	/// Assign the iterator to the next inedge of the corresponding node.
 	///
 	InEdgeIt& operator++() { return *this; }
 	EdgeIt() { }
 	/// Copy constructor.
 	/// Copy constructor.
 	///
-	EdgeIt(const EdgeIt&) { }
+	EdgeIt(const EdgeIt& e) : Edge(e) { }
 	/// Initialize the iterator to be invalid.
 	/// Initialize the iterator to be invalid.
 	///
 	EdgeIt(Invalid) { }
 	/// This constructor sets the iterator to first edge.
 	/// This constructor set the iterator to the first edge of
 	/// node
 	///@param g the graph
-	EdgeIt(const StaticGraph& g) { }
+	EdgeIt(const StaticGraph&) { }
 	/// Edge -> EdgeIt conversion
 	/// Sets the iterator to the value of the trivial iterator \c e.
 	/// This feature necessitates that each time we
 	/// iterate the edge-set, the iteration order is the same.
 	NodeMap(const StaticGraph&) { }
 	///\e
 	NodeMap(const StaticGraph&, T) { }
 	///Copy constructor
-	NodeMap(const NodeMap&) { }
+	NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
 	///Assignment operator
 	NodeMap& operator=(const NodeMap&) { return *this; }
 	// \todo fix this concept
 };
 	///\e
 	EdgeMap(const StaticGraph&) { }
 	///\e
 	EdgeMap(const StaticGraph&, T) { }
 	///Copy constructor
-	EdgeMap(const EdgeMap&) { }
+	EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) { }
 	///Assignment operator
 	EdgeMap& operator=(const EdgeMap&) { return *this; }
 	// \todo fix this concept
 };
 ///Add a new edge to the graph.
 ///Add a new edge to the graph with source node \c s
 ///and target node \c t.
 ///\return the new edge.
-Edge addEdge(Node s, Node t) { return INVALID; }
+Edge addEdge(Node, Node) { return INVALID; }
 /// Resets the graph.
 /// This function deletes all edges and nodes of the graph.
 /// It also frees the memory allocated to store them.
 ErasableGraph() { }
 /// Deletes a node.
 /// Deletes node \c n node.
 ///
-void erase(Node n) { }
+void erase(Node) { }
 /// Deletes an edge.
 /// Deletes edge \c e edge.
 ///
-void erase(Edge e) { }
+void erase(Edge) { }
 template <typename _Graph>
 struct Constraints : public _ErasableGraph::Constraints<_Graph> {};
 };

changeset 1394	f0c48d7fa73d
parent 1359	1581f961cfaa
child 1426	91eb70983697