#pragma once

#ifndef TCG_ITERATOR_OPS_H

#define TCG_ITERATOR_OPS_H

// tcg includes

#include "traits.h"

#include "ptr.h"

// STD includes

#include <iterator></iterator>

namespace tcg

{

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

//    Traits

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

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

struct iterator_traits : public std::iterator_traits<it> {</it>

	typedef It inheritable_iterator_type;

};

template <typename t=""></typename>

struct iterator_traits<t *=""> : public std::iterator_traits<t *=""> {</t></t>

	typedef ptr<t> inheritable_iterator_type;</t>

};

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

//    Derived Iterator  definition

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

template <typename der,="" it,="" iterator_tag="typename" std::iterator_traits<it="" typename="">::iterator_category></typename>

struct derived_iterator : public tcg::iterator_traits<it>::inheritable_iterator_type {</it>

	typedef typename tcg::iterator_traits<it>::inheritable_iterator_type base_iterator;</it>

public:

	derived_iterator() : base_iterator() {}

	derived_iterator(const base_iterator &it) : base_iterator(it) {}

	Der &operator++()

	{

		base_iterator::operator++();

		return static_cast<der &="">(*this);</der>

	}

	Der operator++(int) { return Der(base_iterator::operator++(0), static_cast<der &="">(*this)); }</der>

};

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

struct derived_iterator<it, der,="" std::bidirectional_iterator_tag=""></it,>

	: public derived_iterator<it, der,="" std::forward_iterator_tag=""> {</it,>

	typedef typename tcg::iterator_traits<it>::inheritable_iterator_type base_iterator;</it>

public:

	derived_iterator() : _iter() {}

	derived_iterator(const base_iterator &it) : _iter(it) {}

	Der &operator--()

	{

		base_iterator::operator--();

		return static_cast<der &="">(*this);</der>

	}

	Der operator--(int) { return Der(base_iterator::operator--(0), static_cast<der &="">(*this)); }</der>

private:

	typedef derived_iterator<it, der,="" std::forward_iterator_tag=""> _iter;</it,>

};

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

struct derived_iterator<it, der,="" std::random_access_iterator_tag=""></it,>

	: public derived_iterator<it, der,="" std::bidirectional_iterator_tag=""> {</it,>

	typedef typename tcg::iterator_traits<it>::inheritable_iterator_type base_iterator;</it>

	typedef typename base_iterator::difference_type difference_type;

public:

	derived_iterator() : _iter() {}

	derived_iterator(const base_iterator &it) : _iter(it) {}

	Der operator+(difference_type d) const

	{

		return Der(static_cast<const &="" base_iterator="">(*this) + d,</const>

				   static_cast<const &="" der="">(*this));</const>

	}

	Der &operator+=(difference_type d)

	{

		static_cast<base_iterator &="">(*this) += d;</base_iterator>

		return static_cast<der &="">(*this);</der>

	}

	Der operator-(difference_type d) const

	{

		return Der(static_cast<const &="" base_iterator="">(*this) - d,</const>

				   static_cast<const &="" der="">(*this));</const>

	}

	Der &operator-=(difference_type d)

	{

		static_cast<base_iterator &="">(*this) -= d;</base_iterator>

		return static_cast<der &="">(*this);</der>

	}

	difference_type operator-(const Der &other) const

	{

		return static_cast<const &="" base_iterator="">(*this) -</const>

			   static_cast<const &="" base_iterator="">(other);</const>

	}

private:

	typedef derived_iterator<it, der,="" std::bidirectional_iterator_tag=""> _iter;</it,>

};

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

//    Cast Iterator  definition

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

/*!

  A cast iterator is a utility iterator wrapper that can be used to access

  an iterator's data through a supplied functor intermediary, proving to be

  especially useful when converting data from a container to another with

  minimal effort.

*/

template 

		  typename Val = typename traits<typename function_traits<func="">::ret_type>::referenced_type,</typename>

		  typename Ref = typename choose_if_match<typename function_traits<func="">::ret_type &, typename traits<val>::reference_type>::type,</val></typename>

