test/support/test_iterators.h

//===----------------------------------------------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef ITERATORS_H
#define ITERATORS_H

#include <iterator>
#include <stdexcept>
#include <cassert>

#include "test_macros.h"

#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
#define DELETE_FUNCTION = delete
#else
#define DELETE_FUNCTION
#endif

template <class It>
class output_iterator
{
    It it_;

    template <class U> friend class output_iterator;
public:
    typedef          std::output_iterator_tag                  iterator_category;
    typedef void                                               value_type;
    typedef typename std::iterator_traits<It>::difference_type difference_type;
    typedef It                                                 pointer;
    typedef typename std::iterator_traits<It>::reference       reference;

    It base() const {return it_;}

    output_iterator () {}
    explicit output_iterator(It it) : it_(it) {}
    template <class U>
        output_iterator(const output_iterator<U>& u) :it_(u.it_) {}

    reference operator*() const {return *it_;}

    output_iterator& operator++() {++it_; return *this;}
    output_iterator operator++(int)
        {output_iterator tmp(*this); ++(*this); return tmp;}

    template <class T>
    void operator,(T const &) DELETE_FUNCTION;
};

template <class It>
class input_iterator
{
    It it_;

    template <class U> friend class input_iterator;
public:
    typedef          std::input_iterator_tag                   iterator_category;
    typedef typename std::iterator_traits<It>::value_type      value_type;
    typedef typename std::iterator_traits<It>::difference_type difference_type;
    typedef It                                                 pointer;
    typedef typename std::iterator_traits<It>::reference       reference;

    It base() const {return it_;}

    input_iterator() : it_() {}
    explicit input_iterator(It it) : it_(it) {}
    template <class U>
        input_iterator(const input_iterator<U>& u) :it_(u.it_) {}

    reference operator*() const {return *it_;}
    pointer operator->() const {return it_;}

    input_iterator& operator++() {++it_; return *this;}
    input_iterator operator++(int)
        {input_iterator tmp(*this); ++(*this); return tmp;}

    friend bool operator==(const input_iterator& x, const input_iterator& y)
        {return x.it_ == y.it_;}
    friend bool operator!=(const input_iterator& x, const input_iterator& y)
        {return !(x == y);}

    template <class T>
    void operator,(T const &) DELETE_FUNCTION;
};

template <class T, class U>
inline
bool
operator==(const input_iterator<T>& x, const input_iterator<U>& y)
{
    return x.base() == y.base();
}

template <class T, class U>
inline
bool
operator!=(const input_iterator<T>& x, const input_iterator<U>& y)
{
    return !(x == y);
}

template <class It>
class forward_iterator
{
    It it_;

    template <class U> friend class forward_iterator;
public:
    typedef          std::forward_iterator_tag                 iterator_category;
    typedef typename std::iterator_traits<It>::value_type      value_type;
    typedef typename std::iterator_traits<It>::difference_type difference_type;
    typedef It                                                 pointer;
    typedef typename std::iterator_traits<It>::reference       reference;

    It base() const {return it_;}

    forward_iterator() : it_() {}
    explicit forward_iterator(It it) : it_(it) {}
    template <class U>
        forward_iterator(const forward_iterator<U>& u) :it_(u.it_) {}

    reference operator*() const {return *it_;}
    pointer operator->() const {return it_;}

    forward_iterator& operator++() {++it_; return *this;}
    forward_iterator operator++(int)
        {forward_iterator tmp(*this); ++(*this); return tmp;}

    friend bool operator==(const forward_iterator& x, const forward_iterator& y)
        {return x.it_ == y.it_;}
    friend bool operator!=(const forward_iterator& x, const forward_iterator& y)
        {return !(x == y);}

    template <class T>
    void operator,(T const &) DELETE_FUNCTION;
};

template <class T, class U>
inline
bool
operator==(const forward_iterator<T>& x, const forward_iterator<U>& y)
{
    return x.base() == y.base();
}

template <class T, class U>
inline
bool
operator!=(const forward_iterator<T>& x, const forward_iterator<U>& y)
{
    return !(x == y);
}

template <class It>
class bidirectional_iterator
{
    It it_;

    template <class U> friend class bidirectional_iterator;
public:
    typedef          std::bidirectional_iterator_tag           iterator_category;
    typedef typename std::iterator_traits<It>::value_type      value_type;
    typedef typename std::iterator_traits<It>::difference_type difference_type;
    typedef It                                                 pointer;
    typedef typename std::iterator_traits<It>::reference       reference;

    It base() const {return it_;}

    bidirectional_iterator() : it_() {}
    explicit bidirectional_iterator(It it) : it_(it) {}
    template <class U>
        bidirectional_iterator(const bidirectional_iterator<U>& u) :it_(u.it_) {}

