Index: CMakeLists.txt
===================================================================
--- CMakeLists.txt	(revision 1336)
+++ CMakeLists.txt	(revision 1337)
@@ -265,6 +265,6 @@
 
 INCLUDE(CheckCXXCompilerFlag)
-CHECK_CXX_COMPILER_FLAG("-std=c++11" CXX11FLAG)
-IF(CXX11FLAG)
+CHECK_CXX_COMPILER_FLAG("-std=c++11" LEMON_CXX11)
+IF(LEMON_CXX11)
   SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 ENDIF()
Index: lemon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h	(revision 1336)
+++ lemon/bellman_ford.h	(revision 1337)
@@ -702,6 +702,6 @@
     /// which you can use in range-based for loops, STL algorithms, etc.
     LemonRangeWrapper1<ActiveIt, BellmanFord>
-        activeNodes(const BellmanFord& algorithm) const {
-      return LemonRangeWrapper1<ActiveIt, BellmanFord>(algorithm);
+    activeNodes() const {
+      return LemonRangeWrapper1<ActiveIt, BellmanFord>(*this);
     }
 
Index: lemon/bits/edge_set_extender.h
===================================================================
--- lemon/bits/edge_set_extender.h	(revision 1270)
+++ lemon/bits/edge_set_extender.h	(revision 1337)
@@ -114,4 +114,7 @@
     };
 
+    LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
+      return LemonRangeWrapper1<NodeIt, Digraph>(*this);
+    }
 
     class ArcIt : public Arc {
@@ -137,4 +140,7 @@
     };
 
+    LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
+      return LemonRangeWrapper1<ArcIt, Digraph>(*this);
+    }
 
     class OutArcIt : public Arc {
@@ -161,4 +167,7 @@
     };
 
+    LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
+      return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
+    }
 
     class InArcIt : public Arc {
@@ -184,4 +193,8 @@
 
     };
+
+    LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
+      return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
+    }
 
     // \brief Base node of the iterator
@@ -373,4 +386,7 @@
     };
 
+    LemonRangeWrapper1<NodeIt, Graph> nodes() const {
+      return LemonRangeWrapper1<NodeIt, Graph>(*this);
+    }
 
     class ArcIt : public Arc {
@@ -396,4 +412,7 @@
     };
 
+    LemonRangeWrapper1<ArcIt, Graph> arcs() const {
+      return LemonRangeWrapper1<ArcIt, Graph>(*this);
+    }
 
     class OutArcIt : public Arc {
@@ -420,4 +439,7 @@
     };
 
+    LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
+      return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
+    }
 
     class InArcIt : public Arc {
@@ -444,4 +466,7 @@
     };
 
+    LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
+      return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
+    }
 
     class EdgeIt : public Parent::Edge {
@@ -466,4 +491,8 @@
 
     };
+
+    LemonRangeWrapper1<EdgeIt, Graph> edges() const {
+      return LemonRangeWrapper1<EdgeIt, Graph>(*this);
+    }
 
     class IncEdgeIt : public Parent::Edge {
@@ -491,4 +520,8 @@
       }
     };
+
+    LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
+      return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
+    }
 
     // \brief Base node of the iterator
Index: lemon/bits/graph_adaptor_extender.h
===================================================================
--- lemon/bits/graph_adaptor_extender.h	(revision 1336)
+++ lemon/bits/graph_adaptor_extender.h	(revision 1337)
@@ -86,5 +86,5 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Adaptor> nodes() {
+    LemonRangeWrapper1<NodeIt, Adaptor> nodes() const {
       return LemonRangeWrapper1<NodeIt, Adaptor>(*this);
     }
@@ -112,5 +112,5 @@
     };
 
