Deliver/include/Log4CPP/Common.Include/ReverseIterator.List.tlh

#pragma once

#include <list>

#include "ReverseIterator.Base.tlh"


//-----------------------------------------------------------------------------
//		ReverseIterator
//		list - 常量
//-----------------------------------------------------------------------------

namespace ReverseIterator
{
	template <typename T>
	class _L_ConstIterator : public __BaseIterator <typename std::list <T>::const_reverse_iterator>
	{
		typedef   __BaseIterator <typename std::list <T>::const_reverse_iterator>  inherited;

	public:
		//	using value_type = _Container.value_type;
		using reference = typename std::list <T>::reference;
		using const_reference = typename std::list <T>::const_reference;

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

		_L_ConstIterator (const std::list <T> & ar)
		{
			this->Iter = this->_begin = ar.cbegin ();
			this->_end = ar.cend ();
			this->m_Count = (int) ar.size ();
			this->m_Index = this->m_Count - 1;
		}

		_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);
		}

	public:
		inline const_reference Current ()
		{
			return (*(this->Iter));
		}

		inline const_reference operator () (void) { return Current (); }
		inline const_reference operator *  (void) { return Current (); }
	};
};


//-----------------------------------------------------------------------------
//		ReverseIterator
//		list - 变量
//-----------------------------------------------------------------------------
namespace ReverseIterator
{
	template <typename T>
	class _L_Iterator : public __BaseIterator <typename std::list <T>::reverse_iterator>
	{
		typedef   __BaseIterator <typename std::list <T>::reverse_iterator>  inherited;

	public:
		//	using value_type = _Container.value_type;
		using reference = typename std::list <T>::reference;

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

		_L_Iterator (std::list <T> & ar)
		{
			this->Iter = this->_begin = ar.begin ();
			this->_end = ar.end ();
			this->m_Count = (int) ar.size ();
			this->m_Index = this->m_Count - 1;
		}

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

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

		~_L_Iterator () {}

	public:
		inline _L_Iterator & operator = (const _L_Iterator & from)
		{
			CopyAssign (from);

			return (*this);
		}

	public:
		inline reference Current ()
		{
			return (*(this->Iter));
		}

		inline reference operator () (void) { return Current (); }
		inline reference operator *  (void) { return Current (); }
	};
}