		  typename Ptr = typename choose_if_match<ref, traits<val="" typename="" void,="">::pointer_type>::type></ref,>

class cast_iterator : public derived_iterator<it, cast_iterator<it,="" func,="" ptr="" ref,="" val,="">></it,>

{

	typedef derived_iterator<it, cast_iterator=""> iterator;</it,>

	typedef typename iterator::base_iterator base_iterator;

	typedef Func function;

	typedef typename function_traits<func>::ret_type ret_type;</func>

public:

	typedef Ref reference;

	typedef Ptr pointer;

	typedef Val value_type;

public:

	cast_iterator() : iterator(), m_func() {}

	cast_iterator(const Func &func) : iterator(), m_func(func) {}

	cast_iterator(const base_iterator &it) : iterator(it), m_func() {}

	cast_iterator(const base_iterator &it, const Func &func) : iterator(it), m_func(func) {}

	cast_iterator(const base_iterator &it, const cast_iterator &other)

		: iterator(it), m_func(other.m_func) {}

	ret_type operator*() { return m_func(iterator::operator*()); }

	pointer operator->() { return ptr(0); }

private:

	Func m_func;

private:

	template <typename t=""></typename>

	pointer ptr(T, typename tcg::enable_if<tcg::type_mismatch<pointer, void="">::value, T>::type = 0) const</tcg::type_mismatch<pointer,>

	{

		return &operator*();

	}

	void ptr(char) const {}

};

//==========================================================================

//  Utility maker function

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

inline cast_iterator<it, func=""> make_cast_it(const It &it, Func func)</it,>

{

	return cast_iterator<it, func="">(it, func);</it,>

}

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

//    Step Iterator class

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

/*!

  The Step Iterator class is a simple random access iterator wrapper which

  moves by a fixed number of items.

\warning The size of the container referenced by the wrapped iterator should

  always be a multiple of the specified step.

*/

template <typename ranit=""></typename>

class step_iterator

	: public std::iterator

						   typename std::iterator_traits<ranit>::value_type,</ranit>

						   typename std::iterator_traits<ranit>::difference_type,</ranit>

						   typename std::iterator_traits<ranit>::pointer,</ranit>

						   typename std::iterator_traits<ranit>::reference></ranit>

{

	RanIt m_it;

	typename step_iterator::difference_type m_step;

public:

	step_iterator() {}

	step_iterator(const RanIt &it, typename step_iterator::difference_type step) : m_it(it), m_step(step) {}

	step_iterator &operator++()

	{

		m_it += m_step;

		return *this;

	}

	step_iterator &operator--()

	{

		m_it -= m_step;

		return *this;

	}

	step_iterator operator++(int)

	{

		step_iterator it(*this);

		operator++();

		return it;

	}

	step_iterator operator--(int)

	{

		step_iterator it(*this);

		operator--();

		return it;

	}

	step_iterator &operator+=(const typename step_iterator::difference_type &val)

	{

		m_it += val * m_step;

		return *this;

	}

	step_iterator &operator-=(const typename step_iterator::difference_type &val)

	{

		m_it -= val * m_step;

		return *this;

	}

	typename step_iterator::difference_type operator-(const step_iterator &it) const

	{

		return (m_it - it.m_it) / m_step;

	}

	step_iterator operator+(const typename step_iterator::difference_type &val) const

	{

		step_iterator it(*this);

		it += val;

		return it;

	}

	step_iterator operator-(const typename step_iterator::difference_type &val) const

	{

		step_iterator it(*this);

		it -= val;

		return it;

	}

	typename step_iterator::reference operator*() const { return *m_it; }

	typename step_iterator::pointer operator->() const { return m_it.operator->(); }

	const RanIt &it() const { return m_it; }

	int step() const { return m_step; }

	bool operator==(const step_iterator &it) const { return m_it == it.m_it; }

	bool operator!=(const step_iterator &it) const { return !operator==(it); }

	bool operator<(const step_iterator &it) const { return m_it < it.m_it; }

	bool operator>(const step_iterator &it) const { return m_it > it.m_it; }

	bool operator<=(const step_iterator &it) const { return m_it <= it.m_it; }

	bool operator>=(const step_iterator &it) const { return m_it >= it.m_it; }

};

} //namespace tcg

#endif //TCG_ITERATOR_OPS_H