deal.II version GIT relicensing-6834-g5b78e6bcdf 2026-10-01 11:20:01+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Private Attributes | Related Symbols | List of all members
SynchronousIterators< Iterators > Struct Template Reference

#include <deal.II/base/synchronous_iterator.h>

Detailed Description

template<typename Iterators>
struct SynchronousIterators< Iterators >

A class that represents a set of iterators each of which are incremented by one at the same time. This is typically used in calls like std::transform(a.begin(), a.end(), b.begin(), functor); where we have synchronous iterators marching through the containers a,b. If an object of this type represents the end of a range, only the first element is considered (we only have a.end(), not b.end()). An example of how this class is used is given in step-35.

The template argument of the current class shall be of type std::tuple with arguments equal to the iterator types.

The individual iterators can be accessed using std::get<X>(synchronous_iterator.iterators) where X is the number corresponding to the desired iterator.

This type, and the helper functions associated with it, are used as the Value concept for the blocked_range type of the Threading Building Blocks.

Definition at line 47 of file synchronous_iterator.h.

Public Types

using difference_type = std::size_t
 
using iterator_category = std::bidirectional_iterator_tag
 
using value_type = Iterators
 
using pointer = Iterators *
 
using reference = Iterators &
 

Public Member Functions

 SynchronousIterators (const Iterators &i)
 
const Iterators & operator* () const
 
Iterators & operator* ()
 

Private Attributes

Iterators iterators
 

Related Symbols

(Note that these are not member symbols.)

template<typename Iterators >
bool operator< (const SynchronousIterators< Iterators > &a, const SynchronousIterators< Iterators > &b)
 
template<typename Iterators >
std::size_t operator- (const SynchronousIterators< Iterators > &a, const SynchronousIterators< Iterators > &b)
 
template<typename I1 , typename I2 >
void advance (std::tuple< I1, I2 > &t, const unsigned int n)
 
template<typename I1 , typename I2 , typename I3 >
void advance (std::tuple< I1, I2, I3 > &t, const unsigned int n)
 
template<typename I1 , typename I2 , typename I3 , typename I4 >
void advance (std::tuple< I1, I2, I3, I4 > &t, const unsigned int n)
 
template<typename I1 , typename I2 >
void prev (std::tuple< I1, I2 > &t)
 
template<typename I1 , typename I2 , typename I3 >
void prev (std::tuple< I1, I2, I3 > &t)
 
template<typename I1 , typename I2 , typename I3 , typename I4 >
void prev (std::tuple< I1, I2, I3, I4 > &t)
 
template<typename I1 , typename I2 >
void advance_by_one (std::tuple< I1, I2 > &t)
 
template<typename I1 , typename I2 , typename I3 >
void advance_by_one (std::tuple< I1, I2, I3 > &t)
 
template<typename I1 , typename I2 , typename I3 , typename I4 >
void advance_by_one (std::tuple< I1, I2, I3, I4 > &t)
 
template<typename Iterators >
SynchronousIterators< Iterators > operator+ (const SynchronousIterators< Iterators > &a, const std::size_t n)
 
template<typename Iterators >
SynchronousIterators< Iterators > & operator++ (SynchronousIterators< Iterators > &a)
 
template<typename Iterators >
SynchronousIterators< Iterators > & operator-- (SynchronousIterators< Iterators > &a)
 
template<typename Iterators >
SynchronousIterators< Iterators > operator++ (SynchronousIterators< Iterators > &a, int)
 
template<typename Iterators >
bool operator!= (const SynchronousIterators< Iterators > &a, const SynchronousIterators< Iterators > &b)
 

Member Typedef Documentation

◆ difference_type

template<typename Iterators >
using SynchronousIterators< Iterators >::difference_type = std::size_t

The following traits are necessary for std::distance() to work with SynchronousIterators.

Definition at line 72 of file synchronous_iterator.h.

◆ iterator_category

template<typename Iterators >
using SynchronousIterators< Iterators >::iterator_category = std::bidirectional_iterator_tag

Definition at line 73 of file synchronous_iterator.h.

◆ value_type

template<typename Iterators >
using SynchronousIterators< Iterators >::value_type = Iterators

Definition at line 74 of file synchronous_iterator.h.

◆ pointer

template<typename Iterators >
using SynchronousIterators< Iterators >::pointer = Iterators *

Definition at line 75 of file synchronous_iterator.h.

◆ reference

template<typename Iterators >
using SynchronousIterators< Iterators >::reference = Iterators &

Definition at line 76 of file synchronous_iterator.h.

Constructor & Destructor Documentation

◆ SynchronousIterators()

template<typename Iterators >
SynchronousIterators< Iterators >::SynchronousIterators ( const Iterators &  i)
inline

Constructor.

Definition at line 88 of file synchronous_iterator.h.

Member Function Documentation

◆ operator*() [1/2]

template<typename Iterators >
const Iterators & SynchronousIterators< Iterators >::operator* ( ) const
inline

Dereference const operator. Returns a const reference to the iterators represented by the current class.

Definition at line 96 of file synchronous_iterator.h.

◆ operator*() [2/2]

