/* -*- mode: C++; indent-tabs-mode: nil; -*-

  */

 #ifndef STL_ITERATORS_H_

 #define STL_ITERATORS_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 LemonItWrapper

       : public T, public std::iterator<std::input_iterator_tag, T> {

     LemonItWrapper(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 static_cast<const T&>(*this);

     }

     //I can't think of any use case for this with Lemon iterators,

     //but maybe it should be included for completeness.

     const T* operator->() {

       return static_cast<const T*>(this);

     }

     //Lemon iterators don't have postincrement.

     void operator++(int) {

       T::operator++();

     }

     using 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 LemonRangeWrapper1 {

     const P &_p;

     typedef LemonItWrapper<LIT> It;

   public:

     LemonRangeWrapper1(const P &p) : _p(p) {}

     It begin() const {

       return It(LIT(_p));

     }

     It end() const {

       return It(lemon::INVALID);

     }

   };

   /// \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 LemonRangeWrapper2 {

     const P1 &_p1;

     const P2 &_p2;

     typedef LemonItWrapper<LIT> It;

   public:

     LemonRangeWrapper2(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);

     }

   };

 }

 #endif /* STL_ITERATORS_H_ */