#ifndef TCG_ANY_ITERATOR_H

#define TCG_ANY_ITERATOR_H

#include "base.h"

/*

  \file     any_iterator.h

  \brief    This file contains the implementation of a type-erased iterator template class.

  \details  Type erasure is a C++ idiom about allocating an interface

            to an object who is then hidden as the interface's implementation detail.

            The cost of using a type-erased object instead of its actual type is typically

            measured in a heap access at construction and destruction, and one virtual

            function call per method invocation.

            A type-erased iterator can be useful to hide implementation details about container

            choices, yet providing an iterator-like interface to access the stored data.

*/

#ifndef TCG_RVALUES_SUPPORT

#include <boost config.hpp=""></boost>

#ifdef BOOST_NO_RVALUE_REFERENCES

#define TCG_RVALUES_SUPPORT 0

#else

#define TCG_RVALUES_SUPPORT 1

#endif

#endif

namespace tcg

{

//****************************************************************************

//    any_iterator_concept (ie the interface)

//****************************************************************************

template <typename dist="" typename="" val,="" valptr,="" valref,=""></typename>

class any_iterator_concept

{

public:

	virtual ~any_iterator_concept() {}

	virtual any_iterator_concept *clone() const = 0;

	virtual ValRef operator*() const = 0;

	virtual ValPtr operator->() const = 0;

	virtual bool operator==(const any_iterator_concept &other) const = 0;

	virtual bool operator!=(const any_iterator_concept &other) const = 0;

	virtual void operator++() = 0;

	virtual any_iterator_concept *operator++(int)

	{

		assert(false);

		return 0;

	}

	virtual void operator--() { assert(false); }

	virtual any_iterator_concept *operator--(int)

	{

		assert(false);

		return 0;

	}

	virtual bool operator<(const any_iterator_concept &) const

	{

		assert(false);

		return false;

	}

	virtual bool operator>(const any_iterator_concept &) const

	{

		assert(false);

		return false;

	}

	virtual bool operator<=(const any_iterator_concept &) const

	{

		assert(false);

		return false;

	}

	virtual bool operator>=(const any_iterator_concept &) const

	{

		assert(false);

		return false;

	}

	virtual any_iterator_concept *operator+(Dist) const

	{

		assert(false);

		return 0;

	}

	virtual void operator+=(Dist d) { assert(false); }

	virtual any_iterator_concept *operator-(Dist) const

	{

		assert(false);

		return 0;

	}

	virtual void operator-=(Dist d) { assert(false); }

	virtual Dist operator-(const any_iterator_concept &) const

	{

		assert(false);

		return 0;

	}

	virtual ValRef operator[](Dist) const

	{

		assert(false);

		return *(Val *)0;

	}

};

//****************************************************************************

//    any_iterator_model (ie the concrete interface implementations)

//****************************************************************************

template 

		  typename Val, typename ValRef, typename ValPtr, typename Dist>

class any_iterator_model

	: public any_iterator_concept<val, dist="" valptr,="" valref,=""></val,>

{

	typedef any_iterator_concept<val, dist="" valptr,="" valref,=""> any_it_concept;</val,>

public:

	any_iterator_model() : m_it() {}

	any_iterator_model(const It &it) : m_it(it) {}

	any_it_concept *clone() const

	{

		return new any_iterator_model<it, dist="" iterator_cat,="" val,="" valptr,="" valref,="">(*this);</it,>

	}

	ValRef operator*() const { return m_it.operator*(); }

	ValPtr operator->() const { return m_it.operator->(); }

	bool operator==(const any_it_concept &other) const

	{

		return m_it == static_cast<const &="" any_iterator_model="">(other).m_it;</const>

	}

	bool operator!=(const any_it_concept &other) const

	{

		return m_it != static_cast<const &="" any_iterator_model="">(other).m_it;</const>

	}

	void operator++() { ++m_it; }

	any_it_concept *operator++(int)

	{

		return new any_iterator_model<it, dist="" iterator_cat,="" val,="" valptr,="" valref,="">(m_it++);</it,>

	}

protected:

	It m_it;

};

template 

