Index: lemon/concepts/bpgraph.h
===================================================================
--- lemon/concepts/bpgraph.h	(revision 1336)
+++ lemon/concepts/bpgraph.h	(revision 1270)
@@ -28,5 +28,4 @@
 #include <lemon/concept_check.h>
 #include <lemon/core.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -223,20 +222,4 @@
       };
 
-      /// \brief Gets the collection of the red nodes of the graph.
-      ///
-      /// This function can be used for iterating on
-      /// the red nodes of the graph. It returns a wrapped RedNodeIt,
-      /// which looks like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph, you can write:
-      ///\code
-      /// for(auto v: g.redNodes())
-      ///   doSomething(v);
-      ///\endcode
-      LemonRangeWrapper1<RedNodeIt, BpGraph> redNodes() const {
-        return LemonRangeWrapper1<RedNodeIt, BpGraph>(*this);
-      }
-
-
       /// Iterator class for the blue nodes.
 
@@ -282,20 +265,4 @@
       };
 
-      /// \brief Gets the collection of the blue nodes of the graph.
-      ///
-      /// This function can be used for iterating on
-      /// the blue nodes of the graph. It returns a wrapped BlueNodeIt,
-      /// which looks like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph, you can write:
-      ///\code
-      /// for(auto v: g.blueNodes())
-      ///   doSomething(v);
-      ///\endcode
-      LemonRangeWrapper1<BlueNodeIt, BpGraph> blueNodes() const {
-        return LemonRangeWrapper1<BlueNodeIt, BpGraph>(*this);
-      }
-
-
       /// Iterator class for the nodes.
 
@@ -341,20 +308,4 @@
       };
 
-      /// \brief Gets the collection of the nodes of the graph.
-      ///
-      /// This function can be used for iterating on
-      /// the nodes of the graph. It returns a wrapped NodeIt,
-      /// which looks like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph, you can write:
-      ///\code
-      /// for(auto v: g.nodes())
-      ///   doSomething(v);
-      ///\endcode
-      LemonRangeWrapper1<NodeIt, BpGraph> nodes() const {
-        return LemonRangeWrapper1<NodeIt, BpGraph>(*this);
-      }
-
-
 
       /// The edge type of the graph
@@ -445,21 +396,4 @@
       };
 
-      /// \brief Gets the collection of the edges of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// edges of the graph. It returns a wrapped
-      /// EdgeIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph, you can write:
-      ///\code
-      /// for(auto e: g.edges())
-      ///   doSomething(e);
-      ///\endcode
-      LemonRangeWrapper1<EdgeIt, BpGraph> edges() const {
-        return LemonRangeWrapper1<EdgeIt, BpGraph>(*this);
-      }
-
-
       /// Iterator class for the incident edges of a node.
 
@@ -509,23 +443,4 @@
         IncEdgeIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the incident edges
-      ///  of a certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// incident undirected edges of a certain node of the graph.
-      /// It returns a wrapped
-      /// IncEdgeIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph and u is a Node, you can write:
-      ///\code
-      /// for(auto e: g.incEdges(u))
-      ///   doSomething(e);
-      ///\endcode
-      LemonRangeWrapper2<IncEdgeIt, BpGraph, Node> incEdges(const Node& u) const {
-        return LemonRangeWrapper2<IncEdgeIt, BpGraph, Node>(*this, u);
-      }
-
 
       /// The arc type of the graph
@@ -624,21 +539,4 @@
         ArcIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the directed arcs of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the graph. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph you can write:
-      ///\code
-      /// for(auto a: g.arcs())
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, BpGraph> arcs() const {
-        return LemonRangeWrapper1<ArcIt, BpGraph>(*this);
-      }
-
 
       /// Iterator class for the outgoing arcs of a node.
@@ -690,22 +588,4 @@
       };
 
-      /// \brief Gets the collection of the outgoing directed arcs of a
-      /// certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// outgoing arcs of a certain node of the graph. It returns a wrapped
-      /// OutArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph and u is a Node, you can write:
-      ///\code
-      /// for(auto a: g.outArcs(u))
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper2<OutArcIt, BpGraph, Node> outArcs(const Node& u) const {
-        return LemonRangeWrapper2<OutArcIt, BpGraph, Node>(*this, u);
-      }
-
-
       /// Iterator class for the incoming arcs of a node.
 
