IntRangeI.H
Go to the documentation of this file.
1/*---------------------------------------------------------------------------*\
2 ========= |
3 \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4 \\ / O peration |
5 \\ / A nd | www.openfoam.com
6 \\/ M anipulation |
7-------------------------------------------------------------------------------
8 Copyright (C) 2020 OpenCFD Ltd.
9-------------------------------------------------------------------------------
10License
11 This file is part of OpenFOAM.
12
13 OpenFOAM is free software: you can redistribute it and/or modify it
14 under the terms of the GNU General Public License as published by
15 the Free Software Foundation, either version 3 of the License, or
16 (at your option) any later version.
17
18 OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
19 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
20 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
25
26\*---------------------------------------------------------------------------*/
27
28// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
29
30template<class IntType>
31inline constexpr Foam::IntRange<IntType>::IntRange() noexcept
32:
33 start_(0),
34 size_(0)
35{}
36
37
38template<class IntType>
39inline constexpr Foam::IntRange<IntType>::IntRange
40(
41 const IntType len
42) noexcept
43:
44 start_(0),
45 size_(len)
46{}
47
48
49template<class IntType>
50inline constexpr Foam::IntRange<IntType>::IntRange
51(
52 const IntType beg,
53 const IntType len
54) noexcept
55:
56 start_(beg),
57 size_(len)
58{}
59
60
61// * * * * * * * * * * * * * * Forward Iterators * * * * * * * * * * * * * * //
62
63template<class IntType>
64inline constexpr Foam::IntRange<IntType>::const_iterator::
65const_iterator(const IntType val) noexcept
66:
67 value_(val)
68{}
69
70
71template<class IntType>
72inline constexpr IntType
73Foam::IntRange<IntType>::const_iterator::
74operator*() const noexcept
75{
76 return value_;
77}
78
79
80template<class IntType>
81inline constexpr IntType
82Foam::IntRange<IntType>::const_iterator::
83operator[](const IntType n) const noexcept
84{
85 return (value_ + n);
86}
87
88
89template<class IntType>
90inline typename Foam::IntRange<IntType>::const_iterator&
91Foam::IntRange<IntType>::const_iterator::
92operator++() noexcept
93{
94 ++value_;
95 return *this;
96}
97
98
99template<class IntType>
100inline typename Foam::IntRange<IntType>::const_iterator
101Foam::IntRange<IntType>::const_iterator::
102operator++(int) noexcept
103{
104 const_iterator old(*this);
105 ++value_;
106 return old;
107}
108
109
110template<class IntType>
111inline typename Foam::IntRange<IntType>::const_iterator&
112Foam::IntRange<IntType>::const_iterator::
113operator--() noexcept
114{
115 --value_;
116 return *this;
117}
118
119
120template<class IntType>
121inline typename Foam::IntRange<IntType>::const_iterator
122Foam::IntRange<IntType>::const_iterator::
123operator--(int) noexcept
124{
125 const_iterator old(*this);
126 --value_;
127 return old;
128}
129
130
131template<class IntType>
132inline typename Foam::IntRange<IntType>::const_iterator&
133Foam::IntRange<IntType>::const_iterator::
134operator+=(const IntType n) noexcept
135{
136 value_ += n;
137 return *this;
138}
139
140
141template<class IntType>
142inline typename Foam::IntRange<IntType>::const_iterator&
143Foam::IntRange<IntType>::const_iterator::
144operator-=(const IntType n) noexcept
145{
146 value_ -= n;
147 return *this;
148}
149
150
151template<class IntType>
152inline constexpr typename Foam::IntRange<IntType>::const_iterator
153Foam::IntRange<IntType>::const_iterator::
154operator+(const IntType n) const noexcept
155{
156 return const_iterator(value_ + n);
157}
158
159
160template<class IntType>
161inline constexpr typename Foam::IntRange<IntType>::const_iterator
162Foam::IntRange<IntType>::const_iterator::
163operator-(const IntType n) const noexcept
164{
165 return const_iterator(value_ - n);
166}
167
168
169template<class IntType>
170inline constexpr IntType
171Foam::IntRange<IntType>::const_iterator::
172operator-(const const_iterator& iter) const noexcept
173{
174 return (value_ - iter.value_);
175}
176
177
178template<class IntType>
179inline constexpr bool
180Foam::IntRange<IntType>::const_iterator::
181operator==(const const_iterator& iter) const noexcept
182{
183 return (value_ == iter.value_);
184}
185
186
187template<class IntType>
188inline constexpr bool
189Foam::IntRange<IntType>::const_iterator::
190operator<(const const_iterator& iter) const noexcept
191{
192 return (value_ < iter.value_);
193}
194
195
196// * * * * * * * * * * * * * * Reverse Iterators * * * * * * * * * * * * * * //
197
198template<class IntType>
199inline constexpr Foam::IntRange<IntType>::const_reverse_iterator::
200const_reverse_iterator(const IntType val) noexcept
201:
202 value_(val)
203{}
204
205
206template<class IntType>
207inline constexpr IntType
208Foam::IntRange<IntType>::const_reverse_iterator::
209operator*() const noexcept
210{
211 return value_;
212}
213
214
215template<class IntType>
216inline constexpr IntType
217Foam::IntRange<IntType>::const_reverse_iterator::
218operator[](const IntType n) const noexcept
219{
220 return (value_ - n);
221}
222
223
224template<class IntType>
225inline typename Foam::IntRange<IntType>::const_reverse_iterator&
226Foam::IntRange<IntType>::const_reverse_iterator::
227operator++() noexcept
228{
229 --value_;
230 return *this;
231}
232
233
234template<class IntType>
235inline typename Foam::IntRange<IntType>::const_reverse_iterator
236Foam::IntRange<IntType>::const_reverse_iterator::
237operator++(int) noexcept
238{
239 const_reverse_iterator old(*this);
240 --value_;
241 return old;
242}
243
244
245template<class IntType>
246inline typename Foam::IntRange<IntType>::const_reverse_iterator&
247Foam::IntRange<IntType>::const_reverse_iterator::
248operator--() noexcept
249{
250 ++value_;
251 return *this;
252}
253
254
255template<class IntType>
256inline typename Foam::IntRange<IntType>::const_reverse_iterator
257Foam::IntRange<IntType>::const_reverse_iterator::
258operator--(int) noexcept
259{
260 const_reverse_iterator old(*this);
261 ++value_;
262 return old;
263}
264
265
266template<class IntType>
267inline typename Foam::IntRange<IntType>::const_reverse_iterator&
268Foam::IntRange<IntType>::const_reverse_iterator::
269operator+=(const IntType n) noexcept
270{
271 value_ -= n;
272 return *this;
273}
274
275
276template<class IntType>
277inline typename Foam::IntRange<IntType>::const_reverse_iterator&
278Foam::IntRange<IntType>::const_reverse_iterator::
279operator-=(const IntType n) noexcept
280{
281 value_ += n;
282 return *this;
283}
284
285
286template<class IntType>
287inline constexpr typename Foam::IntRange<IntType>::const_reverse_iterator
288Foam::IntRange<IntType>::const_reverse_iterator::
289operator+(const IntType n) const noexcept
290{
291 return const_reverse_iterator(value_ - n);
292}
293
294
295template<class IntType>
296inline constexpr typename Foam::IntRange<IntType>::const_reverse_iterator
297Foam::IntRange<IntType>::const_reverse_iterator::
298operator-(const IntType n) const noexcept
299{
300 return const_reverse_iterator(value_ + n);
301}
302
303
304template<class IntType>
305inline constexpr IntType
306Foam::IntRange<IntType>::const_reverse_iterator::
307operator-(const const_reverse_iterator& iter) const noexcept
308{
309 return (iter.value_ - value_);
310}
311
312
313template<class IntType>
314inline constexpr bool
315Foam::IntRange<IntType>::const_reverse_iterator::
316operator==(const const_reverse_iterator& iter) const noexcept
317{
318 return (value_ == iter.value_);
319}
320
321
322template<class IntType>
323inline constexpr bool
324Foam::IntRange<IntType>::const_reverse_iterator::
325operator<(const const_reverse_iterator& iter) const noexcept
326{
327 return (value_ > iter.value_);
328}
329
330
331// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
332
333template<class IntType>
334inline typename Foam::IntRange<IntType>::const_iterator
335Foam::IntRange<IntType>::at(const IntType i) const
336{
337 return const_iterator(start_ + ((i < 0 || i > size_) ? size_ : i));
338}
339
340
341template<class IntType>
342inline typename Foam::IntRange<IntType>::const_iterator
343Foam::IntRange<IntType>::begin() const noexcept
344{
345 return const_iterator(start_);
346}
347
348
349template<class IntType>
350inline typename Foam::IntRange<IntType>::const_iterator
351Foam::IntRange<IntType>::cbegin() const noexcept
352{
353 return const_iterator(start_);
354}
355
356
357template<class IntType>
358inline typename Foam::IntRange<IntType>::const_iterator
359Foam::IntRange<IntType>::end() const noexcept
360{
361 return const_iterator(start_ + size_);
362}
363
364
365template<class IntType>
366inline typename Foam::IntRange<IntType>::const_iterator
367Foam::IntRange<IntType>::cend() const noexcept
368{
369 return const_iterator(start_ + size_);
370}
371
372
373template<class IntType>
374inline typename Foam::IntRange<IntType>::const_reverse_iterator
375Foam::IntRange<IntType>::rbegin() const noexcept
376{
377 return const_reverse_iterator(start_ + (size_-1));
378}
379
380
381template<class IntType>
382inline typename Foam::IntRange<IntType>::const_reverse_iterator
383Foam::IntRange<IntType>::crbegin() const noexcept
384{
385 return const_reverse_iterator(start_ + (size_-1));
386}
387
388
389template<class IntType>
390inline typename Foam::IntRange<IntType>::const_reverse_iterator
391Foam::IntRange<IntType>::rend() const noexcept
392{
393 return const_reverse_iterator(start_ - 1);
394}
395
396
397template<class IntType>
398inline typename Foam::IntRange<IntType>::const_reverse_iterator
399Foam::IntRange<IntType>::crend() const noexcept
400{
401 return const_reverse_iterator(start_ - 1);
402}
403
404
405// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
406
407template<class IntType>
408inline IntType Foam::IntRange<IntType>::start() const noexcept
409{
410 return start_;
411}
412
413
414template<class IntType>
415inline IntType Foam::IntRange<IntType>::size() const noexcept
416{
417 return size_;
418}
419
420
421template<class IntType>
422inline IntType& Foam::IntRange<IntType>::start() noexcept
423{
424 return start_;
425}
426
427
428template<class IntType>
429inline IntType& Foam::IntRange<IntType>::size() noexcept
430{
431 return size_;
432}
433
434
435template<class IntType>
436inline bool Foam::IntRange<IntType>::empty() const noexcept
437{
438 return !size_;
439}
440
441
442template<class IntType>
443inline IntType Foam::IntRange<IntType>::first() const noexcept
444{
445 return start_;
446}
447
448
449template<class IntType>
450inline IntType Foam::IntRange<IntType>::last() const noexcept
451{
452 return (start_ + (size_-1));
453}
454
455
456template<class IntType>
457inline IntType Foam::IntRange<IntType>::rend_value() const noexcept
458{
459 return (start_ - 1);
460}
461
462
463template<class IntType>
464inline IntType Foam::IntRange<IntType>::end_value() const noexcept
465{
466 return (start_ + size_);
467}
468
469
470template<class IntType>
471inline void Foam::IntRange<IntType>::clear() noexcept
472{
473 start_ = size_ = 0;
474}
475
476
477template<class IntType>
478inline void Foam::IntRange<IntType>::reset
479(
480 const IntType beg,
481 const IntType len
482) noexcept
483{
484 start_ = beg;
485 size_ = len;
486}
487
488
489template<class IntType>
490inline void Foam::IntRange<IntType>::setStart(const IntType i) noexcept
491{
492 start_ = i;
493}
494
495
496template<class IntType>
497inline void Foam::IntRange<IntType>::setSize(const IntType n) noexcept
498{
499 size_ = n;
500}
501
502
503template<class IntType>
504inline void Foam::IntRange<IntType>::resize(const IntType n) noexcept
505{
506 size_ = n;
507}
508
509
510template<class IntType>
511inline void Foam::IntRange<IntType>::clampSize() noexcept
512{
513 if (size_ < 0) size_ = 0;
514}
515
516
517template<class IntType>
518inline bool Foam::IntRange<IntType>::found(const IntType value) const noexcept
519{
520 // Avoid overflow risk:
521 // (value < (start_ + size_)) --> ((value - start_) < size_)
522
523 return (size_ && start_ <= value && (value - start_) < size_);
524}
525
526
527// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
528
529template<class IntType>
530inline constexpr IntType Foam::IntRange<IntType>::
531operator[](const IntType i) const noexcept
532{
533 return start_ + i;
534}
535
536
537template<class IntType>
538inline bool Foam::IntRange<IntType>::
539operator()(const IntType value) const noexcept
540{
541 return found(value);
542}
543
544
545template<class IntType>
546inline IntType Foam::IntRange<IntType>::
547operator++() noexcept
548{
549 return ++size_;
550}
551
552
553template<class IntType>
554inline IntType Foam::IntRange<IntType>::
555operator++(int) noexcept
556{
557 return size_++;
558}
559
560
561template<class IntType>
562inline IntType Foam::IntRange<IntType>::
563operator--() noexcept
564{
565 --size_;
566 clampSize();
567 return size_;
568}
569
570
571template<class IntType>
572inline IntType Foam::IntRange<IntType>::
573operator--(int) noexcept
574{
575 const IntType old(size_);
576 --size_;
577 clampSize();
578 return old;
579}
580
581
582template<class IntType>
583inline IntType Foam::IntRange<IntType>::
584operator+=(const IntType n) noexcept
585{
586 size_ += n;
587 return size_;
588}
589
590
591template<class IntType>
592inline IntType Foam::IntRange<IntType>::
593operator-=(const IntType n) noexcept
594{
595 size_ -= n;
596 clampSize();
597 return size_;
598}
599
600
601// ************************************************************************* //
found
bool found
Definition: TABSMDCalcMethod2.H:32
n
label n
Definition: TABSMDCalcMethod2.H:31
Foam::Euler::resize
virtual bool resize()
Resize the ODE solver.
Definition: Euler.C:53
Foam::IntRange::const_iterator
Random-access input iterator with const access.
Definition: IntRange.H:290
Foam::IntRange::const_iterator::operator++
const_iterator & operator++() noexcept
Prefix increment.
Definition: IntRangeI.H:92
Foam::IntRange::const_iterator::operator<
constexpr bool operator<(const const_iterator &iter) const noexcept
Compare less-than.
Definition: IntRangeI.H:190
Foam::IntRange::const_iterator::operator--
const_iterator & operator--() noexcept
Prefix decrement.
Definition: IntRangeI.H:113
Foam::IntRange::const_iterator::operator+=
const_iterator & operator+=(const IntType n) noexcept
Arbitrary increment.
Definition: IntRangeI.H:134
Foam::IntRange::const_iterator::operator[]
constexpr IntType operator[](const IntType n) const noexcept
Offset dereference operator.
Definition: IntRangeI.H:83
Foam::IntRange::const_iterator::operator*
constexpr IntType operator*() const noexcept
Return the value.
Definition: IntRangeI.H:74
Foam::IntRange::const_iterator::operator-=
const_iterator & operator-=(const IntType n) noexcept
Arbitrary decrement.
Definition: IntRangeI.H:144
Foam::IntRange::const_reverse_iterator
Random-access reverse input iterator with const access.
Definition: IntRange.H:401
Foam::IntRange::const_reverse_iterator::operator++
const_reverse_iterator & operator++() noexcept
Prefix increment.
Definition: IntRangeI.H:227
Foam::IntRange::const_reverse_iterator::operator--
const_reverse_iterator & operator--() noexcept
Prefix decrement.
Definition: IntRangeI.H:248
Foam::IntRange::const_reverse_iterator::operator+=
const_reverse_iterator & operator+=(const IntType n) noexcept
Arbitrary increment.
Definition: IntRangeI.H:269
Foam::IntRange::const_reverse_iterator::operator[]
constexpr IntType operator[](const IntType n) const noexcept
Offset dereference operator.
Definition: IntRangeI.H:218
Foam::IntRange::const_reverse_iterator::operator-=
const_reverse_iterator & operator-=(const IntType n) noexcept
Arbitrary decrement.
Definition: IntRangeI.H:279
Foam::IntRange::const_reverse_iterator::operator*
constexpr IntType operator*() const noexcept
Return the value.
Definition: IntRangeI.H:209
Foam::IntRange::const_reverse_iterator::operator<
constexpr bool operator<(const const_reverse_iterator &iter) const noexcept
Reverse compare less-than.
Definition: IntRangeI.H:325
Foam::IntRange
An interval of (signed) integers defined by a start and a size.
Definition: IntRange.H:64
Foam::IntRange::clear
void clear() noexcept
Reset to zero start and zero size.
Definition: IntRangeI.H:471
Foam::IntRange::end
const_iterator end() const noexcept
A const_iterator set to 1 beyond the end of the range.
Definition: IntRangeI.H:359
Foam::IntRange::operator++
IntType operator++() noexcept
Increase the size by 1.
Definition: IntRangeI.H:547
Foam::IntRange::operator--
IntType operator--() noexcept
Decrease the size by 1, but never below 0.
Definition: IntRangeI.H:563
Foam::IntRange::last
IntType last() const noexcept
The (inclusive) upper value of the range.
Definition: IntRangeI.H:450
Foam::IntRange::begin
const_iterator begin() const noexcept
A const_iterator set to the beginning of the range.
Definition: IntRangeI.H:343
Foam::IntRange::operator[]
constexpr IntType operator[](const IntType i) const noexcept
Offset dereference, without bounds checking.
Definition: IntRangeI.H:531
Foam::IntRange::rend_value
IntType rend_value() const noexcept
The value 1 before the start of the range.
Definition: IntRangeI.H:457
Foam::IntRange::empty
bool empty() const noexcept
True if range is empty (zero-sized)
Definition: IntRangeI.H:436
Foam::IntRange::rend
const_reverse_iterator rend() const noexcept
A const_reverse_iterator set to 1 before the begin of range.
Definition: IntRangeI.H:391
Foam::IntRange::start
IntType start() const noexcept
The (inclusive) lower value of the range.
Definition: IntRangeI.H:408
Foam::IntRange::crbegin
const_reverse_iterator crbegin() const noexcept
A const_reverse_iterator set to 1 before the end of range.
Definition: IntRangeI.H:383
Foam::IntRange::at
const_iterator at(const IntType i) const
Definition: IntRangeI.H:335
Foam::IntRange::operator+=
IntType operator+=(const IntType n) noexcept
Increase the size by n.
Definition: IntRangeI.H:584
Foam::IntRange::size
IntType size() const noexcept
The size of the range.
Definition: IntRangeI.H:415
Foam::IntRange::clampSize
void clampSize() noexcept
Enforce non-negative size.
Definition: IntRangeI.H:511
Foam::IntRange::crend
const_reverse_iterator crend() const noexcept
A const_reverse_iterator set to 1 before the begin of range.
Definition: IntRangeI.H:399
Foam::IntRange::setSize
void setSize(const IntType n) noexcept
Change the size, no checks. Identical to resize()
Definition: IntRangeI.H:497
Foam::IntRange::cbegin
const_iterator cbegin() const noexcept
A const_iterator set to the beginning of the range.
Definition: IntRangeI.H:351
Foam::IntRange::rbegin
const_reverse_iterator rbegin() const noexcept
A const_reverse_iterator set to 1 before the end of range.
Definition: IntRangeI.H:375
Foam::IntRange::cend
const_iterator cend() const noexcept
A const_iterator set to 1 beyond the end of the range.
Definition: IntRangeI.H:367
Foam::IntRange::first
IntType first() const noexcept
The (inclusive) lower value of the range. Same as start()
Definition: IntRangeI.H:443
Foam::IntRange::IntRange
constexpr IntRange() noexcept
Default construct an empty range (0,0)
Definition: IntRangeI.H:31
Foam::IntRange::end_value
IntType end_value() const noexcept
The value 1 beyond the end of the range.
Definition: IntRangeI.H:464
Foam::IntRange::operator-=
IntType operator-=(const IntType n) noexcept
Decrease the size by n, but never below 0.
Definition: IntRangeI.H:593
Foam::IntRange::setStart
void setStart(const IntType i) noexcept
Set the start position, no checks.
Definition: IntRangeI.H:490
Foam::complex::operator+
friend complex operator+(const complex &c1, const complex &c2)
Definition: complexI.H:291
Foam::ensightCase::operator()
Ostream & operator()() const
Output stream (master only).
Definition: ensightCaseI.H:74
Foam::ensightMesh::options::reset
void reset()
Reset to defaults.
Definition: ensightMeshOptions.C:105
Foam::refineCell::operator==
friend bool operator==(const refineCell &rc1, const refineCell &rc2)
Definition: refineCell.H:97
Foam::zeroField::operator-
zeroField operator-() const noexcept
Definition: zeroField.H:85
Foam::noexcept
const direction noexcept
Definition: Scalar.H:223