#ifndef WCL_Iterator_HH
#define WCL_Iterator_HH

#include<WCL/WCL.hh>

namespace WCL { 

//#####################################################################################################################
template<class T,class I> 
struct Get_Ptr {
  static T&   get( I const i) { assert(*i); return **i;   }
  static bool skip(I const i) { return *i==0; }
}; 

template<class T,class I> 
struct Get_First_Ptr {
  static T&   get( I const i) { assert(i->first); return *i->first;   }
  static bool skip(I const i) { return i->first==0; }
}; 

template<class T,class I> 
struct Get_Second_Ptr {
  static T&   get( I const i) { assert(i->second); return *i->second;   }
  static bool skip(I const i) { return i->second==0; }
}; 

template<class T,class I> 
struct Get_First {
  static T const& get( I const i) { return i->first;  }
  static bool skip(I const i) { return false;      }
}; 

template<class T,class I> 
struct Get_Second {
  static T const& get( I const i) { return i->second;  }
  static bool skip(I const i) { return false;      }
}; 

//#####################################################################################################################
template<class T,class I, template<class TG, class IG> class Get_> 
//Get must have
// static T&   get( I const& i);
class Iterator {
  // Typedefs ------------------------------------------------------------------
  private:typedef Get_<T,I> Get;
          typedef Iterator<T,I,Get_> Self;
  public: typedef std::forward_iterator_tag iterator_category;
          typedef size_t    size_type;
          typedef ptrdiff_t difference_type;
          typedef T         value_type;
          typedef T*        pointer;
          typedef T&        reference;
  // Constructors --------------------------------------------------------------
  public: explicit Iterator(I i) : myRef(i) {}
                   Iterator()    : myRef(I())  {}
          template<class T2, class I2, template<class, class> class G2> 
                   Iterator(Iterator<T2,I2,G2> const& i) : myRef(i.ref()) {}
  // Node ----------------------------------------------------------------------
  public:I myRef;
  public: I const& ref() const { return myRef; }
  // Operators -----------------------------------------------------------------
  public: T&    operator* () const { return  Get::get(myRef); }
          T*    operator->() const { return &Get::get(myRef); }
          Self& operator++()       { ++myRef; return *this; }
          Self  operator++(int)    { Self tmp=*this; ++myRef; return tmp; }
};

template<class T1, class I1, template<class, class> class G1, class T2, class I2, template<class, class> class G2>
inline bool operator==(Iterator<T1,I1,G1> const&i1,Iterator<T2,I2,G2> const&i2){ 
  return i1.ref()==i2.ref(); 
}

template<class T1, class I1, template<class, class> class G1, class T2, class I2, template<class, class> class G2>
inline bool operator!=(Iterator<T1,I1,G1> const&i1,Iterator<T2,I2,G2> const&i2){ 
  return !(i1.ref()==i2.ref()); 
}

#define ITERATOR_BASE_IMPL(Impl,E,Get)                                                            \
         typedef WCL::Iterator<E,Impl::const_iterator,Get>         const_iterator;                \
         typedef WCL::Iterator<E,Impl::      iterator,Get>               iterator;                \
         typedef WCL::Iterator<E,Impl::const_reverse_iterator,Get> const_reverse_iterator;        \
         typedef WCL::Iterator<E,Impl::      reverse_iterator,Get>       reverse_iterator;        \
         const_iterator begin() const { return const_iterator(Impl::begin()); }                   \
               iterator begin()       { return       iterator(Impl::begin()); }                   \
         const_iterator end()   const { return const_iterator(Impl::end  ()); }                   \
               iterator end()         { return       iterator(Impl::end  ()); }                   \
         const_reverse_iterator rbegin() const { return const_reverse_iterator(Impl::rbegin()); } \
               reverse_iterator rbegin()       { return       reverse_iterator(Impl::rbegin()); } \
         const_reverse_iterator rend()   const { return const_reverse_iterator(Impl::rend  ()); } \
               reverse_iterator rend()         { return       reverse_iterator(Impl::rend  ()); }

#define CONST_ITERATOR_BASE_IMPL(Impl,E,Get)                                                      \
         typedef WCL::Iterator<E,Impl::const_iterator,Get>         const_iterator;                \
         typedef WCL::Iterator<E,Impl::const_reverse_iterator,Get> const_reverse_iterator;        \
         const_iterator begin() const { return const_iterator(Impl::begin()); }                   \
         const_iterator end()   const { return const_iterator(Impl::end  ()); }                   \
         const_reverse_iterator rbegin() const { return const_reverse_iterator(Impl::rbegin()); } \
         const_reverse_iterator rend()   const { return const_reverse_iterator(Impl::rend  ()); }  

#define ITERATOR_BASE(Impl)                                           \
         typedef Impl::const_iterator                 const_iterator; \
         typedef Impl::      iterator                       iterator; \
         typedef Impl::const_reverse_iterator const_reverse_iterator; \
         typedef Impl::      reverse_iterator       reverse_iterator; \
         using Impl::begin;                                           \
         using Impl::end;                                             \
         using Impl::rbegin;                                          \
         using Impl::rend;                                            

#define CONST_ITERATOR_BASE(Impl)                                         \
         typedef Impl::const_iterator                 const_iterator;     \
         typedef Impl::const_reverse_iterator const_reverse_iterator;     \
         const_iterator         begin()  const { return Impl::begin();  } \
         const_iterator         end()    const { return Impl::end  ();  } \
         const_reverse_iterator rbegin() const { return Impl::rbegin(); } \
         const_reverse_iterator rend()   const { return Impl::rend  (); }  

#define TEMPLATE_ITERATOR_BASE_IMPL(Impl,E,Get)                                                              \
         typedef typename WCL::Iterator<E,typename Impl::const_iterator,Get>         const_iterator;         \
         typedef typename WCL::Iterator<E,typename Impl::      iterator,Get>               iterator;         \
         typedef typename WCL::Iterator<E,typename Impl::const_reverse_iterator,Get> const_reverse_iterator; \
         typedef typename WCL::Iterator<E,typename Impl::      reverse_iterator,Get>       reverse_iterator; \
         const_iterator begin() const { return const_iterator(Impl::begin()); }                              \
               iterator begin()       { return       iterator(Impl::begin()); }                              \
         const_iterator end()   const { return const_iterator(Impl::end  ()); }                              \
               iterator end()         { return       iterator(Impl::end  ()); }                              \
         const_reverse_iterator rbegin() const { return const_reverse_iterator(Impl::rbegin()); }            \
               reverse_iterator rbegin()       { return       reverse_iterator(Impl::rbegin()); }            \
         const_reverse_iterator rend()   const { return const_reverse_iterator(Impl::rend  ()); }            \
               reverse_iterator rend()         { return       reverse_iterator(Impl::rend  ()); }

#define TEMPLATE_CONST_ITERATOR_BASE_IMPL(Impl,E,Get)                                                        \
         typedef typename WCL::Iterator<E,typename Impl::const_iterator,Get>         const_iterator;         \
         typedef typename WCL::Iterator<E,typename Impl::const_reverse_iterator,Get> const_reverse_iterator; \
         const_iterator begin() const { return const_iterator(Impl::begin()); }                              \
         const_iterator end()   const { return const_iterator(Impl::end  ()); }                              \
         const_reverse_iterator rbegin() const { return const_reverse_iterator(Impl::rbegin()); }            \
         const_reverse_iterator rend()   const { return const_reverse_iterator(Impl::rend  ()); }  

#define TEMPLATE_ITERATOR_BASE(Impl)                                           \
         typedef typename Impl::const_iterator                 const_iterator; \
         typedef typename Impl::      iterator                       iterator; \
         typedef typename Impl::const_reverse_iterator const_reverse_iterator; \
         typedef typename Impl::      reverse_iterator       reverse_iterator; \
         using Impl::begin;                                                    \
         using Impl::end;                                                      \
         using Impl::rbegin;                                                   \
         using Impl::rend;                                            

#define TEMPLATE_CONST_ITERATOR_BASE(Impl)                                     \
         typedef typename Impl::const_iterator                 const_iterator; \
         typedef typename Impl::const_reverse_iterator const_reverse_iterator; \
         const_iterator         begin()  const { return Impl::begin();  }      \
         const_iterator         end()    const { return Impl::end  ();  }      \
         const_reverse_iterator rbegin() const { return Impl::rbegin(); }      \
         const_reverse_iterator rend()   const { return Impl::rend  (); }  

//#####################################################################################################################
template<class T,class I, template<class TG, class IG> class Get_> 
//Get must have
// static T&   get( I const& i);
// static bool skip(I const& i);
class FilterIterator {
  // Typedefs ------------------------------------------------------------------
  private:typedef Get_<T,I> Get;
          typedef FilterIterator<T,I,Get_> Self;
  public: typedef std::forward_iterator_tag iterator_category;
          typedef size_t    size_type;
          typedef ptrdiff_t difference_type;
          typedef T         value_type;
          typedef T*        pointer;
          typedef T&        reference;
  // Constructors --------------------------------------------------------------
  public: explicit FilterIterator(I i,I i_end) : myRef(i), myEnd(i_end) { skip(); }
          template<class T2, class I2, template<class, class> class G2> 
                   FilterIterator(FilterIterator<T2,I2,G2> const& i) : myRef(i.ref()), myEnd(i.ref_end()) {}
  // Node ----------------------------------------------------------------------
  public: I       myRef;
  public: I const myEnd;
  public: I const& ref()     const { return myRef; }
  public: I const& ref_end() const { return myEnd; }
  // Operators -----------------------------------------------------------------
  public: T&    operator* () const { return  Get::get(myRef); }
          T*    operator->() const { return &Get::get(myRef); }
          Self& operator++()       { ++myRef; skip(); return *this; }
          Self  operator++(int)    { Self tmp=*this; ++(*this); return tmp; }
  private:void skip() { while(Get::skip(myRef)&&myRef!=myEnd) ++myRef; }
};

template<class T1, class I1, template<class, class> class G1, class T2, class I2, template<class, class> class G2>
inline bool operator==(FilterIterator<T1,I1,G1> const&i1,FilterIterator<T2,I2,G2> const&i2){ 
  return i1.ref()==i2.ref(); 
}

template<class T1, class I1, template<class, class> class G1, class T2, class I2, template<class, class> class G2>
inline bool operator!=(FilterIterator<T1,I1,G1> const&i1,FilterIterator<T2,I2,G2> const&i2){ 
  return !(i1.ref()==i2.ref()); 
}


#define FILTER_ITERATOR_BASE_IMPL(Impl,E,Get)                                                                   \
         typedef WCL::FilterIterator<E,Impl::const_iterator,Get>         const_iterator;                        \
         typedef WCL::FilterIterator<E,Impl::      iterator,Get>               iterator;                        \
         typedef WCL::FilterIterator<E,Impl::const_reverse_iterator,Get> const_reverse_iterator;                \
         typedef WCL::FilterIterator<E,Impl::      reverse_iterator,Get>       reverse_iterator;                \
         const_iterator begin() const { return const_iterator(Impl::begin(),Impl::end()); }                     \
               iterator begin()       { return       iterator(Impl::begin(),Impl::end()); }                     \
         const_iterator end()   const { return const_iterator(Impl::end  (),Impl::end()); }                     \
               iterator end()         { return       iterator(Impl::end  (),Impl::end()); }                     \
         const_reverse_iterator rbegin() const { return const_reverse_iterator(Impl::rbegin(),Impl::rend()); }  \
               reverse_iterator rbegin()       { return       reverse_iterator(Impl::rbegin(),Impl::rend()); }  \
         const_reverse_iterator rend()   const { return const_reverse_iterator(Impl::rend  (),Impl::rend()); }  \
               reverse_iterator rend()         { return       reverse_iterator(Impl::rend  (),Impl::rend()); }


#define CONST_FILTER_ITERATOR_BASE_IMPL(Impl,E,Get)                                                             \
         typedef WCL::FilterIterator<E,Impl::const_iterator,Get>         const_iterator;                        \
         typedef WCL::FilterIterator<E,Impl::const_reverse_iterator,Get> const_reverse_iterator;                \
         const_iterator begin() const { return const_iterator(Impl::begin(),Impl::end()); }                     \
         const_iterator end()   const { return const_iterator(Impl::end  (),Impl::end()); }                     \
         const_reverse_iterator rbegin() const { return const_reverse_iterator(Impl::rbegin(),Impl::rend()); }  \
         const_reverse_iterator rend()   const { return const_reverse_iterator(Impl::rend  (),Impl::rend()); }  

//#####################################################################################################################
template<class T,class I> 
struct ObjectFilter {
           ObjectFilter() : myRefs(0) {}

