Iterator.hpp

/// Представляет поэлементный доступ к элементам коллекции
/// @param T - тип элементов коллекции
template<typename T>
class Iterator {
public:
	typedef T* pointer;          //!< Указатель на значение
	typedef T& reference;         //!< Ccылка на значение
	typedef T value_type;        //!< Предопределенный тип для T
	typedef matx::size_t dist_t; //!< Тип для представления расстояния между итераторами

	Iterator();        //!< Конструктор по умолчанию
	Iterator(pointer); //!< Конструктор с параметром
	Iterator(const Iterator&); //!< Конструктор копий

	Iterator& operator = (const Iterator &);        //!< Оператор присваивания

	bool      operator == (const Iterator &) const; //!< Оператор сравнения
	bool      operator != (const Iterator &) const; //!< Оператор не-сравнения

	reference operator *  () const; //!< Разыменование итератора
	pointer   operator -> () const; //!< Косвенное обращение
	/// @bug only prefix
	Iterator& operator ++ ();    //!< prefix-incerment
	//Iterator& operator ++ (int); //!< postfix-incerment
	Iterator& operator -- ();    //!< prefix-decerment
	//Iterator& operator -- (int); //!< postfix-decerment

	Iterator  operator +  (const dist_t) const; //!< Плюс число
	Iterator  operator -  (const dist_t) const; //!< Минус число
	dist_t    operator -  (const Iterator&) const; //!< Расстояние до другого указателя

	bool      operator <  (const Iterator&) const; //!< bool, если этот указатель имеет адрес меньше чем второй
	bool      operator <= (const Iterator&) const; //!< bool, если этот указатель имеет адрес меньше чем второй, или они равны
	bool      operator >  (const Iterator&) const; //!< bool, если этот указатель имеет адрес больше чем второй
	bool      operator >= (const Iterator&) const; //!< bool, если этот указатель имеет адрес больше чем второй, или они равны

	Iterator& operator += (const dist_t); //!< Увеличить адрес текущего вектора
	Iterator& operator -= (const dist_t); //!< Уменьшить адрес текущего вектора

	reference operator [] (const dist_t) const; //!< Поэлементный доступ
protected:
	pointer ptr;       //!< C-like указатель
};

template<typename T>
Iterator<T>::Iterator() {
	ptr = 0;
}

template<typename T>
Iterator<T>::Iterator(pointer ptrToElement) {
	ptr = ptrToElement;
}

template<typename T>
Iterator<T>::Iterator(const Iterator<T> &it) {
	ptr = it.ptr;
}

template<typename T>
Iterator<T>& Iterator<T>::operator = (const Iterator<T> &it) {
	ptr = it.ptr;
	return *this;
}

template<typename T>
bool Iterator<T>::operator == (const Iterator<T> &it) const {
	return (ptr == it.ptr);
}

template<typename T>
bool Iterator<T>::operator != (const Iterator<T> &it) const {
	return not(ptr == it.ptr);
}

template<typename T>
typename Iterator<T>::reference Iterator<T>::operator * () const {
	return *ptr;
}

template<typename T>
typename Iterator<T>::pointer Iterator<T>::operator -> () const {
	return &*ptr;
}

template<typename T>
Iterator<T>& Iterator<T>::operator ++ () {
	Iterator tmp(*this);
	ptr++;
	return *this;
}

//template<typename T>
//Iterator<T>& Iterator<T>::operator ++ (int) {
//	ptr++;
//	return *this;
//}

template<typename T>
Iterator<T>& Iterator<T>::operator -- () {
	ptr--;
	return *this;
}

//template<typename T>
//Iterator<T>& Iterator<T>::operator -- (int) {
//	ptr--;
//	return *this;
//}

template<typename T>
Iterator<T> Iterator<T>::operator + (const dist_t n) const {
	return Iterator<T>(ptr + n);
}

template<typename T>
Iterator<T> Iterator<T>::operator - (const dist_t n) const {
	return Iterator<T>(ptr - n);
}

template<typename T>
typename Iterator<T>::dist_t Iterator<T>::operator - (const Iterator<T> &it) const {
	return ptr - it.ptr;
}

template<typename T>
bool Iterator<T>::operator < (const Iterator<T> &it) const {
	return (ptr < it.ptr);
}

template<typename T>
bool Iterator<T>::operator <= (const Iterator<T> &it) const {
	return (ptr < it.ptr) or (ptr == it.ptr);
}


template<typename T>
bool Iterator<T>::operator > (const Iterator<T> &it) const {
	return (ptr > it.ptr);
}

template<typename T>
bool Iterator<T>::operator >= (const Iterator<T> &it) const {
	return (ptr > it.ptr) or (ptr == it.ptr);
}

template<typename T>
Iterator<T>& Iterator<T>::operator += (const dist_t n) {
	ptr += n;
	return *this;
}

template<typename T>
Iterator<T>& Iterator<T>::operator -= (const dist_t n) {
	ptr -= n;
	return *this;
}

template<typename T>
typename Iterator<T>::reference Iterator<T>::operator [] (const dist_t index) const {
	return *(ptr + index);
}