MARLEY (Model of Argon Reaction Low Energy Yields)  v1.2.0
A Monte Carlo event generator for tens-of-MeV neutrino interactions
IteratorToMember.hh
1 //
5 // This file is part of MARLEY (Model of Argon Reaction Low Energy Yields)
6 //
7 // MARLEY is free software: you can redistribute it and/or modify it under the
8 // terms of version 3 of the GNU General Public License as published by the
9 // Free Software Foundation.
10 //
11 // For the full text of the license please see COPYING or
12 // visit http://opensource.org/licenses/GPL-3.0
13 //
14 // Please respect the MCnet academic usage guidelines. See GUIDELINES
15 // or visit https://www.montecarlonet.org/GUIDELINES for details.
16 
17 #pragma once
18 #include <iterator>
19 
20 namespace marley {
21 
29  template< typename It, typename R > class IteratorToMember
30  {
31 
32  public:
33 
34  // Some typedefs
36  typedef typename std::iterator_traits<It>::value_type T;
37  typedef typename std::iterator_traits<It>::iterator_category
38  iterator_category;
39  typedef typename std::iterator_traits<It>::difference_type
40  difference_type;
41  typedef R value_type;
42  typedef R* pointer;
43  typedef R& reference;
44 
48  IteratorToMember(It from, R T::* memptr)
49  : m_it(from), m_memptr(memptr){}
50 
51  // Operators *, ->, and [] are first forwarded to the contained
52  // iterator, then extract the data member.
53  reference operator*() const;
54  pointer operator->() const;
55  reference operator[](difference_type n) const;
56 
57  // All operators that have to do with position are forwarded
58  // to the contained iterator.
59  IteratorToMember& operator++();
60  IteratorToMember operator++(int);
61  IteratorToMember& operator--();
62  IteratorToMember operator--(int);
63  IteratorToMember& operator+=(difference_type n);
64  IteratorToMember operator+(difference_type n) const;
65  IteratorToMember& operator-=(difference_type n);
66  IteratorToMember operator-(difference_type n) const;
67 
68  inline difference_type
69  operator-(const IteratorToMember<It, R>& rhs) const
70  { return m_it - rhs.m_it; }
71 
72  bool operator==(const IteratorToMember<It, R>& rhs) const
73  { return m_it == rhs.m_it; }
74 
75  bool operator!=(const IteratorToMember<It, R>& rhs) const
76  { return m_it != rhs.m_it; }
77 
78  It m_it;
79 
80  protected:
81  value_type T::* m_memptr;
82 
83  };
84 
85  // Member function operators
86  template<typename It, typename R>
87  inline typename IteratorToMember<It, R>::reference
88  IteratorToMember<It, R>::operator*() const
89  { return (*m_it).*m_memptr; }
90 
91  template<typename It, typename R>
92  inline typename IteratorToMember<It, R>::pointer
93  IteratorToMember<It, R>::operator->() const
94  { return &((*m_it).*m_memptr); }
95 
96  template<typename It, typename R>
97  inline typename IteratorToMember<It, R>::reference
98  IteratorToMember<It, R>::operator[](difference_type n) const
99  { return m_it[n].*m_memptr; }
100 
101  // Prefix operator++
102  template<typename It, typename R>
103  inline IteratorToMember<It, R>&
104  IteratorToMember<It, R>::operator++()
105  { ++m_it; return *this; }
106 
107  // Prefix operator--
108  template<typename It, typename R>
109  inline IteratorToMember<It, R>&
110  IteratorToMember<It, R>::operator--()
111  { --m_it; return *this; }
112 
113  template<typename It, typename R>
114  inline IteratorToMember<It, R>&
115  IteratorToMember<It, R>::operator+=(difference_type n)
116  { m_it += n; return *this; }
117 
118  template<typename It, typename R>
119  inline IteratorToMember<It, R>&
120  IteratorToMember<It, R>::operator-=(difference_type n)
121  { m_it -= n; return *this; }
122 
123  template<typename It, typename R>
124  inline IteratorToMember<It, R>
125  IteratorToMember<It, R>::operator+(difference_type n) const
126  { return IteratorToMember<It, R>(m_it + n, m_memptr); }
127 
128  template<typename It, typename R>
129  inline IteratorToMember<It, R>
130  IteratorToMember<It, R>::operator-(difference_type n) const
131  { return IteratorToMember<It, R>(m_it - n, m_memptr); }
132 
137  template<typename It, typename R>
138  inline IteratorToMember<It, R>
139  IteratorToMember<It, R>::operator++(int)
140  {
141  auto result = IteratorToMember<It, R>(*this);
142  ++m_it;
143  return result;
144  }
145 
147  template<typename It, typename R>
148  inline IteratorToMember<It, R>
149  IteratorToMember<It, R>::operator--(int)
150  {
151  auto result = IteratorToMember<It, R>(*this);
152  --m_it;
153  return result;
154  }
155 
157  template<typename It, typename R>
158  IteratorToMember<It, R>
159  make_IteratorToMember(It it, R std::iterator_traits<It>
160  ::value_type::* memptr)
161  { return IteratorToMember<It, R>(it, memptr); }
162 
163 }
marley::IteratorToMember
Template class that creates an iterator to a class member based on an iterator to the class object.
Definition: IteratorToMember.hh:30
marley::IteratorToMember::T
std::iterator_traits< It >::value_type T
Type pointed to by original iterator.
Definition: IteratorToMember.hh:36
marley::IteratorToMember::IteratorToMember
IteratorToMember(It from, R T::*memptr)
Construction from an iterator and a pointer to member.
Definition: IteratorToMember.hh:48
Generated by doxygen 1.9.1