TransformIterator.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ads_TransformIterator_h__)
#define __ads_TransformIterator_h__

#include "AdaptedIterator.h"

#include "../functor/index.h"

BEGIN_NAMESPACE_ADS


template<typename _Iterator, class _Transform>
class TransformIterator :
  public AdaptedIterator<
  _Iterator,
  typename std::iterator_traits<_Iterator>::iterator_category,
  typename _Transform::result_type,
  typename std::iterator_traits<_Iterator>::difference_type,
  void,
  void> {
private:

  //
  // Private types.
  //

  typedef AdaptedIterator<
  _Iterator,
  typename std::iterator_traits<_Iterator>::iterator_category,
  typename _Transform::result_type,
  typename std::iterator_traits<_Iterator>::difference_type,
  void,
  void> Base;

public:

  //
  // Public types.
  //

  typedef typename Base::Iterator Iterator;
  typedef _Transform Transform;

  // The following five types are required to be defined for any iterator.

  typedef typename Base::iterator_category iterator_category;
  typedef typename Base::value_type value_type;
  typedef typename Base::difference_type difference_type;
  typedef typename Base::pointer pointer;
  typedef typename Base::reference reference;

private:
  
  //
  // Member data.
  //

  Transform _transform;

public:
  
  //--------------------------------------------------------------------------


  TransformIterator() :
    Base(),
    _transform()
  {}

  TransformIterator(const TransformIterator& x) :
    Base(x),
    _transform(x._transform)
  {}

  TransformIterator& 
  operator=(const TransformIterator& x) {
    // For the sake of efficiency, don't assign the transform.
    Base::operator=(x);
    return *this;
  }

  explicit
  TransformIterator(const Iterator& i) :
    Base(i),
    _transform()
  {}

  TransformIterator(const Transform& t) :
    Base(),
    _transform(t)
  {}

  TransformIterator(const Iterator& i, const Transform& t) :
    Base(i),
    _transform(t)
  {}

  TransformIterator& 
  operator=(const Iterator& i) {
    Base::operator=(i);
    return *this;
  }

  //--------------------------------------------------------------------------


  const Iterator&
  base() const {
    return Base::base();
  }

  const Transform&
  transform() const {
    return _transform;
  }

  //--------------------------------------------------------------------------

  //
  // Trivial iterator requirements.
  //

  value_type
  operator*() const {
    return _transform(*Base::_iterator);
  }

  //
  // Forward iterator requirements.
  //

  TransformIterator&
  operator++() {
    ++Base::_iterator;
    return *this;
  }

  TransformIterator
  operator++(int) {
    TransformIterator tmp = *this;
    ++Base::_iterator;
    return tmp;
  }

  //
  // Bi-directional iterator requirements.
  //

  TransformIterator&
  operator--() {
    --Base::_iterator;
    return *this;
  }

  TransformIterator
  operator--(int) {
    TransformIterator tmp = *this;
    --Base::_iterator;
    return tmp;
  }

  //
  // Random access iterator requirements.
  //

  value_type
  operator[](const difference_type& n) const {
    return _transform(Base::_iterator[n]);
  }

  TransformIterator&
  operator+=(const difference_type& n) {
    Base::_iterator += n;
    return *this;
  }

  TransformIterator
  operator+(const difference_type& n) const {
    return TransformIterator(Base::_iterator + n);
  }

  TransformIterator&
  operator-=(const difference_type& n) {
    Base::_iterator -= n;
    return *this;
  }

  TransformIterator
  operator-(const difference_type& n) const {
    return TransformIterator(Base::_iterator - n);
  }

};

//
// Random access iterator requirements.
//


template<typename _Iterator, class _Transform>
inline
TransformIterator<_Iterator,_Transform>
operator+(typename TransformIterator<_Iterator,_Transform>::difference_type n,
          const TransformIterator<_Iterator,_Transform>& x) {
  return x + n;
}


template<typename _Iterator, class _Transform>
inline
TransformIterator<_Iterator,_Transform>
constructTransformIterator() {
  return TransformIterator<_Iterator,_Transform>();
}


template<typename _Iterator, class _Transform>
inline
TransformIterator<_Iterator,_Transform>
constructTransformIterator
(const typename TransformIterator<_Iterator,_Transform>::Iterator& i) {
  return TransformIterator<_Iterator,_Transform>(i);
}


template<typename _Iterator, class _Transform>
inline
TransformIterator<_Iterator,_Transform>
constructTransformIterator
(const typename TransformIterator<_Iterator,_Transform>::Transform& t) {
  return TransformIterator<_Iterator,_Transform>(t);
}


template<typename _Iterator, class _Transform>
inline
TransformIterator<_Iterator,_Transform>
constructTransformIterator
(const typename TransformIterator<_Iterator,_Transform>::Iterator& i,
 const typename TransformIterator<_Iterator,_Transform>::Transform& t) {
  return TransformIterator<_Iterator,_Transform>(i, t);
}


template<typename IntIter, typename DataIter>
inline
TransformIterator<IntIter, IndexIterUnary<DataIter> >
constructArrayIndexingIterator(IntIter i, DataIter d) {
  IndexIterUnary<DataIter> f(d);
  return TransformIterator<IntIter, IndexIterUnary<DataIter> >(i, f);
}

END_NAMESPACE_ADS

#endif

---