-    LemonRangeWrapper1<ArcIt, Adaptor> arcs() {
+    LemonRangeWrapper1<ArcIt, Adaptor> arcs() const {
       return LemonRangeWrapper1<ArcIt, Adaptor>(*this);
     }
@@ -270,5 +270,5 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Adaptor> nodes() {
+    LemonRangeWrapper1<NodeIt, Adaptor> nodes() const {
       return LemonRangeWrapper1<NodeIt, Adaptor>(*this);
     }
@@ -297,5 +297,5 @@
     };
 
-    LemonRangeWrapper1<ArcIt, Adaptor> arcs() {
+    LemonRangeWrapper1<ArcIt, Adaptor> arcs() const {
       return LemonRangeWrapper1<ArcIt, Adaptor>(*this);
     }
@@ -379,5 +379,5 @@
     };
 
-    LemonRangeWrapper1<EdgeIt, Adaptor> edges() {
+    LemonRangeWrapper1<EdgeIt, Adaptor> edges() const {
       return LemonRangeWrapper1<EdgeIt, Adaptor>(*this);
     }
Index: lemon/config.h.in
===================================================================
--- lemon/config.h.in	(revision 1306)
+++ lemon/config.h.in	(revision 1337)
@@ -1,4 +1,6 @@
 #define LEMON_VERSION "@PROJECT_VERSION@"
 #cmakedefine LEMON_HAVE_LONG_LONG 1
+
+#cmakedefine LEMON_CXX11 1
 
 #cmakedefine LEMON_HAVE_LP 1
Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 1336)
+++ lemon/list_graph.h	(revision 1337)
@@ -1210,5 +1210,5 @@
     ListGraph() {}
 
-    typedef Parent::OutArcIt IncEdgeIt;
+    typedef Parent::IncEdgeIt IncEdgeIt;
 
     /// \brief Add a new node to the graph.
@@ -2137,5 +2137,5 @@
     ListBpGraph() {}
 
-    typedef Parent::OutArcIt IncEdgeIt;
+    typedef Parent::IncEdgeIt IncEdgeIt;
 
     /// \brief Add a new red node to the graph.
Index: test/bellman_ford_test.cc
===================================================================
--- test/bellman_ford_test.cc	(revision 1270)
+++ test/bellman_ford_test.cc	(revision 1337)
@@ -102,4 +102,8 @@
 
     for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {}
+    for (auto n: const_bf_test.activeNodes()) { ::lemon::ignore_unused_variable_warning(n); }
+    for (Digraph::Node n: const_bf_test.activeNodes()) {
+      ::lemon::ignore_unused_variable_warning(n);
+    }
   }
   {
Index: test/graph_test.h
===================================================================
--- test/graph_test.h	(revision 1270)
+++ test/graph_test.h	(revision 1337)
@@ -39,4 +39,25 @@
     check(n==INVALID,"Wrong Node list linking.");
     check(countNodes(G)==cnt,"Wrong Node number.");
+
+#ifdef LEMON_CXX11
+    {
+      typename Graph::NodeIt n(G);
+      for(auto u: G.nodes())
+        {
+          check(n==u,"Wrong STL Node iterator.");
+          ++n;
+        }
+      check(n==INVALID,"Wrong STL Node iterator.");
+    }
+    {
+      typename Graph::NodeIt n(G);
+      for(typename Graph::Node u: G.nodes())
+        {
+          check(n==u,"Wrong STL Node iterator.");
+          ++n;
+        }
+      check(n==INVALID,"Wrong STL Node iterator.");
+    }
+#endif
   }
 
@@ -57,4 +78,24 @@
     check(n==INVALID,"Wrong red Node list linking.");
     check(countRedNodes(G)==cnt,"Wrong red Node number.");
+#ifdef LEMON_CXX11
+    {
+      typename Graph::RedNodeIt n(G);
+      for(auto u: G.redNodes())
+        {
+          check(n==u,"Wrong STL RedNode iterator.");
+          ++n;
+        }
+      check(n==INVALID,"Wrong STL RedNode iterator.");
+    }
+    {
+      typename Graph::RedNodeIt n(G);
+      for(typename Graph::RedNode u: G.redNodes())
+        {
+          check(n==u,"Wrong STL RedNode iterator.");
+          ++n;
+        }
+      check(n==INVALID,"Wrong STL RedNode iterator.");
+    }
+#endif
   }
 
@@ -75,4 +116,25 @@
     check(n==INVALID,"Wrong blue Node list linking.");
     check(countBlueNodes(G)==cnt,"Wrong blue Node number.");
