/*

 *

 * Copyright (c) 1994

 * Hewlett-Packard Company

 *

 * Copyright (c) 1996-1998

 * Silicon Graphics Computer Systems, Inc.

 *

 * Copyright (c) 1997

 * Moscow Center for SPARC Technology

 *

 * Copyright (c) 1999

 * Boris Fomitchev

 *

 * This material is provided "as is", with absolutely no warranty expressed

 * or implied. Any use is at your own risk.

 *

 * Permission to use or copy this software for any purpose is hereby granted

 * without fee, provided the above notices are retained on all copies.

 * Permission to modify the code and to distribute modified code is granted,

 * provided the above notices are retained, and a notice that the code was

 * modified is included with the above copyright notice.

 *

 */

/* NOTE: This is an internal header file, included by other STL headers.

 *   You should not attempt to use it directly.

 */

#ifndef _STLP_INTERNAL_ITERATOR_H

#define _STLP_INTERNAL_ITERATOR_H

#ifndef _STLP_INTERNAL_ITERATOR_BASE_H

#  include <stl/_iterator_base.h>

#endif

_STLP_BEGIN_NAMESPACE

#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)

// This is the new version of reverse_iterator, as defined in the

//  draft C++ standard.  It relies on the iterator_traits template,

//  which in turn relies on partial specialization.  The class

//  reverse_bidirectional_iterator is no longer part of the draft

//  standard, but it is retained for backward compatibility.

template <class _Iterator>

class reverse_iterator :

  public iterator<typename iterator_traits<_Iterator>::iterator_category,

                  typename iterator_traits<_Iterator>::value_type,

                  typename iterator_traits<_Iterator>::difference_type,

                  typename iterator_traits<_Iterator>::pointer,

                  typename iterator_traits<_Iterator>::reference> {

protected:

  _Iterator current;

  typedef reverse_iterator<_Iterator> _Self;

public:

  typedef typename iterator_traits<_Iterator>::iterator_category  iterator_category;

  typedef typename iterator_traits<_Iterator>::value_type value_type;

  typedef typename iterator_traits<_Iterator>::difference_type difference_type;

  typedef typename iterator_traits<_Iterator>::pointer pointer;

  typedef typename iterator_traits<_Iterator>::reference reference;

  typedef _Iterator iterator_type;

public:

  reverse_iterator() {}

  explicit reverse_iterator(iterator_type __x) : current(__x) {}

  reverse_iterator(const _Self& __x) : current(__x.current) {}

  _Self& operator = (const _Self& __x) { current = __x.base(); return *this; }

#  if defined (_STLP_MEMBER_TEMPLATES)

  template <class _Iter>

  reverse_iterator(const reverse_iterator<_Iter>& __x) : current(__x.base()) {}

  template <class _Iter>

  _Self& operator = (const reverse_iterator<_Iter>& __x) { current = __x.base(); return *this; }

#  endif /* _STLP_MEMBER_TEMPLATES */

  iterator_type base() const { return current; }

  reference operator*() const {

    _Iterator __tmp = current;

    return *--__tmp;

  }

  _STLP_DEFINE_ARROW_OPERATOR

  _Self& operator++() {

    --current;

    return *this;

  }

  _Self operator++(int) {

    _Self __tmp = *this;

    --current;

    return __tmp;

  }

  _Self& operator--() {

    ++current;

    return *this;

  }

  _Self operator--(int) {

    _Self __tmp = *this;

    ++current;

    return __tmp;

  }

  _Self operator+(difference_type __n) const { return _Self(current - __n); }

  _Self& operator+=(difference_type __n) {

    current -= __n;

    return *this;

  }

  _Self operator-(difference_type __n) const { return _Self(current + __n); }

  _Self& operator-=(difference_type __n) {

    current += __n;

    return *this;

  }

  reference operator[](difference_type __n) const { return *(*this + __n); }

};

template <class _Iterator>

inline bool  _STLP_CALL operator==(const reverse_iterator<_Iterator>& __x,

                                   const reverse_iterator<_Iterator>& __y)

{ return __x.base() == __y.base(); }

template <class _Iterator>

inline bool _STLP_CALL operator<(const reverse_iterator<_Iterator>& __x,

                                 const reverse_iterator<_Iterator>& __y)

{ return __y.base() < __x.base(); }

#  if defined (_STLP_USE_SEPARATE_RELOPS_NAMESPACE)

template <class _Iterator>

inline bool _STLP_CALL operator!=(const reverse_iterator<_Iterator>& __x,

                                  const reverse_iterator<_Iterator>& __y)

{ return !(__x == __y); }

