#pragma once

#include <list>

#include "Iterator.Base.tlh"

#include "Iterator.Sequence.tlh"


//-----------------------------------------------------------------------------
//		Iterator
//		list - 常量
//-----------------------------------------------------------------------------

namespace Iterator
{
	template <typename T>
	class _L_ConstIterator : public __SequenceIterator <typename std::list <T>::const_iterator>
	{
		typedef   __SequenceIterator <typename std::list <T>::const_iterator>  inherited;

	public:
		using value_type = typename std::list <T>::value_type;
		using reference = typename std::list <T>::reference;
		using const_reference = typename std::list <T>::const_reference;
		using data_type = const_reference;
		using deref_type = value_type;

	public:
		//		构造一个全空的迭代器, 用于容器指针为空的情形
		_L_ConstIterator () : inherited ()
		{
		}

		_L_ConstIterator (const std::list <T> & ar)
		{
			InitFrom (ar);
		}

		_L_ConstIterator (const _L_ConstIterator & from)
		{
			CopyAssign (from);
		}

		_L_ConstIterator (_L_ConstIterator && from)
		{
			MoveAssign (from);
		}

		~_L_ConstIterator () {}

	public:
		inline _L_ConstIterator & operator = (const _L_ConstIterator & from)
		{
			CopyAssign (from);
			return (*this);
		}

		inline _L_ConstIterator & operator = (_L_ConstIterator && from)
		{
			MoveAssign (from);
			return (*this);
		}

	public:
		inline data_type Current ()     { return (*(this->m_stdIter)); }
		inline data_type operator () () { return Current (); }
		inline data_type operator *  () { return Current (); }

	protected:
		void InitFrom (const std::list <T> & ar)
		{
			this->m_stdIter = this->m_stdBegin = ar.cbegin ();
			this->m_stdEnd = ar.cend ();
			this->m_Count = (int)ar.size ();
			this->m_Index = 0;
		}

	};
};


//-----------------------------------------------------------------------------
//		Iterator
//		list - 变量
//-----------------------------------------------------------------------------
namespace Iterator
{
	template <typename T>
	class _L_Iterator : public __SequenceIterator <typename std::list <T>::iterator>
	{
		using inherited = __SequenceIterator <typename std::list <T>::iterator>;

	public:
		using value_type = typename std::list <T>::value_type;
		using reference = typename std::list <T>::reference;
		using data_type = reference;
		using deref_type = value_type;

	public:
		//		构造一个全空的迭代器, 用于容器指针为空的情形
		_L_Iterator () : inherited ()
		{
		}

		_L_Iterator (std::list <T> & ar)
		{
		}

		_L_Iterator (const _L_Iterator & from)
		{
			inherited::CopyAssign (from);
		}

		_L_Iterator (_L_Iterator && from)
		{
			inherited::MoveAssign (from);
		}

		~_L_Iterator () {}

	public:
		inline _L_Iterator & operator = (const _L_Iterator & from)
		{
			CopyAssign (from);
			return (*this);
		}

		inline _L_Iterator & operator = ( _L_Iterator && from)
		{
			MoveAssign (from);
			return (*this);
		}

	public:
		inline data_type Current ()     { return (*(this->m_stdIter)); }
		inline data_type operator () () { return Current (); }
		inline data_type operator *  () { return Current (); }

	protected:
		void InitFrom (std::list <T> & ar)
		{
			this->m_stdIter = this->m_stdBegin = ar.begin ();
			this->m_stdEnd = ar.end ();
			this->m_Count = (int)ar.size ();
			this->m_Index = 0;
		}
	};
}