1 // -*- C++ -*-
2
3 // Copyright (C) 2007-2023 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the terms
7 // of the GNU General Public License as published by the Free Software
8 // Foundation; either version 3, or (at your option) any later
9 // version.
10
11 // This library is distributed in the hope that it will be useful, but
12 // WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // General Public License for more details.
15
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24
25 /** @file parallel/iterator.h
26 * @brief Helper iterator classes for the std::transform() functions.
27 * This file is a GNU parallel extension to the Standard C++ Library.
28 */
29
30 // Written by Johannes Singler.
31
32 #ifndef _GLIBCXX_PARALLEL_ITERATOR_H
33 #define _GLIBCXX_PARALLEL_ITERATOR_H 1
34
35 #include <parallel/basic_iterator.h>
36 #include <bits/stl_pair.h>
37
38 namespace __gnu_parallel
39 {
40 /** @brief A pair of iterators. The usual iterator operations are
41 * applied to both child iterators.
42 */
43 template<typename _Iterator1, typename _Iterator2,
44 typename _IteratorCategory>
45 class _IteratorPair : public std::pair<_Iterator1, _Iterator2>
46 {
47 private:
48 typedef std::pair<_Iterator1, _Iterator2> _Base;
49
50 public:
51 typedef _IteratorCategory iterator_category;
52 typedef void value_type;
53
54 typedef std::iterator_traits<_Iterator1> _TraitsType;
55 typedef typename _TraitsType::difference_type difference_type;
56 typedef _IteratorPair* pointer;
57 typedef _IteratorPair& reference;
58
59 _IteratorPair() { }
60
61 _IteratorPair(const _Iterator1& __first, const _Iterator2& __second)
62 : _Base(__first, __second) { }
63
64 // Pre-increment operator.
65 _IteratorPair&
66 operator++()
67 {
68 ++_Base::first;
69 ++_Base::second;
70 return *this;
71 }
72
73 // Post-increment operator.
74 const _IteratorPair
75 operator++(int)
76 { return _IteratorPair(_Base::first++, _Base::second++); }
77
78 // Pre-decrement operator.
79 _IteratorPair&
80 operator--()
81 {
82 --_Base::first;
83 --_Base::second;
84 return *this;
85 }
86
87 // Post-decrement operator.
88 const _IteratorPair
89 operator--(int)
90 { return _IteratorPair(_Base::first--, _Base::second--); }
91
92 // Type conversion.
93 operator _Iterator2() const
94 { return _Base::second; }
95
96 _IteratorPair&
97 operator=(const _IteratorPair& __other)
98 {
99 _Base::first = __other.first;
100 _Base::second = __other.second;
101 return *this;
102 }
103
104 _IteratorPair
105 operator+(difference_type __delta) const
106 { return _IteratorPair(_Base::first + __delta, _Base::second + __delta);
107 }
108
109 difference_type
110 operator-(const _IteratorPair& __other) const
111 { return _Base::first - __other.first; }
112 };
113
114
115 /** @brief A triple of iterators. The usual iterator operations are
116 applied to all three child iterators.
117 */
118 template<typename _Iterator1, typename _Iterator2, typename _Iterator3,
119 typename _IteratorCategory>
120 class _IteratorTriple
121 {
122 public:
123 typedef _IteratorCategory iterator_category;
124 typedef void value_type;
125 typedef typename std::iterator_traits<_Iterator1>::difference_type
126 difference_type;
127 typedef _IteratorTriple* pointer;
128 typedef _IteratorTriple& reference;
129
130 _Iterator1 _M_first;
131 _Iterator2 _M_second;
132 _Iterator3 _M_third;
133
134 _IteratorTriple() { }
135
136 _IteratorTriple(const _Iterator1& __first, const _Iterator2& __second,
137 const _Iterator3& __third)
138 {
139 _M_first = __first;
140 _M_second = __second;
141 _M_third = __third;
142 }
143
144 // Pre-increment operator.
145 _IteratorTriple&
146 operator++()
147 {
148 ++_M_first;
149 ++_M_second;
150 ++_M_third;
151 return *this;
152 }
153
154 // Post-increment operator.
155 const _IteratorTriple
156 operator++(int)
157 { return _IteratorTriple(_M_first++, _M_second++, _M_third++); }
158
159 // Pre-decrement operator.
160 _IteratorTriple&
161 operator--()
162 {
163 --_M_first;
164 --_M_second;
165 --_M_third;
166 return *this;
167 }
168
169 // Post-decrement operator.
170 const _IteratorTriple
171 operator--(int)
172 { return _IteratorTriple(_M_first--, _M_second--, _M_third--); }
173
174 // Type conversion.
175 operator _Iterator3() const
176 { return _M_third; }
177
178 _IteratorTriple&
179 operator=(const _IteratorTriple& __other)
180 {
181 _M_first = __other._M_first;
182 _M_second = __other._M_second;
183 _M_third = __other._M_third;
184 return *this;
185 }
186
187 _IteratorTriple
188 operator+(difference_type __delta) const
189 { return _IteratorTriple(_M_first + __delta, _M_second + __delta,
190 _M_third + __delta); }
191
192 difference_type
193 operator-(const _IteratorTriple& __other) const
194 { return _M_first - __other._M_first; }
195 };
196 }
197
198 #endif /* _GLIBCXX_PARALLEL_ITERATOR_H */