Ticket #325: stl-iterators-be9aea8c23ae.patch

CMakeLists.txt

@@ -246 +246 @@
 
 ENABLE_TESTING()
 
+
+INCLUDE(CheckCXXCompilerFlag)
+CHECK_CXX_COMPILER_FLAG("-std=c++11" CXX11)
+IF(CXX11)
+  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+ENDIF()
+
+
 IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
   ADD_CUSTOM_TARGET(check ALL COMMAND ${CMAKE_CTEST_COMMAND})
 ELSE()

contrib/CMakeLists.txt

@@ -17 +17 @@
 # ADD_EXECUTABLE(myprog myprog-main.cc)
 # TARGET_LINK_LIBRARIES(myprog lemon)
 
+
+ADD_EXECUTABLE(stlit_test stlit_test/stlit_test.cc)
+TARGET_LINK_LIBRARIES(stlit_test lemon)
+

new file contrib/stlit_test/stlit_test.cc

@@ +1 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ */
+
+
+#include <iostream>
+#include <lemon/list_graph.h>
+#include <lemon/stl_iterators.h>
+
+
+using namespace std;
+using namespace lemon;
+
+
+/*#include <chrono>
+using namespace chrono;
+void speedTest(){
+  ListDigraph g;
+  const int n=100000;
+  for(int i=0; i<n; i++)
+    g.addNode();
+
+
+//  //for(ListDigraph::NodeIt u(g); u!=INVALID; ++u)
+//  for(auto u: g.nodeColl())
+//    cout<<g.id(u)<<endl;
+
+
+  vector<ListDigraph::Node> v(n);
+
+  for(int k=0; k<100000; k++){
+    int i=0;
+    for(ListDigraph::NodeIt u(g); u!=INVALID; ++u){
+    //for(auto u: g.nodeColl()){
+      v[i]=u;
+      i++;
+    }
+  }
+
+  cout<<g.id(v[0])<<endl;
+}*/
+
+
+int main() {
+
+  /*auto t1 = high_resolution_clock::now();
+
+  speedTest();
+
+  auto t2 = high_resolution_clock::now();
+  cout << duration_cast<milliseconds>(t2-t1).count() << " milliseconds\n";
+  return 0;
+  */
+
+
+  const int n=10;
+  ListDigraph g;
+  for(int i=0; i<n; i++)
+    g.addNode();
+
+  for(auto u: g.nodeColl())
+    cout<<g.id(u)<<endl;
+
+  //Test postincrement
+//  for(auto it=g.nodeColl().begin(); it!=g.nodeColl().end(); it++) {
+//    auto u=*it;
+//    cout<<g.id(u)<<endl;
+//  }
+
+
+
+  cout<<endl;
+
+  vector<ListDigraph::Node> v1(n);
+  copy(g.nodeColl().begin(), g.nodeColl().end(), v1.begin());
+
+  vector<ListDigraph::Node> v(g.nodeColl().begin(), g.nodeColl().end());
+  g.addArc(v[0],v[1]);
+  g.addArc(v[0],v[2]);
+
+  for(auto e: g.outArcs(v[0]))
+    cout<<g.id(g.target(e))<<endl;
+
+  cout<<endl;
+
+
+  ToStlit<ListDigraph::NodeIt> st1 = g.nodeColl().begin();
+  //auto st1 = g.nodeColl().begin();
+  auto st2 = st1; //test assignment
+  ++st1; //test preincrement
+  st1++; //test postincrement
+  cout<<g.id(st1)<<" "<<g.id(st2)<<endl;
+  swap(st1, st2); //test swap
+  cout<<g.id(st1)<<" "<<g.id(st2)<<endl;
+
+  st1->operator==(st2);
+
+  return 0;
+}

lemon/bits/graph_extender.h

@@ -27 +27 @@
 #include <lemon/concept_check.h>
 #include <lemon/concepts/maps.h>
 
+#include <lemon/stl_iterators.h>
+
 //\ingroup graphbits
 //\file
 //\brief Extenders for the graph types
@@ -116 +118 @@
 
     };
 
+    LemonitWrapper1<NodeIt, Digraph> nodeColl() {
+      return LemonitWrapper1<NodeIt, Digraph>(*this);
+    }
 
     class ArcIt : public Arc {
       const Digraph* _digraph;
@@ -163 +168 @@
 
     };
 
+    LemonitWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u){
+      return LemonitWrapper2<OutArcIt, Digraph, Node>(*this, u);
+    }
+
 
     class InArcIt : public Arc {
       const Digraph* _digraph;

lemon/concepts/digraph.h

@@ -27 +27 @@
 #include <lemon/concepts/maps.h>
 #include <lemon/concept_check.h>
 #include <lemon/concepts/graph_components.h>
+#include <lemon/stl_iterators.h>
 
 namespace lemon {
   namespace concepts {
@@ -147 +148 @@
         NodeIt& operator++() { return *this; }
       };
 
+      /// \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.nodeColl())
+      ///   doSomething(v);
+      ///
+      /// //Using an STL algorithm:
+      /// copy(g.nodeColl().begin(), g.nodeColl().end(), vect.begin());
+      ///\endcode
+      LemonitWrapper1<NodeIt, Digraph> nodeColl() {
+        return LemonitWrapper1<NodeIt, Digraph>(*this);
+      }
+
 
       /// The arc type of the digraph
 
@@ -237 +257 @@
         OutArcIt& operator++() { return *this; }
       };
 
+      LemonitWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u){
+        return LemonitWrapper2<OutArcIt, Digraph, Node>(*this, u);
+      }
+
+
       /// Iterator class for the incoming arcs of a node.
 
       /// This iterator goes trough the \e incoming arcs of a certain node

new file lemon/stl_iterators.h

