MARLEY (Model of Argon Reaction Low Energy Yields) v2.0.0
A Monte Carlo event generator for tens-of-MeV neutrino interactions
Loading...
Searching...
No Matches
IteratorToMember.hh
1
4//
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
20namespace 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.13.2