+#ifdef LEMON_CXX11
+    {
+      typename Graph::BlueNodeIt n(G);
+      for(auto u: G.blueNodes())
+        {
+          check(n==u,"Wrong STL BlueNode iterator.");
+          ++n;
+        }
+      check(n==INVALID,"Wrong STL BlueNode iterator.");
+    }
+    {
+      typename Graph::BlueNodeIt n(G);
+      for(typename Graph::BlueNode u: G.blueNodes())
+        {
+          check(n==u,"Wrong STL BlueNode iterator.");
+          ++n;
+        }
+      check(n==INVALID,"Wrong STL BlueNode iterator.");
+    }
+#endif
+
   }
 
@@ -91,4 +153,25 @@
     check(e==INVALID,"Wrong Arc list linking.");
     check(countArcs(G)==cnt,"Wrong Arc number.");
+#ifdef LEMON_CXX11
+    {
+      typename Graph::ArcIt a(G);
+      for(auto e: G.arcs())
+        {
+          check(a==e,"Wrong STL Arc iterator.");
+          ++a;
+        }
+      check(a==INVALID,"Wrong STL Arc iterator.");
+    }
+    {
+      typename Graph::ArcIt a(G);
+      for(typename Graph::Arc e: G.arcs())
+        {
+          check(a==e,"Wrong STL Arc iterator.");
+          ++a;
+        }
+      check(a==INVALID,"Wrong STL Arc iterator.");
+    }
+#endif
+
   }
 
@@ -106,4 +189,25 @@
     check(e==INVALID,"Wrong OutArc list linking.");
     check(countOutArcs(G,n)==cnt,"Wrong OutArc number.");
+#ifdef LEMON_CXX11
+    {
+      typename Graph::OutArcIt a(G,n);
+      for(auto e: G.outArcs(n))
+        {
+          check(a==e,"Wrong STL OutArc iterator.");
+          ++a;
+        }
+      check(a==INVALID,"Wrong STL OutArc iterator.");
+    }
+    {
+      typename Graph::OutArcIt a(G,n);
+      for(typename Graph::Arc e: G.outArcs(n))
+        {
+          check(a==e,"Wrong STL OutArc iterator.");
+          ++a;
+        }
+      check(a==INVALID,"Wrong STL OutArc iterator.");
+    }
+#endif
+
   }
 
@@ -121,4 +225,24 @@
     check(e==INVALID,"Wrong InArc list linking.");
     check(countInArcs(G,n)==cnt,"Wrong InArc number.");
+#ifdef LEMON_CXX11
+    {
+      typename Graph::InArcIt a(G,n);
+      for(auto e: G.inArcs(n))
+        {
+          check(a==e,"Wrong STL InArc iterator.");
+          ++a;
+        }
+      check(a==INVALID,"Wrong STL InArc iterator.");
+    }
+    {
+      typename Graph::InArcIt a(G,n);
+      for(typename Graph::Arc e: G.inArcs(n))
+        {
+          check(a==e,"Wrong STL InArc iterator.");
+          ++a;
+        }
+      check(a==INVALID,"Wrong STL InArc iterator.");
+    }
+#endif
   }
 
@@ -135,4 +259,25 @@
     check(e==INVALID,"Wrong Edge list linking.");
     check(countEdges(G)==cnt,"Wrong Edge number.");
+#ifdef LEMON_CXX11
+    {
+      typename Graph::EdgeIt a(G);
+      for(auto e: G.edges())
+        {
+          check(a==e,"Wrong STL Edge iterator.");
+          ++a;
+        }
+      check(a==INVALID,"Wrong STL Edge iterator.");
+    }
+    {
+      typename Graph::EdgeIt a(G);
+      for(typename Graph::Edge e: G.edges())
+        {
+          check(a==e,"Wrong STL Edge iterator.");
+          ++a;
+        }
+      check(a==INVALID,"Wrong STL Edge iterator.");
+    }
+#endif
+
   }
 
@@ -151,4 +296,25 @@
     check(e==INVALID,"Wrong IncEdge list linking.");
     check(countIncEdges(G,n)==cnt,"Wrong IncEdge number.");