template <class _Iterator>

inline bool _STLP_CALL operator>(const reverse_iterator<_Iterator>& __x,

                                 const reverse_iterator<_Iterator>& __y)

{ return __y < __x; }

template <class _Iterator>

inline bool _STLP_CALL operator<=(const reverse_iterator<_Iterator>& __x,

                                  const reverse_iterator<_Iterator>& __y)

{ return !(__y < __x); }

template <class _Iterator>

inline bool _STLP_CALL operator>=(const reverse_iterator<_Iterator>& __x,

                                  const reverse_iterator<_Iterator>& __y)

{ return !(__x < __y); }

#  endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */

template <class _Iterator>

#  if defined (__SUNPRO_CC)

inline ptrdiff_t _STLP_CALL

#  else

inline typename reverse_iterator<_Iterator>::difference_type _STLP_CALL

#  endif

operator-(const reverse_iterator<_Iterator>& __x,

          const reverse_iterator<_Iterator>& __y)

{ return __y.base() - __x.base(); }

template <class _Iterator, class _DifferenceType>

inline reverse_iterator<_Iterator>  _STLP_CALL

operator+(_DifferenceType n,const reverse_iterator<_Iterator>& x)

{ return x.operator+(n); }

#endif

template <class _Container>

class back_insert_iterator

  : public iterator<output_iterator_tag, void, void, void, void> {

  typedef back_insert_iterator<_Container> _Self;

protected:

  //c is a Standard name (24.4.2.1), do no make it STLport naming convention compliant.

  _Container *container;

public:

  typedef _Container          container_type;

  typedef output_iterator_tag iterator_category;

  explicit back_insert_iterator(_Container& __x) : container(&__x) {}

  _Self& operator=(const _Self& __other) {

    container = __other.container;

    return *this;

  }

  _Self& operator=(const typename _Container::value_type& __val) {

    container->push_back(__val);

    return *this;

  }

  _Self& operator*() { return *this; }

  _Self& operator++() { return *this; }

  _Self  operator++(int) { return *this; }

};

template <class _Container>

inline back_insert_iterator<_Container>  _STLP_CALL back_inserter(_Container& __x)

{ return back_insert_iterator<_Container>(__x); }

template <class _Container>

class front_insert_iterator

  : public iterator<output_iterator_tag, void, void, void, void> {

  typedef front_insert_iterator<_Container> _Self;

protected:

  //c is a Standard name (24.4.2.3), do no make it STLport naming convention compliant.

  _Container *container;

public:

  typedef _Container          container_type;

  typedef output_iterator_tag iterator_category;

  explicit front_insert_iterator(_Container& __x) : container(&__x) {}

  _Self& operator=(const _Self& __other) {

    container = __other.container;

    return *this;

  }

  _Self& operator=(const typename _Container::value_type& __val) {

    container->push_front(__val);

    return *this;

  }

  _Self& operator*() { return *this; }

  _Self& operator++() { return *this; }

  _Self  operator++(int) { return *this; }

};

template <class _Container>

inline front_insert_iterator<_Container>  _STLP_CALL front_inserter(_Container& __x)

{ return front_insert_iterator<_Container>(__x); }

template <class _Container>

class insert_iterator

  : public iterator<output_iterator_tag, void, void, void, void> {

  typedef insert_iterator<_Container> _Self;

protected:

  //container is a Standard name (24.4.2.5), do no make it STLport naming convention compliant.

  _Container *container;

  typename _Container::iterator _M_iter;

public:

  typedef _Container          container_type;

  typedef output_iterator_tag iterator_category;

  insert_iterator(_Container& __x, typename _Container::iterator __i)

    : container(&__x), _M_iter(__i) {}

  _Self& operator=(_Self const& __other) {

    container = __other.container;

    _M_iter = __other._M_iter;

    return *this;

  }

  _Self& operator=(const typename _Container::value_type& __val) {

    _M_iter = container->insert(_M_iter, __val);

    ++_M_iter;

    return *this;

  }

  _Self& operator*() { return *this; }

  _Self& operator++() { return *this; }

  _Self& operator++(int) { return *this; }

};

template <class _Container, class _Iterator>

inline insert_iterator<_Container>  _STLP_CALL

inserter(_Container& __x, _Iterator __i) {

  typedef typename _Container::iterator __iter;

  return insert_iterator<_Container>(__x, __iter(__i));

}

_STLP_END_NAMESPACE

#if ! defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) || defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)

#  include <stl/_iterator_old.h>

#endif

#endif /* _STLP_INTERNAL_ITERATOR_H */

// Local Variables:

// mode:C++

// End: