/******************************************************************************
    Trick Library 'ax'
        補助反復子クラステンプレートヘッダファイル
            Copyright(C) 2008 Wraith.   All rights reserved.
                                            Coded by Wraith in Jun 6, 2008.
******************************************************************************/


///////////////////////////////////////////////////////////////////////////////
//
//  ■ axiterat.h
//      http://tricklib.com/cxx/ax/axiterat.h
//
//  □ 関連ファイル
//      http://tricklib.com/cxx/ax/axconfig.h
//      http://tricklib.com/cxx/ax/axexcept.h
//      http://tricklib.com/cxx/ax/axmemory.h
//      http://tricklib.com/cxx/ax/axstring.h
//
//  □ ライセンス情報
//      http://tricklib.com/license.htm
//
//  ★ このファイルはC++標準ライブラリの <iterator> 相当のものになり、規格票
//  　(ISO/IEC 14882, JIS X 3014)の 24 章に基づき実装されています。
//

#ifndef TRICKLIB_AX_AXITERATOR_H
#define TRICKLIB_AX_AXITERATOR_H

#include "axconfig.h"
#include <stddef.h>

namespace tricklib
{

namespace ax
{

// 24.3 基本的要素
#if defined(TRICKLIB_AX_AVAILABLE_TEMPLATE_OVERLOADS)

template<class Iterator> struct iterator_traits
{
    typedef typename Iterator::difference_type difference_type;
    typedef typename Iterator::value_type value_type;
    typedef typename Iterator::pointer pointer;
    typedef typename Iterator::reference reference;
    typedef typename Iterator::iterator_category iterator_category;
};
template<class T> struct iterator_traits<T*>
{
    typedef ptrdiff_t difference_type;
    typedef T value_type;
    typedef T* pointer;
    typedef T& reference;
    typedef random_access_iterator_tag iterator_category;
};
template<class T> struct iterator_traits<const T*>
{
    typedef ptrdiff_t difference_type;
    typedef T value_type;
    typedef const T* pointer;
    typedef const T& reference;
    typedef random_access_iterator_tag iterator_category;
};
#if 0
template<class T> struct iterator_traits<T __far*>
{
    typedef long difference_type;
    typedef T value_type;
    typedef T __far* pointer;
    typedef T __far& reference;
    typedef random_access_iterator_tag iterator_category;
};
#endif
#endif

#if defined(TRICKLIB_AX_AVAILABLE_DEFAULT_TEMPLATE_ARGS)
// 24.3.2 基本的な反復子
template<class Category, class T, class Distance = ptrdiff_t, class Pointer = T *, class Reference = T &>
struct iterator
{
    typedef T value_type;
    typedef Distance difference_type;
    typedef Pointer pointer;
    typedef Reference reference;
    typedef Category iterator_category;
};
#else
// 24.3.2 基本的な反復子
template<class Category, class T>
struct iterator
{
    typedef T value_type;
    typedef ptrdiff_t difference_type;
    typedef T * pointer;
    typedef T & reference;
    typedef Category iterator_category;
};
#endif

struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag: public input_iterator_tag {};
struct bidirectional_iterator_tag: public forward_iterator_tag {};
struct random_access_iterator_tag: public bidirectional_iterator_tag {};


template<class T>
class ax_array_iterator :public iterator<random_access_iterator_tag, T>
{
public:
    typedef iterator<random_access_iterator_tag, T> base_type;
    typedef typename base_type::value_type  value_type;
    typedef typename base_type::difference_type  difference_type;
    typedef typename base_type::reference reference;
    typedef typename base_type::pointer pointer;
    typedef ax_array_iterator<T> this_type;
    
public:
    value_type * value;
    
public:
    ax_array_iterator(value_type * a_value = NULL) :value(a_value) { }
    ax_array_iterator(const this_type & a) :value(a.value) { }
    
