#pragma once

#include "Iterator.Base.tlh"

#include "Iterator.Container.tlh"
#include "Iterator.List.tlh"
#include "Iterator.VectorOfPtr.tlh"
#include "Iterator.ListOfPtr.tlh"

#include "Iterator.Filter.tlh"

#if _HAS_CXX17
#include "Iterator.Function.tlh"
#endif

#include "Iterator.Extension.tlh"



//-----------------------------------------------------------------------------
//		From
//-----------------------------------------------------------------------------
namespace Iterator
{
	namespace Ext__ConstIterator
	{
		template <typename _Container>
		class Ext : public Extension <__ConstIterator <_Container>>
		{
		public:
			//			using Extension::Extension;
			Ext () { }
			Ext (const _Container & ar) { InitFrom (ar); }
		};
	}

	template <typename _Container>
	static Ext__ConstIterator::Ext <_Container> From (const _Container & ar)
	{
		return Ext__ConstIterator::Ext <_Container> (ar);
	}

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


	namespace Ext__Iterator
	{
		template <typename _Container>
		class Ext : public Extension <__Iterator <_Container>>
		{
		public:
			//			using Extension::Extension;
			Ext () { }
			Ext (_Container & ar) { InitFrom (ar); }
		};
	}

	template <typename _Container>
	static Ext__Iterator::Ext <_Container> From (_Container & ar)
	{
		return Ext__Iterator::Ext <_Container> (ar);
	}

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

};



//-----------------------------------------------------------------------------
//		From - list
//-----------------------------------------------------------------------------
namespace Iterator
{
	namespace Ext_L_ConstIterator
	{
		template <typename T>
		class Ext : public Extension <_L_ConstIterator <T>>
		{
		public:
			Ext () { }
			Ext (const std::list <T> & ar) { InitFrom (ar); }
		};
	}

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

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


	namespace Ext_L_Iterator
	{
		template <typename T>
		class Ext : public Extension <_L_Iterator <T>>
		{
		public:
			Ext () { }
			Ext (std::list <T> & ar) { InitFrom (ar); }
		};
	}


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

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

};



//-----------------------------------------------------------------------------
//		From - VectorOfPtr
//-----------------------------------------------------------------------------
namespace Iterator
{
	namespace Ext_VP_ConstIterator
	{
		template <typename T>
		class Ext : public Extension <_VP_ConstIterator <T>>
		{
		public:
			Ext () { }
			Ext (const VectorOfPtr <T> & ar) { InitFrom (ar); }
		};
	}

	template <typename T>
	static Ext_VP_ConstIterator::Ext <T> From (const VectorOfPtr <T> & ar)
	{
		return Ext_VP_ConstIterator::Ext <T> (ar);
	}

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


	namespace Ext_VP_Iterator
	{
		template <typename T>
		class Ext : public Extension <_VP_Iterator <T>>
		{
		public:
			Ext () { }
			Ext (VectorOfPtr <T> & ar) { InitFrom (ar); }
		};
	}

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

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



//-----------------------------------------------------------------------------
//		From - ListOfPtr
//-----------------------------------------------------------------------------
namespace Iterator
{
	namespace Ext_LP_ConstIterator
	{
		template <typename T>
		class Ext : public Extension <_LP_ConstIterator <T>>
		{
		public:
			Ext () { }
			Ext (const ListOfPtr <T> & ar) { InitFrom (ar); }
		};
	}

	template <typename T>
	static Ext_LP_ConstIterator::Ext <T> From (const ListOfPtr <T> & ar)
	{
		return Ext_LP_ConstIterator::Ext <T> (ar);
	}

	template <typename T>
	static Ext_LP_ConstIterator::Ext <T> From (const ListOfPtr <T> * ar)
	{
		if (ar == nullptr)
			return Ext_LP_ConstIterator::Ext <T> ();
		else
			return Ext_LP_ConstIterator::Ext <T> (*ar);
	}


	namespace Ext_LP_Iterator
	{
		template <typename T>
		class Ext : public Extension <_LP_Iterator <T>>
		{
		public:
			Ext () { }
			Ext (ListOfPtr <T> & ar) { InitFrom (ar); }
		};
	}

	template <typename T>
	static Ext_LP_Iterator::Ext <T> From (ListOfPtr <T> & ar)
	{
		return Ext_LP_Iterator::Ext <T> (ar);
	}

	template <typename T>
	static Ext_LP_Iterator::Ext <T> From (ListOfPtr <T> * ar)
	{
		if (ar == nullptr)
			return Ext_LP_Iterator::Ext <T> ();
		else
			return Ext_LP_Iterator::Ext <T> (*ar);
	}
};



#if _HAS_CXX17

//-----------------------------------------------------------------------------
//		From - Function
//-----------------------------------------------------------------------------
namespace Iterator
{
	namespace Ext_Fun_Iterator
	{
		template <typename T>
		class Ext : public Extension <Function_Iterator <T>>
		{
		public:
			Ext () { }
			Ext (Function_Iterator::FuncType & fun)  { InitFrom (fun); }
		};
	}

	template <typename T>
	static Ext_Fun_Iterator::Ext <T> From (const std::function <std::optional <T> ()> & fun)
	{
		return Ext_Fun_Iterator::Ext <T> (fun);
	}

	template <typename T>
	static Ext_Fun_Iterator::Ext <T> From (std::function <std::optional <T> ()> && fun)
	{
		return Ext_Fun_Iterator::Ext <T> (fun);
	}
};

#endif


//-----------------------------------------------------------------------------
//		TypeFrom
//-----------------------------------------------------------------------------

namespace Iterator
{
	template <typename T>
	struct TypeFrom
	{
		using Type = decltype (::Iterator::From ((T *) nullptr));
		using ConstType = decltype (::Iterator::From ((const T *) nullptr));
	};
};

//	以下写法也可以, 
//	using IterType = decltype (::Iterator::From ((VectorOfPtr <DICOMVRSet> *) nullptr));

//	下面的写法更漂亮
//	using IterType = ::Iterator::TypeFrom <VectorOfPtr <DICOMVRSet>>::Type;