+#ifdef LEMON_CXX11
+    {
+      typename Graph::IncEdgeIt a(G,n);
+      for(auto e: G.incEdges(n))
+        {
+          check(a==e,"Wrong STL IncEdge iterator.");
+          ++a;
+        }
+      check(a==INVALID,"Wrong STL IncEdge iterator.");
+    }
+    {
+      typename Graph::IncEdgeIt a(G,n);
+      for(typename Graph::Edge e: G.incEdges(n))
+        {
+          check(a==e,"Wrong STL IncEdge iterator.");
+          ++a;
+        }
+      check(a==INVALID,"Wrong STL IncEdge iterator.");
+    }
+#endif
+
   }
 
Index: test/lp_test.cc
===================================================================
--- test/lp_test.cc	(revision 1300)
+++ test/lp_test.cc	(revision 1337)
@@ -21,5 +21,5 @@
 #include "test_tools.h"
 #include <lemon/tolerance.h>
-
+#include <lemon/concept_check.h>
 #include <lemon/config.h>
 
@@ -48,4 +48,9 @@
   int count=0;
   for (LpBase::ColIt c(lp); c!=INVALID; ++c) ++count;
+#ifdef LEMON_CXX11
+  int cnt = 0;
+  for(auto c: lp.cols()) { cnt++; ::lemon::ignore_unused_variable_warning(c); }
+  check(count == cnt, "Wrong STL iterator");
+#endif
   return count;
 }
@@ -54,4 +59,9 @@
   int count=0;
   for (LpBase::RowIt r(lp); r!=INVALID; ++r) ++count;
+#ifdef LEMON_CXX11
+  int cnt = 0;
+  for(auto r: lp.rows()) { cnt++; ::lemon::ignore_unused_variable_warning(r); }
+  check(count == cnt, "Wrong STL iterator");
+#endif
   return count;
 }
Index: test/maps_test.cc
===================================================================
--- test/maps_test.cc	(revision 1270)
+++ test/maps_test.cc	(revision 1337)
@@ -731,4 +731,28 @@
     check(n == 3, "Wrong number");
     check(map1.falseNum() == 3, "Wrong number");
+
+#ifdef LEMON_CXX11
+    {
+      int c = 0;
+      for(auto v: map1.items(false)) { c++; ::lemon::ignore_unused_variable_warning(v); }
+      check(c == map1.falseNum(), "Wrong number");
+    }
+    {
+      int c = 0;
+      for(auto v: map1.items(true)) { c++; ::lemon::ignore_unused_variable_warning(v); }
+      check(c == map1.trueNum(), "Wrong number");
+    }
+    {
+      int c = 0;
+      for(auto v: map1.falseKeys()) { c++; ::lemon::ignore_unused_variable_warning(v); }
+      check(c == map1.falseNum(), "Wrong number");
+    }
+    {
+      int c = 0;
+      for(auto v: map1.trueKeys()) { c++; ::lemon::ignore_unused_variable_warning(v); }
+      check(c == map1.trueNum(), "Wrong number");
+    }
+#endif
+
   }
 
@@ -781,4 +805,13 @@
     }
     check(n == num, "Wrong number");
+#ifdef LEMON_CXX11
+    {
+      int c = 0;
+      for(auto v: map1.items(0)) { c++; ::lemon::ignore_unused_variable_warning(v); }
+      check(c == (num + 1) / 2, "Wrong number");
+      for(auto v: map1.items(1)) { c++; ::lemon::ignore_unused_variable_warning(v); }
+      check(c == num, "Wrong number");
+    }
+#endif
 
   }
@@ -839,4 +872,14 @@
     }
     check(n == num, "Wrong number");
+
+#ifdef LEMON_CXX11
+    {
+      int c = 0;
+      for(auto v: map1.items(0.0)) { c++; ::lemon::ignore_unused_variable_warning(v); }
+      check(c == (num + 1) / 2, "Wrong number");
+      for(auto v: map1.items(1.0)) { c++; ::lemon::ignore_unused_variable_warning(v); }
+      check(c == num, "Wrong number");
+    }
+#endif
 
   }