		  typename Val, typename ValRef, typename ValPtr, typename Dist>

class any_iterator_model<it, dist="" std::bidirectional_iterator_tag,="" val,="" valptr,="" valref,=""></it,>

	: public any_iterator_model<it, dist="" std::forward_iterator_tag,="" val,="" valptr,="" valref,=""></it,>

{

	typedef any_iterator_concept<val, dist="" valptr,="" valref,=""> any_it_concept;</val,>

	using any_iterator_model<it, dist="" std::forward_iterator_tag,="" val,="" valptr,="" valref,="">::m_it;</it,>

public:

	any_iterator_model() {}

	any_iterator_model(const It &it)

		: any_iterator_model<it, dist="" std::forward_iterator_tag,="" val,="" valptr,="" valref,="">(it) {}</it,>

	any_it_concept *clone() const

	{

		return new any_iterator_model<it, dist="" std::bidirectional_iterator_tag,="" val,="" valptr,="" valref,="">(*this);</it,>

	}

	void operator--() { --m_it; }

	any_it_concept *operator--(int)

	{

		return new any_iterator_model<it, dist="" std::bidirectional_iterator_tag,="" val,="" valptr,="" valref,="">(m_it--);</it,>

	}

};

template <typename dist="" it,="" typename="" val,="" valptr,="" valref,=""></typename>

class any_iterator_model<it, dist="" std::random_access_iterator_tag,="" val,="" valptr,="" valref,=""></it,>

	: public any_iterator_model<it, dist="" std::bidirectional_iterator_tag,="" val,="" valptr,="" valref,=""></it,>

{

	typedef any_iterator_concept<val, dist="" valptr,="" valref,=""> any_it_concept;</val,>

	using any_iterator_model<it, dist="" std::forward_iterator_tag,="" val,="" valptr,="" valref,="">::m_it;</it,>

public:

	any_iterator_model() {}

	any_iterator_model(const It &it)

		: any_iterator_model<it, dist="" std::bidirectional_iterator_tag,="" val,="" valptr,="" valref,="">(it) {}</it,>

	any_it_concept *clone() const

	{

		return new any_iterator_model<it, dist="" std::random_access_iterator_tag,="" val,="" valptr,="" valref,="">(*this);</it,>

	}

	bool operator<(const any_it_concept &other) const

	{

		return m_it < static_cast<const &="" any_iterator_model="">(other).m_it;</const>

	}

	bool operator>(const any_it_concept &other) const

	{

		return m_it > static_cast<const &="" any_iterator_model="">(other).m_it;</const>

	}

	bool operator<=(const any_it_concept &other) const

	{

		return m_it <= static_cast<const &="" any_iterator_model="">(other).m_it;</const>

	}

	bool operator>=(const any_it_concept &other) const

	{

		return m_it >= static_cast<const &="" any_iterator_model="">(other).m_it;</const>

	}

	any_it_concept *operator+(Dist d) const

	{

		return new any_iterator_model<it, dist="" std::random_access_iterator_tag,="" val,="" valptr,="" valref,="">(m_it + d);</it,>

	}

	void operator+=(Dist d) { m_it += d; }

	any_it_concept *operator-(Dist d) const

	{

		return new any_iterator_model<it, dist="" std::random_access_iterator_tag,="" val,="" valptr,="" valref,="">(m_it - d);</it,>

	}

	void operator-=(Dist d) { m_it -= d; }

	Dist operator-(const any_it_concept &other) const

	{

		return m_it - static_cast<const &="" any_iterator_model="">(other).m_it;</const>

	}

	ValRef operator[](Dist d) const { return m_it[d]; }

};

//****************************************************************************

//    any_iterator  (ie the wrapper to the interface)

//****************************************************************************

template 

		  typename ValRef = Val &, typename ValPtr = Val *, typename Dist = std::ptrdiff_t>

class any_iterator