    reference operator*() const {return *it_;}
    pointer operator->() const {return it_;}

    bidirectional_iterator& operator++() {++it_; return *this;}
    bidirectional_iterator operator++(int)
        {bidirectional_iterator tmp(*this); ++(*this); return tmp;}

    bidirectional_iterator& operator--() {--it_; return *this;}
    bidirectional_iterator operator--(int)
        {bidirectional_iterator tmp(*this); --(*this); return tmp;}

    template <class T>
    void operator,(T const &) DELETE_FUNCTION;
};

template <class T, class U>
inline
bool
operator==(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y)
{
    return x.base() == y.base();
}

template <class T, class U>
inline
bool
operator!=(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y)
{
    return !(x == y);
}

template <class It>
class random_access_iterator
{
    It it_;

    template <class U> friend class random_access_iterator;
public:
    typedef          std::random_access_iterator_tag           iterator_category;
    typedef typename std::iterator_traits<It>::value_type      value_type;
    typedef typename std::iterator_traits<It>::difference_type difference_type;
    typedef It                                                 pointer;
    typedef typename std::iterator_traits<It>::reference       reference;

    It base() const {return it_;}

    random_access_iterator() : it_() {}
    explicit random_access_iterator(It it) : it_(it) {}
   template <class U>
        random_access_iterator(const random_access_iterator<U>& u) :it_(u.it_) {}

    reference operator*() const {return *it_;}
    pointer operator->() const {return it_;}

    random_access_iterator& operator++() {++it_; return *this;}
    random_access_iterator operator++(int)
        {random_access_iterator tmp(*this); ++(*this); return tmp;}

    random_access_iterator& operator--() {--it_; return *this;}
    random_access_iterator operator--(int)
        {random_access_iterator tmp(*this); --(*this); return tmp;}

    random_access_iterator& operator+=(difference_type n) {it_ += n; return *this;}
    random_access_iterator operator+(difference_type n) const
        {random_access_iterator tmp(*this); tmp += n; return tmp;}
    friend random_access_iterator operator+(difference_type n, random_access_iterator x)
        {x += n; return x;}
    random_access_iterator& operator-=(difference_type n) {return *this += -n;}
    random_access_iterator operator-(difference_type n) const
        {random_access_iterator tmp(*this); tmp -= n; return tmp;}

    reference operator[](difference_type n) const {return it_[n];}

    template <class T>
    void operator,(T const &) DELETE_FUNCTION;
};

template <class T, class U>
inline
bool
operator==(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
    return x.base() == y.base();
}

template <class T, class U>
inline
bool
operator!=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
    return !(x == y);
}

template <class T, class U>
inline
bool
operator<(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
    return x.base() < y.base();
}

template <class T, class U>
inline
bool
operator<=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
    return !(y < x);
}

template <class T, class U>
inline
bool
operator>(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
    return y < x;
}

template <class T, class U>
inline
bool
operator>=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
    return !(x < y);
}