  virtual ~ObjectFilter() { assert(myRefs==0); }
  virtual T&   get(  I const i) const =0;
  virtual bool valid(I const i) const =0;

  ObjectFilter* share() { ++myRefs; return this; }
  void          free()  { if(--myRefs==0) delete this; }

  private:ObjectFilter(ObjectFilter const&);  // none
          void operator=(ObjectFilter const&);// none

  private:size_t myRefs;
};

// Call skip after constructor
template<class T,class I> 
class ObjectFilterIterator {
  // Typedefs ------------------------------------------------------------------
  private:typedef ObjectFilterIterator<T,I> Self;
  public: typedef std::forward_iterator_tag iterator_category;
          typedef size_t    size_type;
          typedef ptrdiff_t difference_type;
          typedef T         value_type;
          typedef T*        pointer;
          typedef T&        reference;
          typedef ObjectFilter<T,I> Filter;
  // Constructors --------------------------------------------------------------
  protected:explicit ObjectFilterIterator(Filter* f, I i,I i_end) 
                     : myFilter(f), myRef(i), myEnd(i_end) { skip(); }
            template<class T2, class I2> 
                     ObjectFilterIterator(ObjectFilterIterator<T2,I2> const& i) 
                     : myFilter(i.myFilter->share()), myRef(i.ref()), myEnd(i.ref_end()) {}
  public: virtual ~ObjectFilterIterator() { myFilter->free(); }
  // Node ----------------------------------------------------------------------
  public: Filter* myFilter;
  public: I       myRef;
  public: I const myEnd;
  public: I const& ref()     const { return myRef; }
  public: I const& ref_end() const { return myEnd; }
  // Operators -----------------------------------------------------------------
  public: T&    operator* () const { return  myFilter->get(myRef); }
          T*    operator->() const { return &myFilter->get(myRef); }
          Self& operator++()       { ++myRef; skip(); return *this;              }
          Self  operator++(int)    { Self tmp=*this; ++(*this); return tmp;      }
          bool  isEnd()      const { return myRef==myEnd;                        }
  public: void  skip()             { while(myRef!=myEnd&&!myFilter->valid(myRef)) ++myRef; }
};

template<class T1, class I1, class T2, class I2>
inline bool operator==(ObjectFilterIterator<T1,I1> const&i1,ObjectFilterIterator<T2,I2> const&i2){ 
  return i1.ref()==i2.ref(); 
}

template<class T1, class I1, class T2, class I2>
inline bool operator!=(ObjectFilterIterator<T1,I1> const&i1,ObjectFilterIterator<T2,I2> const&i2){ 
  return !(i1.ref()==i2.ref()); 
}

}
#endif