@@ -756,22 +636,4 @@
       };
 
-      /// \brief Gets the collection of the incoming directed arcs of a
-      /// certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// incoming arcs of a certain node of the graph. It returns a wrapped
-      /// InArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph and u is a Node, you can write:
-      ///\code
-      /// for(auto a: g.inArcs(u))
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper2<InArcIt, BpGraph, Node> inArcs(const Node& u) const {
-        return LemonRangeWrapper2<InArcIt, BpGraph, Node>(*this, u);
-      }
-
-
       /// \brief Standard graph map type for the nodes.
       ///
Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h	(revision 1336)
+++ lemon/concepts/digraph.h	(revision 1271)
@@ -28,5 +28,4 @@
 #include <lemon/concept_check.h>
 #include <lemon/concepts/graph_components.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -149,23 +148,4 @@
       };
 
-      /// \brief Gets the collection of the nodes of the digraph.
-      ///
-      /// This function can be used for iterating on
-      /// the nodes of the digraph. It returns a wrapped NodeIt, which looks
-      /// like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListDigraph g;
-      /// for(auto v: g.nodes())
-      ///   doSomething(v);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.nodes().begin(), g.nodes().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
-        return LemonRangeWrapper1<NodeIt, Digraph>(*this);
-      }
-
 
       /// The arc type of the digraph
@@ -258,25 +238,4 @@
       };
 
-      /// \brief Gets the collection of the outgoing arcs of a certain node
-      /// of the digraph.
-      ///
-      /// This function can be used for iterating on the
-      /// outgoing arcs of a certain node of the digraph. It returns a wrapped
-      /// OutArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Digraph and u is a node, you can write:
-      ///\code
-      /// for(auto a: g.outArcs(u))
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.outArcs(u).begin(), g.outArcs(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
-        return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
-      }
-
-
       /// Iterator class for the incoming arcs of a node.
 
@@ -324,25 +283,4 @@
       };
 
-      /// \brief Gets the collection of the incoming arcs of a certain node
-      /// of the digraph.
-      ///
-      /// This function can be used for iterating on the
-      /// incoming arcs of a certain node of the digraph. It returns a wrapped
-      /// InArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Digraph and u is a node, you can write:
-      ///\code
-      /// for(auto a: g.inArcs(u))
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.inArcs(u).begin(), g.inArcs(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
-        return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
-      }
-
-
       /// Iterator class for the arcs.
 
@@ -389,25 +327,4 @@
         ArcIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the arcs of the digraph.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the digraph. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListDigraph g;
-      /// for(auto a: g.arcs())
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.arcs().begin(), g.arcs().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
-        return LemonRangeWrapper1<ArcIt, Digraph>(*this);
-      }
-
 
       /// \brief The source node of the arc.
Index: lemon/concepts/graph.h
===================================================================
--- lemon/concepts/graph.h	(revision 1336)
+++ lemon/concepts/graph.h	(revision 1271)
@@ -28,5 +28,4 @@
 #include <lemon/concept_check.h>
 #include <lemon/core.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -182,23 +181,4 @@
       };
 
-      /// \brief Gets the collection of the nodes of the graph.
-      ///
-      /// This function can be used for iterating on
-      /// the nodes of the graph. It returns a wrapped NodeIt, which looks
-      /// like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListGraph g;
-      /// for(auto v: g.nodes())
-      ///   doSomething(v);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.nodes().begin(), g.nodes().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<NodeIt, Graph> nodes() const {
-        return LemonRangeWrapper1<NodeIt, Graph>(*this);
-      }
-
 
       /// The edge type of the graph
@@ -289,25 +269,4 @@
       };
 
-      /// \brief Gets the collection of the edges of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// edges of the graph. It returns a wrapped
-      /// EdgeIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListGraph g;
-      /// for(auto e: g.edges())
-      ///   doSomething(e);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.edges().begin(), g.edges().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<EdgeIt, Graph> edges() const {
-        return LemonRangeWrapper1<EdgeIt, Graph>(*this);
-      }
-
-
       /// Iterator class for the incident edges of a node.
 
