IteratorToPointerMember.hh

//
// This file is part of MARLEY (Model of Argon Reaction Low Energy Yields)
//
// MARLEY is free software: you can redistribute it and/or modify it under the
// terms of version 3 of the GNU General Public License as published by the
// Free Software Foundation.
//
// For the full text of the license please see COPYING or
// visit http://opensource.org/licenses/GPL-3.0
//
// Please respect the MCnet academic usage guidelines. See GUIDELINES
// or visit https://www.montecarlonet.org/GUIDELINES for details.
 
#pragma once
#include <iterator>
 
namespace marley {
 
  template< typename It, typename R > class IteratorToPointerMember
  {
 
  public:
 
    // Some typedefs
    typedef typename std::iterator_traits<It>::value_type
      T_pointer;
    typedef typename std::remove_reference<
      decltype( *std::declval<T_pointer>() ) >::type T;
    typedef typename std::iterator_traits<It>::iterator_category
      iterator_category;
    typedef typename std::iterator_traits<It>::difference_type
      difference_type;
    typedef R value_type;
    typedef R* pointer;
    typedef R& reference;
 
    IteratorToPointerMember(It from, R T::* memptr) :
      m_it(from), m_memptr(memptr){}
 
    // Operators *, ->, and [] are first forwarded to the contained
    // iterator, then extract the data member.
    virtual reference operator*() const;
    virtual pointer operator->() const;
    reference operator[](difference_type n) const;
 
    // All operators that have to do with position are forwarded
    // to the contained iterator.
    IteratorToPointerMember& operator++();
    IteratorToPointerMember operator++(int);
    IteratorToPointerMember& operator--();
    IteratorToPointerMember operator--(int);
    IteratorToPointerMember& operator+=(difference_type n);
    IteratorToPointerMember operator+(difference_type n) const;
    IteratorToPointerMember& operator-=(difference_type n);
    IteratorToPointerMember operator-(difference_type n) const;
 
    inline difference_type
      operator-(const IteratorToPointerMember<It, R>& rhs) const
      { return m_it - rhs.m_it; }
 
    bool operator==(const IteratorToPointerMember<It, R>& rhs) const
      { return m_it == rhs.m_it; }
    bool operator!=(const IteratorToPointerMember<It, R>& rhs) const
      { return m_it != rhs.m_it; }
 
    It m_it;
 
    protected:
    value_type T::* m_memptr;
 
  };
 
  // Member function operators
  template<typename It, typename R>
    inline typename IteratorToPointerMember<It, R>::reference
    IteratorToPointerMember<It, R>::operator*() const
    { return (**m_it).*m_memptr; }
 
  template<typename It, typename R>
    inline typename IteratorToPointerMember<It, R>::pointer
    IteratorToPointerMember<It, R>::operator->() const
    { return &((**m_it).*m_memptr); }
 
  template<typename It, typename R>
    inline typename IteratorToPointerMember<It, R>::reference
    IteratorToPointerMember<It, R>::operator[](difference_type n) const
    { return m_it[n].*m_memptr; }
 
  // Prefix operator++
  template<typename It, typename R>
    inline IteratorToPointerMember<It, R>&
    IteratorToPointerMember<It, R>::operator++()
    { ++m_it; return *this; }
 
  // Prefix operator--
  template<typename It, typename R>
    inline IteratorToPointerMember<It, R>&
    IteratorToPointerMember<It, R>::operator--()
    { --m_it; return *this; }
 
  template<typename It, typename R>
    inline IteratorToPointerMember<It, R>&
    IteratorToPointerMember<It, R>::operator+=(difference_type n)
    { m_it += n; return *this; }
 
  template<typename It, typename R>
    inline IteratorToPointerMember<It, R>&
    IteratorToPointerMember<It, R>::operator-=(difference_type n)
    { m_it -= n; return *this; }
 
  template<typename It, typename R>
    inline IteratorToPointerMember<It, R>
    IteratorToPointerMember<It, R>::operator+(difference_type n) const
    { return IteratorToPointerMember<It, R>(m_it + n, m_memptr); }
 
  template<typename It, typename R>
    inline IteratorToPointerMember<It, R>
    IteratorToPointerMember<It, R>::operator-(difference_type n) const
    { return IteratorToPointerMember<It, R>(m_it - n, m_memptr); }
 
  template<typename It, typename R>
    inline IteratorToPointerMember<It, R>
    IteratorToPointerMember<It, R>::operator++(int)
    {
      auto result = IteratorToPointerMember<It, R>(*this);
      ++m_it;
      return result;
    }
 
  template<typename It, typename R>
    inline IteratorToPointerMember<It, R>
    IteratorToPointerMember<It, R>::operator--(int)
    {
      auto result = IteratorToPointerMember<It, R>(*this);
      --m_it;
      return result;
    }
 
  template<typename It, typename R>
    IteratorToPointerMember<It, R>
    make_IteratorToPointerMember(It it, R std::iterator_traits<It>
      ::value_type::* memptr)
    { return IteratorToPointerMember<It, R>(it, memptr); }
}