#ifndef M_TMPL_
# error M_TMPL_ not defined
#endif
#ifndef M_TGT_
# error M_TGT_ not defined
#endif

#define M_HDR_ template< M_TMPL_ > template< ptrdiff_t D >
#define M_CNAME_ M_TGT_::T_Iterator_< D >
#define M_CNAME_T_ typename M_TGT_::template T_Iterator_< D >

/*----------------------------------------------------------------------------*/

M_HDR_ inline M_CNAME_::T_Iterator_(
		M_TGT_& array ,
		const ptrdiff_t pos ) noexcept
	: array_( &array ) , pos_( pos )
{ }

M_HDR_ inline M_CNAME_::T_Iterator_( ) noexcept
	: array_( nullptr ) , pos_( 0 )
{ }

M_HDR_ inline M_CNAME_::T_Iterator_(
		T_Iterator_ const& other ) noexcept
	: array_( other.array_ ) , pos_( other.pos_ )
{ }

M_HDR_ inline M_CNAME_T_& M_CNAME_::operator=(
		T_Iterator_ const& other ) noexcept
{
	array_ = other.array_;
	pos_ = other.pos_;
	return *this;
}

/*----------------------------------------------------------------------------*/

M_HDR_ inline M_CNAME_& M_CNAME_::swap(
		M_CNAME_& other ) noexcept
{
	std::swap( array_ ,	other.array_ );
	std::swap( pos_ ,	other.pos_ );
	return *this;
}

template< M_TMPL_ , ptrdiff_t D>
inline void swap(
		M_CNAME_T_& lhs ,
		M_CNAME_T_& rhs ) noexcept
{
	lhs.swap( rhs );
}

/*----------------------------------------------------------------------------*/

M_HDR_ inline bool M_CNAME_::operator==(
		T_Iterator_ const& other ) const noexcept
{
	return array_ == other.array_ && pos_ == other.pos_;
}

M_HDR_ inline bool M_CNAME_::operator!=(
		T_Iterator_ const& other ) const noexcept
{
	return array_ != other.array_ || pos_ != other.pos_;
}

/*----------------------------------------------------------------------------*/

M_HDR_ inline bool M_CNAME_::operator <(
		T_Iterator_ const& other ) const noexcept
{
	return array_ == other.array_ && pos_ < other.pos_;
}

M_HDR_ inline bool M_CNAME_::operator<=(
		T_Iterator_ const& other ) const noexcept
{
	return array_ == other.array_ && pos_ <= other.pos_;
}

M_HDR_ inline bool M_CNAME_::operator >(
		T_Iterator_ const& other ) const noexcept
{
	return array_ == other.array_ && pos_ > other.pos_;
}

M_HDR_ inline bool M_CNAME_::operator>=(
		T_Iterator_ const& other ) const noexcept
{
	return array_ == other.array_ && pos_ >= other.pos_;
}

/*----------------------------------------------------------------------------*/

M_HDR_ inline T& M_CNAME_::operator*( ) const noexcept
{
	assert( valid( ) );
	return (*array_)[ pos_ ];
}

M_HDR_ inline T* M_CNAME_::operator->( ) const noexcept
{
	assert( valid( ) );
	return &((*array_)[ pos_ ]);
}

M_HDR_ inline T& M_CNAME_::operator[](
		const ptrdiff_t pos ) const noexcept
{
	const auto idx( pos + pos_ );
	assert( array_ && idx >= 0 && idx < array_->size( ) );
	return (*array_)[ idx ];
}

/*----------------------------------------------------------------------------*/

M_HDR_ inline M_CNAME_T_& M_CNAME_::operator++ () noexcept
{
	assert( array_ );
	pos_ = std::min( ptrdiff_t( array_->size( ) ) ,
			std::max( ptrdiff_t( -1 ) , pos_ + D ) );
	return *this;
}

M_HDR_ inline M_CNAME_T_ M_CNAME_::operator++ (int) noexcept
{
	assert( array_ );
	auto copy( *this );
	pos_ = std::min( ptrdiff_t( array_->size( ) ) ,
			std::max( ptrdiff_t( -1 ) , pos_ + D ) );
	return copy;
}

M_HDR_ inline M_CNAME_T_& M_CNAME_::operator-- () noexcept
{
	assert( array_ );
	pos_ = std::min( ptrdiff_t( array_->size( ) ) ,
			std::max( ptrdiff_t( -1 ) , pos_ - D ) );
	return *this;
}

M_HDR_ inline M_CNAME_T_ M_CNAME_::operator-- (int) noexcept
{
	assert( array_ );
	auto copy( *this );
	pos_ = std::min( ptrdiff_t( array_->size( ) ) ,
			std::max( ptrdiff_t( -1 ) , pos_ - D ) );
	return copy;
}

/*----------------------------------------------------------------------------*/

M_HDR_ inline M_CNAME_T_ M_CNAME_::operator +(
		const ptrdiff_t value ) const noexcept
{
	auto copy( *this );
	copy += value;
	return copy;
}

M_HDR_ inline M_CNAME_T_ M_CNAME_::operator -(
		const ptrdiff_t value ) const noexcept
{
	auto copy( *this );
	copy -= value;
	return copy;
}

M_HDR_ inline ptrdiff_t M_CNAME_::operator -(
		M_CNAME_T_ const& other ) const noexcept
{
	assert( array_ && array_ == other.array_ );
	return pos_ - other.pos_;
}

M_HDR_ inline M_CNAME_T_& M_CNAME_::operator +=(
		const ptrdiff_t value ) noexcept
{
	assert( array_ );
	pos_ = std::min( ptrdiff_t( array_->size( ) ) ,
		std::max( ptrdiff_t( -1 ) , pos_ + value * D ) );
	return *this;
}

M_HDR_ inline M_CNAME_T_& M_CNAME_::operator -=(
		const ptrdiff_t value ) noexcept
{
	assert( array_ );
	pos_ = std::min( ptrdiff_t( array_->size( ) ) ,
		std::max( ptrdiff_t( -1 ) , pos_ - value * D ) );
	return *this;
}

/*----------------------------------------------------------------------------*/

M_HDR_ inline bool M_CNAME_::valid( ) const noexcept
{
	return array_ && pos_ >= 0 && pos_ < array_->size( );
}

M_HDR_ inline M_TGT_* M_CNAME_::target( ) const noexcept
{
	return array_;
}

M_HDR_ inline ptrdiff_t M_CNAME_::pos( ) const noexcept
{
	return pos_;
}

/*----------------------------------------------------------------------------*/

#undef M_HDR_
#undef M_CNAME_
#undef M_CNAME_T_
#undef M_TMPL_
#undef M_TGT_