	: public std::iterator<iterator_cat, dist,="" val,="" valptr,="" valref=""></iterator_cat,>

{

	any_iterator_concept<val, dist="" valptr,="" valref,=""> *m_model;</val,>

public:

	any_iterator() : m_model(0) {}

	any_iterator(any_iterator_concept<val, dist="" valptr,="" valref,=""> *model) : m_model(model) {}</val,>

	template <typename it=""></typename>

	any_iterator(const It &it)

		: m_model(new any_iterator_model<it, dist="" iterator_cat,="" val,="" valptr,="" valref,="">(it)) {}</it,>

	any_iterator(const any_iterator &other) : m_model(other.m_model->clone()) {}

	any_iterator &operator=(any_iterator other)

	{

		swap(*this, other);

		return *this;

	}

	~any_iterator() { delete m_model; }

	friend void swap(any_iterator &a, any_iterator &b) { std::swap(a.m_model, b.m_model); }

	ValRef operator*() const { return m_model->operator*(); }

	ValPtr operator->() const { return m_model->operator->(); }

	bool operator==(const any_iterator &other) const { return m_model->operator==(*other.m_model); }

	bool operator!=(const any_iterator &other) const { return m_model->operator!=(*other.m_model); }

	any_iterator &operator++()

	{

		++*m_model;

		return *this;

	}

	any_iterator operator++(int) { return any_iterator((*m_model)++); }

	any_iterator &operator--()

	{

		--*m_model;

		return *this;

	}

	any_iterator operator--(int) { return any_iterator((*m_model)--); }

	bool operator<(const any_iterator &other) const { return m_model->operator<(*other.m_model); }

	bool operator>(const any_iterator &other) const { return m_model->operator>(*other.m_model); }

	bool operator<=(const any_iterator &other) const { return m_model->operator<=(*other.m_model); }

	bool operator>=(const any_iterator &other) const { return m_model->operator>=(*other.m_model); }

	any_iterator operator+(Dist d) const { return any_iterator((*m_model) + d); }

	any_iterator &operator+=(Dist d)

	{

		(*m_model) += d;

		return *this;

	}

	any_iterator operator-(Dist d) const { return any_iterator((*m_model) - d); }

	any_iterator &operator-=(Dist d)

	{

		(*m_model) -= d;

		return *this;

	}

	Dist operator-(const any_iterator &other) const { return m_model->operator-(*other.m_model); }

	ValRef operator[](Dist d) const { return m_model->operator[](d); }

#if (TCG_RVALUES_SUPPORT > 0)

	any_iterator(any_iterator &&other) : m_model(other.m_model)

	{

		other.m_model = 0;

	}

#endif

};

//-------------------------------------------------------------------------------

template 

		  typename ValRef, typename ValPtr, typename Dist>

any_iterator<val, dist="" iterator_cat,="" valptr,="" valref,=""> operator+(</val,>

	Dist d, const any_iterator<val, dist="" iterator_cat,="" valptr,="" valref,=""> &it) { return it + d; }</val,>

//****************************************************************************

//    Additional typedefs to the actual types

//****************************************************************************

template <typename val=""></typename>

struct any_iterator<val, tcg::empty_type=""> {</val,>

	typedef any_iterator<val, std::input_iterator_tag=""> input;</val,>

	typedef any_iterator<val, std::output_iterator_tag=""> output;</val,>

	typedef any_iterator<val, std::forward_iterator_tag=""> forward;</val,>

	typedef any_iterator<val, std::bidirectional_iterator_tag=""> bidirectional;</val,>

	typedef any_iterator<val, std::random_access_iterator_tag=""> random;</val,>

};

template <typename &,="" *,="" dist="std::ptrdiff_t" typename="" val,="" valptr="Val" valref="Val"></typename>

struct any_it {

	typedef any_iterator<val, dist="" std::input_iterator_tag,="" valptr,="" valref,=""> input;</val,>

	typedef any_iterator<val, dist="" std::output_iterator_tag,="" valptr,="" valref,=""> output;</val,>

	typedef any_iterator<val, dist="" std::forward_iterator_tag,="" valptr,="" valref,=""> forward;</val,>

	typedef any_iterator<val, dist="" std::bidirectional_iterator_tag,="" valptr,="" valref,=""> bidirectional;</val,>

	typedef any_iterator<val, dist="" std::random_access_iterator_tag,="" valptr,="" valref,=""> random;</val,>

};

} // namespace tcg

#endif // TCG_ANY_ITERATOR_H