MemberIterator.hpp

Go to the documentation of this file.

//
// This file is part of MorphoGraphX - http://www.MorphoGraphX.org
// Copyright (C) 2012-2015 Richard S. Smith and collaborators.
//
// If you use MorphoGraphX in your work, please cite:
//   http://dx.doi.org/10.7554/eLife.05864
//
// MorphoGraphX is free software, and is licensed under under the terms of the 
// GNU General (GPL) Public License version 2.0, http://www.gnu.org/licenses.
// 
#ifndef MEMBER_ITERATOR_HPP
#define MEMBER_ITERATOR_HPP
 
#include <Config.hpp>
 
#include <iterator>
 
namespace mgx 
{
  template <class Iterator, class Derived> struct BaseIterator 
  {
    typedef Iterator base_iterator;
    typedef typename std::iterator_traits<Iterator>::difference_type difference_type;
  
    BaseIterator() : it() {}
  
    BaseIterator(const base_iterator& i) : it(i) {}
  
    BaseIterator(const BaseIterator& other) : it(other.it) {}
  
 
  
    bool operator==(const Derived& other) const { return it == other.it; }
  
    bool operator!=(const Derived& other) const { return it != other.it; }
  
    Derived& operator=(const Derived& copy)
    {
      it = copy.it;
      return static_cast<Derived&>(*this);
    }
  
    Derived& operator++()
    {
      ++it;
      return static_cast<Derived&>(*this);
    }
    Derived& operator++(int)
    {
      Derived tmp(*this);
      ++it;
      return tmp;
    }
  
 
 
    Derived& operator--()
    {
      --it;
      return static_cast<Derived&>(*this);
    }
    Derived& operator--(int)
    {
      Derived tmp(*this);
      --it;
      return tmp;
    }
  
 
 
    Derived& operator+=(difference_type n)
    {
      it += n;
      return static_cast<Derived&>(*this);
    }
  
    Derived& operator-=(difference_type n)
    {
      it -= n;
      return static_cast<Derived&>(*this);
    }
  
    bool operator<(const Derived& other) const {
      return it < other.it;
    }
  
    bool operator>(const Derived& other) const {
      return it > other.it;
    }
  
    bool operator<=(const Derived& other) const {
      return it <= other.it;
    }
  
    bool operator>=(const Derived& other) const {
      return it >= other.it;
    }
  
 
    friend Derived operator+(const Derived& it, difference_type n)
    {
      Derived tmp(it);
      tmp += n;
      return tmp;
    }
  
    friend Derived operator+(difference_type n, const Derived& it)
    {
      Derived tmp(it);
      tmp += n;
      return tmp;
    }
  
    friend Derived operator-(const Derived& it, difference_type n)
    {
      Derived tmp(it);
      tmp -= n;
      return tmp;
    }
  
    friend Derived operator-(difference_type n, const Derived& it)
    {
      Derived tmp(it);
      tmp -= n;
      return tmp;
    }
  
    friend difference_type operator-(const Derived& last, const Derived& first) {
      return last.it - first.it;
    }
  
    base_iterator base() const {
      return it;
    }
  
  protected:
    base_iterator it;
  };
  
  template <class Iterator, class T, T std::iterator_traits<Iterator>::value_type::*member, class Reference = T&,
            class Pointer = T*>
  struct SelectMemberIterator
    : public BaseIterator<Iterator, SelectMemberIterator<Iterator, T, member, Reference, Pointer> > {
    typedef BaseIterator<Iterator, SelectMemberIterator<Iterator, T, member, Reference, Pointer> > Super;
    typedef Iterator base_iterator;
    typedef typename std::iterator_traits<Iterator>::iterator_category iterator_category;
    typedef T value_type;
    typedef typename std::iterator_traits<Iterator>::difference_type difference_type;
    typedef Reference reference;
    typedef Pointer pointer;
  
    SelectMemberIterator() {
    }
  
    SelectMemberIterator(const base_iterator& i)
      : Super(i)
    {
    }
  
    SelectMemberIterator(const SelectMemberIterator& other)
      : Super(other)
    {
    }
  
    reference operator*() {
      return (*this->it).*member;
    }
    const reference operator*() const {
      return (*this->it).*member;
    }
  
    pointer operator->() {
      return &((*this->it).*member);
    }
    const pointer operator->() const {
      return &((*this->it).*member);
    }
  };
  
  template <typename T> struct remove_pointer;
  
  template <typename T> struct remove_pointer<T*> {
    typedef T type;
  };
  
  template <class Iterator, class T, T remove_pointer<typename std::iterator_traits<Iterator>::value_type>::type::*member,
            class Reference = T&, class Pointer = T*>
  struct SelectMemberPointerIterator
    : public BaseIterator<Iterator, SelectMemberPointerIterator<Iterator, T, member, Reference, Pointer> > {
    typedef BaseIterator<Iterator, SelectMemberPointerIterator<Iterator, T, member, Reference, Pointer> > Super;
    typedef Iterator base_iterator;
    typedef typename std::iterator_traits<Iterator>::iterator_category iterator_category;
    typedef T value_type;
    typedef typename std::iterator_traits<Iterator>::difference_type difference_type;
    typedef Reference reference;
    typedef Pointer pointer;
  
    SelectMemberPointerIterator() {
    }
  
    SelectMemberPointerIterator(const base_iterator& i)
      : Super(i)
    {
    }
  
    SelectMemberPointerIterator(const SelectMemberPointerIterator& other)
      : Super(other)
    {
    }
  
    reference operator*() {
      return (**this->it).*member;
    }
    const reference operator*() const {
      return (**this->it).*member;
    }
  
    pointer operator->() {
      return &((**this->it).*member);
    }
    const pointer operator->() const {
      return &((**this->it).*member);
    }
  };
}
#endif