@@ -357,26 +316,4 @@
         IncEdgeIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the incident undirected edges
-      ///  of a certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// incident undirected edges of a certain node of the graph.
-      /// It returns a wrapped
-      /// IncEdgeIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Graph and u is a Node, you can write:
-      ///\code
-      /// for(auto e: g.incEdges(u))
-      ///   doSomething(e);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.incEdges(u).begin(), g.incEdges(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
-        return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
-      }
-
 
       /// The arc type of the graph
@@ -474,25 +411,4 @@
         ArcIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the directed arcs of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the graph. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListGraph g;
-      /// for(auto a: g.arcs())
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.arcs().begin(), g.arcs().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, Graph> arcs() const {
-        return LemonRangeWrapper1<ArcIt, Graph>(*this);
-      }
-
 
       /// Iterator class for the outgoing arcs of a node.
@@ -544,25 +460,4 @@
       };
 
-      /// \brief Gets the collection of the outgoing directed arcs of a
-      /// certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// outgoing arcs of a certain node of the graph. It returns a wrapped
-      /// OutArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Graph and u is a Node, you can write:
-      ///\code
-      /// for(auto a: g.outArcs(u))
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.outArcs(u).begin(), g.outArcs(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
-        return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
-      }
-
-
       /// Iterator class for the incoming arcs of a node.
 
@@ -613,24 +508,4 @@
       };
 
-      /// \brief Gets the collection of the incoming directed arcs of
-      /// a certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// incoming directed arcs of a certain node of the graph. It returns
-      /// a wrapped InArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Graph and u is a Node, you can write:
-      ///\code
-      /// for(auto a: g.inArcs(u))
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.inArcs(u).begin(), g.inArcs(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
-        return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
-      }
-
       /// \brief Standard graph map type for the nodes.
       ///
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 1270)
+++ lemon/concepts/graph_components.h	(revision 1416)
@@ -104,4 +104,5 @@
           i1=INVALID;
           _GraphItem i2 = i1;
+          ::lemon::ignore_unused_variable_warning(i2);
           _GraphItem i3 = INVALID;
 
@@ -735,4 +736,5 @@
 
           Item bi = it1;
+          ::lemon::ignore_unused_variable_warning(bi);
           bi = it2;
         }
@@ -825,4 +827,5 @@
           ++(++it1);
           Item e = it1;
+          ::lemon::ignore_unused_variable_warning(e);
           e = it2;
         }
Index: lemon/concepts/path.h
===================================================================
--- lemon/concepts/path.h	(revision 1336)
+++ lemon/concepts/path.h	(revision 1416)
@@ -27,5 +27,4 @@
 #include <lemon/core.h>
 #include <lemon/concept_check.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -72,5 +71,7 @@
       /// \brief Template copy constructor
       template <typename CPath>
-      Path(const CPath& cpath) {}
+      Path(const CPath& cpath) {
+        ::lemon::ignore_unused_variable_warning(cpath);
+      }
 
       /// \brief Template assigment operator
@@ -117,21 +118,4 @@
       };
 
-      /// \brief Gets the collection of the arcs of the path.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the path. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// for(auto a: p.arcs())
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, Path> arcs() const {
-        return LemonRangeWrapper1<ArcIt, Path>(*this);
-      }
-
-
       template <typename _Path>
       struct Constraints {
@@ -282,21 +266,4 @@
 
       };
-
-      /// \brief Gets the collection of the arcs of the path.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the path. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// for(auto a: p.arcs())
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, PathDumper> arcs() const {
-        return LemonRangeWrapper1<ArcIt, PathDumper>(*this);
-      }
-
 
       /// \brief LEMON style iterator for enumerating the arcs of a path
@@ -329,22 +296,4 @@
       };
 
-      /// \brief Gets the collection of the arcs of the path
-      /// in reverse direction.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the path in reverse direction. It returns a wrapped
-      /// RevArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// for(auto a: p.revArcs())
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper1<RevArcIt, PathDumper> revArcs() const {
-        return LemonRangeWrapper1<RevArcIt, PathDumper>(*this);
-      }
-
-
       template <typename _Path>
       struct Constraints {