template<typename Iterators >
Iterators & SynchronousIterators< Iterators >::operator* ( )
inline

Dereference operator. Returns a reference to the iterators represented by the current class.

Definition at line 105 of file synchronous_iterator.h.

Friends And Related Symbol Documentation

◆ operator<()

template<typename Iterators >
bool operator< ( const SynchronousIterators< Iterators > &  a,
const SynchronousIterators< Iterators > &  b 
)
related

Return whether the first element of the first argument is less than the first element of the second argument. Since the objects compared march forward all elements at the same time, comparing the first element is sufficient.

Definition at line 121 of file synchronous_iterator.h.

◆ operator-()

template<typename Iterators >
std::size_t operator- ( const SynchronousIterators< Iterators > &  a,
const SynchronousIterators< Iterators > &  b 
)
related

Return the distance between the first and the second argument. Since the objects compared march forward all elements at the same time, differencing the first element is sufficient.

Definition at line 139 of file synchronous_iterator.h.

◆ advance() [1/3]

template<typename I1 , typename I2 >
void advance ( std::tuple< I1, I2 > &  t,
const unsigned int  n 
)
related

Advance a tuple of iterators by \(n\).

Definition at line 155 of file synchronous_iterator.h.

◆ advance() [2/3]

template<typename I1 , typename I2 , typename I3 >
void advance ( std::tuple< I1, I2, I3 > &  t,
const unsigned int  n 
)
related

Advance a tuple of iterators by \(n\).

Definition at line 168 of file synchronous_iterator.h.

◆ advance() [3/3]

template<typename I1 , typename I2 , typename I3 , typename I4 >
void advance ( std::tuple< I1, I2, I3, I4 > &  t,
const unsigned int  n 
)
related

Advance a tuple of iterators by \(n\).

Definition at line 182 of file synchronous_iterator.h.

◆ prev() [1/3]

template<typename I1 , typename I2 >
void prev ( std::tuple< I1, I2 > &  t)
related

Reverse a tuple of iterators by 1.

Definition at line 197 of file synchronous_iterator.h.

◆ prev() [2/3]

template<typename I1 , typename I2 , typename I3 >
void prev ( std::tuple< I1, I2, I3 > &  t)
related

Reverse a tuple of iterators by 1.

Definition at line 210 of file synchronous_iterator.h.

◆ prev() [3/3]

template<typename I1 , typename I2 , typename I3 , typename I4 >
void prev ( std::tuple< I1, I2, I3, I4 > &  t)
related

Reverse a tuple of iterators by 1.

Definition at line 224 of file synchronous_iterator.h.

◆ advance_by_one() [1/3]

template<typename I1 , typename I2 >
void advance_by_one ( std::tuple< I1, I2 > &  t)
related

Advance a tuple of iterators by 1.

Definition at line 239 of file synchronous_iterator.h.

◆ advance_by_one() [2/3]

template<typename I1 , typename I2 , typename I3 >
void advance_by_one ( std::tuple< I1, I2, I3 > &  t)
related

Advance a tuple of iterators by 1.

Definition at line 252 of file synchronous_iterator.h.

◆ advance_by_one() [3/3]

template<typename I1 , typename I2 , typename I3 , typename I4 >
void advance_by_one ( std::tuple< I1, I2, I3, I4 > &  t)
related

Advance a tuple of iterators by 1.

Definition at line 266 of file synchronous_iterator.h.

◆ operator+()

template<typename Iterators >
SynchronousIterators< Iterators > operator+ ( const SynchronousIterators< Iterators > &  a,
const std::size_t  n 
)
related

Advance the elements of this iterator by \(n\).

Definition at line 281 of file synchronous_iterator.h.

◆ operator++() [1/2]

template<typename Iterators >
SynchronousIterators< Iterators > & operator++ ( SynchronousIterators< Iterators > &  a)
related

Advance the elements of this iterator by 1 (pre-increment).

Definition at line 295 of file synchronous_iterator.h.

◆ operator--()

template<typename Iterators >
SynchronousIterators< Iterators > & operator-- ( SynchronousIterators< Iterators > &  a)
related

Reverse the elements of this iterator by 1 (pre-decrement).

Definition at line 308 of file synchronous_iterator.h.

◆ operator++() [2/2]

template<typename Iterators >
SynchronousIterators< Iterators > operator++ ( SynchronousIterators< Iterators > &  a,
int   
)
related

Advance the elements of this iterator by 1 (post-increment).

Definition at line 321 of file synchronous_iterator.h.

◆ operator!=()

template<typename Iterators >
bool operator!= ( const SynchronousIterators< Iterators > &  a,
const SynchronousIterators< Iterators > &  b 
)
related

Compare synch iterators for inequality. Since they march in synch, comparing only the first element is sufficient.

Definition at line 336 of file synchronous_iterator.h.

Member Data Documentation

◆ iterators

template<typename Iterators >
Iterators SynchronousIterators< Iterators >::iterators
private

Storage for the iterators represented by the current class.

Definition at line 82 of file synchronous_iterator.h.

The documentation for this struct was generated from the following file:
Generated by doxygen 1.9.8