#pragma once

#include "ReverseIterator.Base.tlh"
#include "ReverseIterator.Container.tlh"
#include "ReverseIterator.List.tlh"
#include "ReverseIterator.VectorOfPtr.tlh"
//#include "ReverseIterator.ListOfPtr.tlh"


//-----------------------------------------------------------------------------
//		From
//-----------------------------------------------------------------------------
namespace ReverseIterator
{
	template <typename _Container>
	static __ConstIterator <_Container> From (const _Container & ar)
	{
		return __ConstIterator <_Container> (ar);
	}

	template <typename _Container>
	static __ConstIterator <_Container> From (const _Container * ar)
	{
		if (ar == nullptr)
			return __ConstIterator <_Container> ();
		else
			return __ConstIterator <_Container> (*ar);
	}



	template <typename _Container>
	static __Iterator <_Container> From (_Container & ar)
	{
		return __Iterator <_Container> (ar);
	}

	template <typename _Container>
	static __Iterator <_Container> From (_Container * ar)
	{
		if (ar == nullptr)
			return __Iterator <_Container> ();
		else
			return __Iterator <_Container> (*ar);
	}
};



//-----------------------------------------------------------------------------
//		From - list
//-----------------------------------------------------------------------------
namespace ReverseIterator
{
	template <typename T>
	static _L_ConstIterator <T> From (const std::list <T> & ar)
	{
		return _L_ConstIterator <T> (ar);
	}

	template <typename T>
	static _L_ConstIterator <T> From (const std::list <T> * ar)
	{
		if (ar == nullptr)
			return _L_ConstIterator <T> ();
		else
			return _L_ConstIterator <T> (*ar);
	}


	template <typename T>
	static _L_Iterator <T> From (std::list <T> & ar)
	{
		return _L_Iterator <T> (ar);
	}

	template <typename T>
	static _L_Iterator <T> From (std::list <T> * ar)
	{
		if (ar == nullptr)
			return _L_Iterator <T> ();
		else
			return _L_Iterator <T> (*ar);
	}

};



//-----------------------------------------------------------------------------
//		From - VectorOfPtr
//-----------------------------------------------------------------------------
namespace ReverseIterator
{
	template <typename T>
	static _VP_ConstIterator <T> From (const VectorOfPtr <T> & ar)
	{
		return _VP_ConstIterator <T> (ar);
	}

	template <typename T>
	static _VP_ConstIterator <T> From (const VectorOfPtr <T> * ar)
	{
		if (ar == nullptr)
			return _VP_ConstIterator <T> ();
		else
			return _VP_ConstIterator <T> (*ar);
	}


	template <typename T>
	static _VP_Iterator <T> From (VectorOfPtr <T> & ar)
	{
		return _VP_Iterator <T> (ar);
	}

	template <typename T>
	static _VP_Iterator <T> From (VectorOfPtr <T> * ar)
	{
		if (ar == nullptr)
			return _VP_Iterator <T> ();
		else
			return _VP_Iterator <T> (*ar);
	}
};