    reference operator * () const
    {
        return *value;
    }
    pointer operator -> () const
    {
        return value;
    }
    this_type & operator ++ ()
    {
        ++value;
        return *this;
    }
    this_type operator ++ (int)
    {
        this_type result(*this);
        ++value;
        return result;
    }
    this_type & operator -- ()
    {
        --value;
        return *this;
    }
    this_type operator -- (int)
    {
        this_type result(*this);
        --value;
        return result;
    }
    this_type operator + (difference_type n) const
    {
        return this_type(value + n);
    }
    this_type & operator += (difference_type n)
    {
        value += n;
        return *this;
    }
    this_type operator - (difference_type n) const
    {
        return this_type(value -n);
    }    
    this_type & operator -= (difference_type n)
    {
        value -= n;
        return *this;
    }
    reference operator [] (difference_type n) const
    {
        return value[n];
    }
};

template<class T> inline
bool operator==(const ax_array_iterator<T> & x, const ax_array_iterator<T> & y)
{
    return x.value == y.value;
}
template<class T> inline
bool operator<(const ax_array_iterator<T> & x, const ax_array_iterator<T> & y)
{
    return x.value < y.value;
}
template<class T> inline
bool operator!=(const ax_array_iterator<T> & x, const ax_array_iterator<T> & y)
{
    return x.value != y.value;
}
template<class T> inline
bool operator>(const ax_array_iterator<T> & x, const ax_array_iterator<T> & y)
{
    return x.value > y.value;
}
template<class T> inline
bool operator>=(const ax_array_iterator<T> & x, const ax_array_iterator<T> & y)
{
    return x.value >= y.value;
}
template<class T> inline
bool operator<=(const ax_array_iterator<T> & x, const ax_array_iterator<T> & y)
{
    return x.value <= y.value;
}
template<class T> inline
typename ax_array_iterator<T>::difference_type operator-(const ax_array_iterator<T> & x, const ax_array_iterator<T> & y)
{
    return x.value -y.value;
}
template<class T> inline
ax_array_iterator<T> operator+(typename ax_array_iterator<T>::difference_type n, const ax_array_iterator<T>& x)
{
    return n +x.value;
}

// 24.3.4 反復子の演算
template<class InputIterator, class Distance> void advance(InputIterator & a_i, Distance a_n);
#if defined(TRICKLIB_AX_AVAILABLE_TEMPLATE_OVERLOADS)
template<class InputIterator> typename iterator_traits<InputIterator>::difference_type distance(InputIterator first, InputIterator last)
#else
template<class InputIterator> typename InputIterator::difference_type distance(InputIterator first, InputIterator last)
#endif
{
    ptrdiff_t i = 0;
    while(last != first)
    {
        ++first;
        ++i;
    }
    return i;
}


// 24.4 あらかじめ定義された反復子
template <class Iterator> class reverse_iterator
{
protected:
    Iterator current;
public:
    typedef Iterator iterator_type;
#if defined(TRICKLIB_AX_AVAILABLE_TEMPLATE_OVERLOADS)
    typedef typename iterator_traits<Iterator>::difference_type  difference_type;
    typedef typename iterator_traits<Iterator>::reference reference;
    typedef typename iterator_traits<Iterator>::pointer pointer;
#else
    typedef typename Iterator::difference_type  difference_type;
    typedef typename Iterator::reference reference;
    typedef typename Iterator::pointer pointer;
#endif
    
    reverse_iterator();
    explicit reverse_iterator(Iterator x);
    //template <class U> reverse_iterator(const reverse_iterator<U>& u);
    reverse_iterator(const reverse_iterator & u);
    
    Iterator base() const; // 明示的
    reference operator*() const;
    pointer operator->() const;
    reverse_iterator& operator++();
    reverse_iterator operator++(int);
    reverse_iterator& operator--();
    reverse_iterator operator--(int);
    reverse_iterator operator+ (difference_type n) const;
    reverse_iterator& operator+=(difference_type n);
    reverse_iterator operator- (difference_type n) const;
    reverse_iterator& operator-=(difference_type n);
    reference operator[](difference_type n) const;
};
template <class Iterator> bool operator==(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
template <class Iterator> bool operator<(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
template <class Iterator> bool operator!=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
template <class Iterator> bool operator>(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
template <class Iterator> bool operator>=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
template <class Iterator> bool operator<=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
template <class Iterator> typename reverse_iterator<Iterator>::difference_type operator-(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
template <class Iterator> reverse_iterator<Iterator> operator+(typename reverse_iterator<Iterator>::difference_type n, const reverse_iterator<Iterator>& x);
template <class Container> class back_insert_iterator;
template <class Container> back_insert_iterator<Container> back_inserter(Container& x);
template <class Container> class front_insert_iterator;
template <class Container> front_insert_iterator<Container> front_inserter(Container& x);
template <class Container> class insert_iterator;
template <class Container, class Iterator> insert_iterator<Container> inserter(Container& x, Iterator i);
// 24.5 ストリーム反復子
//template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t> class istream_iterator;
template <class T, class charT = char> class istream_iterator;
template <class T, class charT, class traits, class Distance>
//bool operator==(const istream_iterator<T,charT,traits,Distance>& x, const istream_iterator<T,charT,traits,Distance>& y);
bool operator==(const istream_iterator<T,charT>& x, const istream_iterator<T,charT>& y);
template <class T, class charT, class traits, class Distance>
//bool operator!=(const istream_iterator<T,charT,traits,Distance>& x, const istream_iterator<T,charT,traits,Distance>& y);
bool operator!=(const istream_iterator<T,charT>& x, const istream_iterator<T,charT>& y);
//template <class T, class charT = char, class traits = char_traits<charT> > class ostream_iterator;
template <class T, class charT = char> class ostream_iterator;
//template<class charT, class traits = char_traits<charT> > class istreambuf_iterator;
template<class charT> class istreambuf_iterator;
template <class charT, class traits>
//bool operator==(const istreambuf_iterator<charT,traits>& a, const istreambuf_iterator<charT,traits>& b);
bool operator==(const istreambuf_iterator<charT>& a, const istreambuf_iterator<charT>& b);
template <class charT, class traits>
//bool operator!=(const istreambuf_iterator<charT,traits>& a, const istreambuf_iterator<charT,traits>& b);
bool operator!=(const istreambuf_iterator<charT>& a, const istreambuf_iterator<charT>& b);
//template <class charT, class traits = char_traits<charT> > class ostreambuf_iterator;
template <class charT> class ostreambuf_iterator;


}

}

#endif  //  TRICKLIB_AX_AXITERATOR_H

/******************************************************************************
    □■□■                  Wraith the Trickster                  □■□■
    ■□■□ 〜I'll go with heaven's advantage and fool's wisdom.〜 ■□■□
******************************************************************************/