@@ +1 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ */
+
+#ifndef LEMON_ITERATOR_WRAPPERS_H_
+#define LEMON_ITERATOR_WRAPPERS_H_
+
+#include <lemon/core.h>
+
+namespace lemon {
+
+  /// \brief Template to make STL iterators from Lemon iterators.
+  ///
+  /// This template makes an STL iterator from a Lemon iterator
+  /// by adding the missing features.
+  /// It inherits from \c std::iterator to make \c iterator_concept work
+  /// (so that STL algorithms work).
+  /// \c T should be the lemon iterator to be decorated.
+  template<class T>
+  struct ToStlit
+      : public T, public std::iterator<std::input_iterator_tag, T> {
+
+    ToStlit(const T &x) : T(x) {}
+
+    //Lemon iterators don't have operator*, (because they rather
+    //inherit from their "value_type"),
+    //so we add one that just returns the object.
+    const T& operator*() const {
+      return *this;
+    }
+
+    //I can't think of any use case for this with Lemon iterators,
+    //but maybe it should be included for completeness.
+    T* operator->() {
+      return this;
+    }
+
+    //Lemon iterators don't have postincrement.
+    void operator++(int) {
+      T::operator++();
+    }
+    //We also have to redefine preincrement, because it disappeared
+    //when postincrement was defined.
+    T& operator++() {
+      return T::operator++();
+    }
+
+  };
+
+
+  /// \brief A generic wrapper for Lemon iterators for range-based for loops.
+  ///
+  /// This template can be used to create a class
+  /// that has begin() and end() from a Lemon iterator
+  /// (with a 1-parameter constructor)
+  /// to make range-based for loops and STL algorithms work.
+  ///
+  /// \c LIT is the Lemon iterator that will be wrapped
+  /// \c P is the type of the parameter of the constructor of \c LIT.
+  template<class LIT, class P>
+  class LemonitWrapper1{
+    const P &_p;
+    typedef ToStlit<LIT> It;
+  public:
+    LemonitWrapper1(const P &p) : _p(p) {}
+    It begin() const {
+      return It(LIT(_p));
+    }
+    It end() const {
+      return It(lemon::INVALID);
+    }
+  };
+
+  /*
+  /// \brief Gets the collection of nodes of a graph.
+  ///
+  /// This function can be used for iterating on
+  /// the nodes of a 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
+  /// ListDigraph g;
+  /// for(auto v: nodeColl(g))
+  ///   doSomething(v);
+  ///
+  /// //Using an STL algorithm:
+  /// copy(nodes(g).begin(), nodes(g).end(), vect);
+  ///\endcode
+  template<class GR>
+  LemonitWrapper1<typename GR::NodeIt, GR> nodeColl(const GR &g){
+    return LemonitWrapper1<typename GR::NodeIt, GR>(g);
+  }
+  */
+
+  /// \brief A generic wrapper for Lemon iterators for range-based for loops.
+  ///
+  /// This template can be used to create a class
+  /// that has begin() and end() from a Lemon iterator
+  /// (with a 2-parameter constructor)
+  /// to make range-based for loops and STL algorithms work.
+  ///
+  /// \c LIT is the Lemon iterator that will be wrapped
+  /// \c P1 and \c P2 are the types of the parameters
+  /// of the constructor of \c LIT.
+  template<class LIT, class P1, class P2>
+  class LemonitWrapper2{
+    const P1 &_p1;
+    const P2 &_p2;
+    typedef ToStlit<LIT> It;
+  public:
+    LemonitWrapper2(const P1 &p1, const P2 &p2) : _p1(p1), _p2(p2) {}
+    It begin() const {
+      return It(LIT(_p1, _p2));
+    }
+    It end() const {
+      return It(lemon::INVALID);
+    }
+  };
+
+  /*template<class GR>
+  LemonitWrapper2<typename GR::OutArcIt, GR, typename GR::Node>
+  outArcs(const GR &g, typename GR::Node n){
+    return LemonitWrapper2<typename GR::OutArcIt, GR, typename GR::Node>(g,n);
+  }*/
+
+
+
+
+
+
+/*
+  //This is a variadic template version of LemonitWrapper,
+  //to avoid having separate classes for 1 and 2 parameter versions.
+  //The drawback of this is that it would require a C++11 compiler.
+
+  #include <tuple>
+
+  template<class LIT, class... P>
+  class LemonitWrapper {
+    const std::tuple<const P&...> _p;
+    typedef ToStlit<LIT> It;
+
+    //This is based on http://stackoverflow.com/a/7858971/708357
+    template<int ...> struct Seq {};
+    template<int N, int ...S> struct Gens : Gens<N-1, N-1, S...> {};
+    template<int ...S> struct Gens<0, S...>{ typedef Seq<S...> Type; };
+    template<int ...S> It callConstr(Seq<S...>) const {
+      return LIT(std::get<S>(_p)...);
+    }
+  public:
+    LemonitWrapper(const P&... p) : _p(p...) {}
+
+    It begin() const {
+      return It(callConstr(typename Gens<sizeof...(P)>::Type()));
+    }
+    It end() const {
+      return It(lemon::INVALID);
+    }
+  };
+
+
+  template<class GR>
+  LemonitWrapper<typename GR::NodeIt, GR> nodes___var(const GR &g){
+    return LemonitWrapper<typename GR::NodeIt, GR>(g);
+  }
+
+  template<class GR>
+  LemonitWrapper<typename GR::OutArcIt, GR, typename GR::Node>
+  outArcs___var(const GR &g, typename GR::Node n){
+    return LemonitWrapper<typename GR::OutArcIt, GR, typename GR::Node>(g,n);
+  }
+*/
+
+}
+
+#endif /* LEMON_ITERATOR_WRAPPERS_H_ */