rendered paste body#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