template <class T, class U>
inline
typename std::iterator_traits<T>::difference_type
operator-(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
{
    return x.base() - y.base();
}

template <class Iter>
inline Iter base(output_iterator<Iter> i) { return i.base(); }

template <class Iter>
inline Iter base(input_iterator<Iter> i) { return i.base(); }

template <class Iter>
inline Iter base(forward_iterator<Iter> i) { return i.base(); }

template <class Iter>
inline Iter base(bidirectional_iterator<Iter> i) { return i.base(); }

template <class Iter>
inline Iter base(random_access_iterator<Iter> i) { return i.base(); }

template <class Iter>    // everything else
inline Iter base(Iter i) { return i; }

template <typename T>
struct ThrowingIterator {
    typedef std::bidirectional_iterator_tag iterator_category;
    typedef ptrdiff_t                       difference_type;
    typedef const T                         value_type;
    typedef const T *                       pointer;
    typedef const T &                       reference;

	enum ThrowingAction { TAIncrement, TADecrement, TADereference, TAAssignment, TAComparison };

//	Constructors
	ThrowingIterator ()
		: begin_(nullptr), end_(nullptr), current_(nullptr), action_(TADereference), index_(0) {}
	ThrowingIterator (const T *first, const T *last, size_t index = 0, ThrowingAction action = TADereference)
		: begin_(first), end_(last), current_(first), action_(action), index_(index) {}
	ThrowingIterator (const ThrowingIterator &rhs)
		: begin_(rhs.begin_), end_(rhs.end_), current_(rhs.current_), action_(rhs.action_), index_(rhs.index_) {}
	ThrowingIterator & operator= (const ThrowingIterator &rhs)
	{
	if (action_ == TAAssignment)
	{
		if (index_ == 0)
			throw std::runtime_error ("throw from iterator assignment");
		else
			--index_;
	}
	begin_   = rhs.begin_;
	end_     = rhs.end_;
	current_ = rhs.current_;
	action_  = rhs.action_;
	index_   = rhs.index_;
	return *this;
	}

//	iterator operations
	reference operator*() const
	{
	if (action_ == TADereference)
	{
		if (index_ == 0)
			throw std::runtime_error ("throw from iterator dereference");
		else
			--index_;
	}
	return *current_;
	}

	ThrowingIterator & operator++()
	{
	if (action_ == TAIncrement)
	{
		if (index_ == 0)
			throw std::runtime_error ("throw from iterator increment");
		else
			--index_;
	}
	++current_;
	return *this;
	}
	
	ThrowingIterator operator++(int)
	{
		ThrowingIterator temp = *this;
		++(*this);
		return temp;
	}

	ThrowingIterator & operator--()
	{
	if (action_ == TADecrement)
	{
		if (index_ == 0)
			throw std::runtime_error ("throw from iterator decrement");
		else
			--index_;
	}
	--current_;
	return *this;
	}

	ThrowingIterator operator--(int) {
		ThrowingIterator temp = *this;
		--(*this);
		return temp;
	}

	bool operator== (const ThrowingIterator &rhs) const
	{
	if (action_ == TAComparison)
	{
		if (index_ == 0)
			throw std::runtime_error ("throw from iterator comparison");
		else
			--index_;
	}
	bool atEndL =     current_ == end_;
	bool atEndR = rhs.current_ == rhs.end_;
	if (atEndL != atEndR) return false;  // one is at the end (or empty), the other is not.
	if (atEndL) return true;			 // both are at the end (or empty)
	return current_ == rhs.current_;
	}

private:
	const T* begin_;
	const T* end_;
	const T* current_;
	ThrowingAction action_;
	mutable size_t index_;
};

template <typename T>
bool operator== (const ThrowingIterator<T>& a, const ThrowingIterator<T>& b)
{	return a.operator==(b); }

template <typename T>
bool operator!= (const ThrowingIterator<T>& a, const ThrowingIterator<T>& b)
{	return !a.operator==(b); }
	
template <typename T>
struct NonThrowingIterator {
    typedef std::bidirectional_iterator_tag iterator_category;
    typedef ptrdiff_t                       difference_type;
    typedef const T                         value_type;
    typedef const T *                       pointer;
    typedef const T &                       reference;

//	Constructors
	NonThrowingIterator ()
		: begin_(nullptr), end_(nullptr), current_(nullptr) {}
	NonThrowingIterator (const T *first, const T* last)
		: begin_(first), end_(last), current_(first) {}
	NonThrowingIterator (const NonThrowingIterator &rhs)
		: begin_(rhs.begin_), end_(rhs.end_), current_(rhs.current_) {}
	NonThrowingIterator & operator= (const NonThrowingIterator &rhs) TEST_NOEXCEPT
	{
	begin_   = rhs.begin_;
	end_     = rhs.end_;
	current_ = rhs.current_;
	return *this;
	}

//	iterator operations
	reference operator*() const TEST_NOEXCEPT
	{
	return *current_;
	}

	NonThrowingIterator & operator++() TEST_NOEXCEPT
	{
	++current_;
	return *this;
	}
	
	NonThrowingIterator operator++(int) TEST_NOEXCEPT
	{
		NonThrowingIterator temp = *this;
		++(*this);
		return temp;
	}

	NonThrowingIterator & operator--() TEST_NOEXCEPT
	{
	--current_;
	return *this;
	}

	NonThrowingIterator operator--(int) TEST_NOEXCEPT
	{
		NonThrowingIterator temp = *this;
		--(*this);
		return temp;
	}

	bool operator== (const NonThrowingIterator &rhs) const TEST_NOEXCEPT
	{
	bool atEndL =     current_ == end_;
	bool atEndR = rhs.current_ == rhs.end_;
	if (atEndL != atEndR) return false;  // one is at the end (or empty), the other is not.
	if (atEndL) return true;			 // both are at the end (or empty)
	return current_ == rhs.current_;
	}

private:
	const T* begin_;
	const T* end_;
	const T* current_;
};

template <typename T>
bool operator== (const NonThrowingIterator<T>& a, const NonThrowingIterator<T>& b) TEST_NOEXCEPT
{	return a.operator==(b); }

template <typename T>
bool operator!= (const NonThrowingIterator<T>& a, const NonThrowingIterator<T>& b) TEST_NOEXCEPT
{	return !a.operator==(b); }

#undef DELETE_FUNCTION

#endif  // ITERATORS_H