MemFunIterator.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ads_MemFunIterator_h__)
#define __ads_MemFunIterator_h__

#include "AdaptedIterator.h"

#include "../../third-party/loki/TypeManip.h"

BEGIN_NAMESPACE_ADS


template<typename _Iterator, class Pointee, typename Result, bool Const = true>
class MemFunIterator :
  public AdaptedIterator<
  _Iterator,
  typename std::iterator_traits<_Iterator>::iterator_category,
  Result,
  typename std::iterator_traits<_Iterator>::difference_type,
  void,  // We don't use the pointer type.
  void>  { // We don't use the reference type.
  //
  // Private types.
  //

private:

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

  //
  // Public types.
  //

public:

  // 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;

  typedef typename Base::Iterator Iterator;

  // CONTINUE:
  // I would like to define the pointee type as below and not have it as 
  // a template parameter, but MSVC++ does not like the typedef below.
  //typedef typename std::iterator_traits<Iterator>::value_type pointee_type;

  //
  // Private types.
  //

private:

  typedef value_type (Pointee::*mem_fun)();
  typedef value_type (Pointee::*mem_fun_const)() const;

  //
  // Public types.
  //

public:

  typedef typename Loki::Select<Const, mem_fun_const, mem_fun>::Result 
  MemberFunction;
  
  //
  // Member data.
  //

private:

  MemberFunction _f;

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


  MemFunIterator() :
    Base(),
    _f()
  {}

  MemFunIterator(MemberFunction f) :
    Base(),
    _f(f)
  {}

  MemFunIterator(MemberFunction f, const Iterator& i) :
    Base(i),
    _f(f)
  {}

  MemFunIterator(const MemFunIterator& x) :
    Base(x),
    _f(x._f)
  {}

  MemFunIterator& 
  operator=(const MemFunIterator& other) {
    Base::operator=(other);
    _f = other._f;
    return *this;
  }

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

  MemFunIterator& 
  operator=(MemberFunction f) {
    _f = f;
    return *this;
  }

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


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

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

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


  //
  // Trivial iterator requirements.
  //

  value_type
  operator*() const {
    // CONTINUE: Try to understand this.
    //return (Base::_iterator->*_f)();
    return ((*Base::_iterator).*_f)();
  }

  /* CONTINUE
  pointer
  operator->() const
  {
    return *Base::_iterator;
  }
  */

  //
  // Forward iterator requirements.
  //

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

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

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

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

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

  //
  // Random access iterator requirements.
  //

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

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

  MemFunIterator
  operator+(const difference_type& n) const {
    MemFunIterator x(*this);
    x += n;
    return x;
  }

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

  MemFunIterator
  operator-(const difference_type& n) const {
    MemFunIterator x(*this);
    x -= n;
    return x;
  }

};

//
// Random access iterator requirements.
//


template<typename Iterator, class Pointee, typename Result, bool Const>
inline
MemFunIterator<Iterator,Pointee,Result,Const>
operator+(typename MemFunIterator<Iterator,Pointee,Result,Const>::
           difference_type n,
           const MemFunIterator<Iterator,Pointee,Result,Const>& x) {
  return x + n;
}

// CONTINUE
#if 0

template<typename _Iterator, typename Result>
inline
MemFunIterator<_Iterator,Result>
constructMemFunIterator
(Result ((typename MemFunIterator<_Iterator,Result>::pointee_type)::*f)()) {
  return MemFunIterator<_Iterator,Result>(f);
}


template<typename _Iterator, typename Result>
inline
MemFunIterator<_Iterator,Result>
constructMemFunIterator
(Result ((typename MemFunIterator<_Iterator,Result>::pointee_type)::*f)(),
  const _Iterator& i) {
  return MemFunIterator<_Iterator,Result>(f, i);
}
#endif

END_NAMESPACE_ADS

#endif

---