libpqxx
The C++ client library for PostgreSQL
Loading...
Searching...
No Matches
result_iterator.hxx
1/* Definitions for the pqxx::result class and support classes.
2 *
3 * pqxx::result represents the set of result rows from a database query.
4 *
5 * DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/result instead.
6 *
7 * Copyright (c) 2000-2024, Jeroen T. Vermeulen.
8 *
9 * See COPYING for copyright license. If you did not receive a file called
10 * COPYING with this source code, please notify the distributor of this
11 * mistake, or contact the author.
12 */
13#ifndef PQXX_H_RESULT_ITERATOR
14#define PQXX_H_RESULT_ITERATOR
15
16#include "pqxx/row.hxx"
17
18
19/* Result iterator.
20 *
21 * Don't include this header from your own application; it is included for you
22 * by other libpqxx headers.
23 */
24
25namespace pqxx
26{
28
32class PQXX_LIBEXPORT const_result_iterator : public row
33{
34public:
35 using iterator_category = std::random_access_iterator_tag;
36 using value_type = row const;
37 using pointer = row const *;
38 using reference = row;
39 using size_type = result_size_type;
40 using difference_type = result_difference_type;
41
42#include "pqxx/internal/ignore-deprecated-pre.hxx"
49
52#include "pqxx/internal/ignore-deprecated-post.hxx"
53
69 [[nodiscard]] pointer operator->() const { return this; }
70
71#include "pqxx/internal/ignore-deprecated-pre.hxx"
73 [[nodiscard]] reference operator*() const { return *this; }
74#include "pqxx/internal/ignore-deprecated-post.hxx"
76
81 using row::back;
82 using row::front;
83 using row::operator[];
84 using row::at;
85 using row::rownumber;
87
92 const_result_iterator &operator=(const_result_iterator const &rhs)
93 {
94#include "pqxx/internal/ignore-deprecated-pre.hxx"
95 row::operator=(rhs);
96#include "pqxx/internal/ignore-deprecated-post.hxx"
97 return *this;
98 }
99
100 const_result_iterator &operator=(const_result_iterator &&rhs)
101 {
102#include "pqxx/internal/ignore-deprecated-pre.hxx"
103 row::operator=(std::move(rhs));
104#include "pqxx/internal/ignore-deprecated-post.hxx"
105 return *this;
106 }
107
108 const_result_iterator operator++(int) &;
109 const_result_iterator &operator++()
110 {
111 ++m_index;
112 return *this;
113 }
114 const_result_iterator operator--(int) &;
115 const_result_iterator &operator--()
116 {
117 --m_index;
118 return *this;
119 }
120
121 const_result_iterator &operator+=(difference_type i)
122 {
123 m_index += i;
124 return *this;
125 }
126 const_result_iterator &operator-=(difference_type i)
127 {
128 m_index -= i;
129 return *this;
130 }
131
134 {
135#include "pqxx/internal/ignore-deprecated-pre.hxx"
136 row::swap(other);
137#include "pqxx/internal/ignore-deprecated-post.hxx"
138 }
140
145 [[nodiscard]] bool operator==(const_result_iterator const &i) const
146 {
147 return m_index == i.m_index;
148 }
149 [[nodiscard]] bool operator!=(const_result_iterator const &i) const
150 {
151 return m_index != i.m_index;
152 }
153 [[nodiscard]] bool operator<(const_result_iterator const &i) const
154 {
155 return m_index < i.m_index;
156 }
157 [[nodiscard]] bool operator<=(const_result_iterator const &i) const
158 {
159 return m_index <= i.m_index;
160 }
161 [[nodiscard]] bool operator>(const_result_iterator const &i) const
162 {
163 return m_index > i.m_index;
164 }
165 [[nodiscard]] bool operator>=(const_result_iterator const &i) const
166 {
167 return m_index >= i.m_index;
168 }
170
175 [[nodiscard]] inline const_result_iterator operator+(difference_type) const;
176 friend const_result_iterator
177 operator+(difference_type, const_result_iterator const &);
178 [[nodiscard]] inline const_result_iterator operator-(difference_type) const;
179 [[nodiscard]] inline difference_type
180 operator-(const_result_iterator const &) const;
182
183private:
184 friend class pqxx::result;
186 row{*r, i, r->columns()}
187 {}
188};
189
190
193 : private const_result_iterator
194{
195public:
198 using iterator_type::difference_type;
199 using iterator_type::iterator_category;
203
208 default;
212 {
213 super::operator--();
214 }
215
218 const_result_iterator{std::move(rhs)}
219 {
220 super::operator--();
221 }
222
224 [[nodiscard]] PQXX_PURE const_result_iterator base() const noexcept;
225
231 using const_result_iterator::operator->;
233 using const_result_iterator::operator*;
235
240 using const_result_iterator::back;
241 using const_result_iterator::front;
242 using const_result_iterator::operator[];
243 using const_result_iterator::at;
244 using const_result_iterator::rownumber;
246
252 operator=(const_reverse_result_iterator const &r)
253 {
254 iterator_type::operator=(r);
255 return *this;
256 }
257 const_reverse_result_iterator &operator=(const_reverse_result_iterator &&r)
258 {
259 iterator_type::operator=(std::move(r));
260 return *this;
261 }
262 const_reverse_result_iterator &operator++()
263 {
264 iterator_type::operator--();
265 return *this;
266 }
267 const_reverse_result_iterator operator++(int) &;
268 const_reverse_result_iterator &operator--()
269 {
270 iterator_type::operator++();
271 return *this;
272 }
273 const_reverse_result_iterator operator--(int) &;
274 const_reverse_result_iterator &operator+=(difference_type i)
275 {
276 iterator_type::operator-=(i);
277 return *this;
278 }
279 const_reverse_result_iterator &operator-=(difference_type i)
280 {
281 iterator_type::operator+=(i);
282 return *this;
283 }
284
285 void swap(const_reverse_result_iterator &other) noexcept
286 {
287 const_result_iterator::swap(other);
288 }
290
295 [[nodiscard]] const_reverse_result_iterator
296 operator+(difference_type i) const
297 {
298 return const_reverse_result_iterator(base() - i);
299 }
300 [[nodiscard]] const_reverse_result_iterator operator-(difference_type i)
301 {
302 return const_reverse_result_iterator(base() + i);
303 }
304 [[nodiscard]] difference_type
305 operator-(const_reverse_result_iterator const &rhs) const
306 {
307 return rhs.const_result_iterator::operator-(*this);
308 }
310
315 [[nodiscard]] bool
316 operator==(const_reverse_result_iterator const &rhs) const noexcept
317 {
318 return iterator_type::operator==(rhs);
319 }
320 [[nodiscard]] bool
321 operator!=(const_reverse_result_iterator const &rhs) const noexcept
322 {
323 return not operator==(rhs);
324 }
325
326 [[nodiscard]] bool operator<(const_reverse_result_iterator const &rhs) const
327 {
328 return iterator_type::operator>(rhs);
329 }
330 [[nodiscard]] bool operator<=(const_reverse_result_iterator const &rhs) const
331 {
332 return iterator_type::operator>=(rhs);
333 }
334 [[nodiscard]] bool operator>(const_reverse_result_iterator const &rhs) const
335 {
336 return iterator_type::operator<(rhs);
337 }
338 [[nodiscard]] bool operator>=(const_reverse_result_iterator const &rhs) const
339 {
340 return iterator_type::operator<=(rhs);
341 }
343};
344
345
346inline const_result_iterator
347const_result_iterator::operator+(result::difference_type o) const
348{
349 return {&m_result, size_type(result::difference_type(m_index) + o)};
350}
351
352inline const_result_iterator
353operator+(result::difference_type o, const_result_iterator const &i)
354{
355 return i + o;
356}
357
358inline const_result_iterator
359const_result_iterator::operator-(result::difference_type o) const
360{
361 return {&m_result, result_size_type(result::difference_type(m_index) - o)};
362}
363
364inline result::difference_type
365const_result_iterator::operator-(const const_result_iterator &i) const
366{
367 return result::difference_type(num() - i.num());
368}
369
370inline const_result_iterator result::end() const noexcept
371{
372 return {this, size()};
373}
374
375
376inline const_result_iterator result::cend() const noexcept
377{
378 return end();
379}
380
381
382inline const_reverse_result_iterator
383operator+(result::difference_type n, const_reverse_result_iterator const &i)
384{
385 return const_reverse_result_iterator{i.base() - n};
386}
387
388} // namespace pqxx
389#endif
Iterator for rows in a result. Use as result::const_iterator.
Definition result_iterator.hxx:33
void swap(const_result_iterator &other) noexcept
Interchange two iterators in an exception-safe manner.
Definition result_iterator.hxx:133
pointer operator->() const
Dereference the iterator.
Definition result_iterator.hxx:69
const_result_iterator() noexcept=default
Create an iterator, but in an unusable state.
reference operator*() const
Dereference the iterator.
Definition result_iterator.hxx:73
Reverse iterator for result. Use as result::const_reverse_iterator.
Definition result_iterator.hxx:194
const_reverse_result_iterator(const_reverse_result_iterator const &rhs)=default
Copy an iterator.
const_reverse_result_iterator(const_result_iterator const &rhs)
Copy a reverse iterator from a regular iterator.
Definition result_iterator.hxx:210
const_reverse_result_iterator(const_result_iterator const &&rhs)
Move a regular iterator into a reverse iterator.
Definition result_iterator.hxx:217
const_reverse_result_iterator()=default
Create an iterator, but in an unusable state.
Reverse iterator for a row. Use as row::const_reverse_iterator.
Definition row.hxx:406
Result set containing data returned by a query or command.
Definition result.hxx:73
Reference to one row in a result.
Definition row.hxx:47
result m_result
Result set of which this is one row.
Definition row.hxx:249
result::size_type m_index
Row number.
Definition row.hxx:256
The home of all libpqxx classes, functions, templates, etc.
Definition array.cxx:27
int result_difference_type
Difference between result sizes.
Definition types.hxx:31
int result_size_type
Number of rows in a result set.
Definition types.hxx:28