transform_input_output_iterator#

template<class _Iter, class _InputFn, class _OutputFn>
class transform_input_output_iterator#

transform_input_output_iterator is a special kind of iterator which applies transform functions when reading from or writing to dereferenced values.

This iterator is useful for algorithms that operate on a type that needs to be serialized/deserialized from values in another iterator, avoiding the need to materialize intermediate results in memory. This also enables the transform functions to be fused with the operations that read and write to the transform_input_output_iterator.

The following code snippet demonstrates how to create a transform_input_output_iterator which performs different transformations when reading from and writing to the iterator.

#include <cuda/iterator>
#include <thrust/device_vector.h>

 int main()
 {
   const size_t size = 4;
   thrust::device_vector<float> v(size);

   // Write 1.0f, 2.0f, 3.0f, 4.0f to vector
   thrust::sequence(v.begin(), v.end(), 1);

   // Iterator that negates read values and writes squared values
   auto iter = cuda::make_transform_input_output_iterator(v.begin(),
       ::cuda::std::negate<float>{}, thrust::square<float>{});

   // Iterator negates values when reading
   std::cout << iter[0] << " ";  // -1.0f;
   std::cout << iter[1] << " ";  // -2.0f;
   std::cout << iter[2] << " ";  // -3.0f;
   std::cout << iter[3] << "\n"; // -4.0f;

   // Write 1.0f, 2.0f, 3.0f, 4.0f to iterator
   thrust::sequence(iter, iter + size, 1);

   // Values were squared before writing to vector
   std::cout << v[0] << " ";  // 1.0f;
   std::cout << v[1] << " ";  // 4.0f;
   std::cout << v[2] << " ";  // 9.0f;
   std::cout << v[3] << "\n"; // 16.0f;

 }

Public Types

using iterator_concept = ::cuda::std::conditional_t<::cuda::std::random_access_iterator<_Iter>, ::cuda::std::random_access_iterator_tag, ::cuda::std::conditional_t<::cuda::std::bidirectional_iterator<_Iter>, ::cuda::std::bidirectional_iterator_tag, ::cuda::std::conditional_t<::cuda::std::forward_iterator<_Iter>, ::cuda::std::forward_iterator_tag, ::cuda::std::output_iterator_tag>>>#
using iterator_category = ::cuda::std::output_iterator_tag#
using difference_type = ::cuda::std::iter_difference_t<_Iter>#
using value_type = ::cuda::std::invoke_result_t<_InputFn&, ::cuda::std::iter_reference_t<_Iter>>#
using pointer = void#
using reference = __transform_input_output_proxy<_Iter, _InputFn, _OutputFn>#

Public Functions

template<class _Iter2 = _Iter, class _InputFn2 = _InputFn, class _OutputFn2 = _OutputFn>
inline constexpr transform_input_output_iterator(
) noexcept(::cuda::std::is_nothrow_default_constructible_v<_Iter2> && ::cuda::std::is_nothrow_default_constructible_v<_InputFn2> && ::cuda::std::is_nothrow_default_constructible_v<_OutputFn2>)#

Default constructs a transform_input_output_iterator with a value initialized iterator and functors.

inline constexpr transform_input_output_iterator(
_Iter __iter,
_InputFn __input_func,
_OutputFn __output_func,
) noexcept(::cuda::std::is_nothrow_move_constructible_v<_Iter> && ::cuda::std::is_nothrow_move_constructible_v<_InputFn> && ::cuda::std::is_nothrow_move_constructible_v<_OutputFn>)#

Constructs a transform_input_output_iterator with base iterator, input functor and output functor.

Parameters:

  • __iter – The iterator to transform

  • __input_func – The input functor to apply to the iterator when reading

  • __output_func – The output functor to apply to the iterator when writing

inline constexpr const _Iter &base() const & noexcept#

Returns a const reference to the base iterator stored.

inline constexpr _Iter base(
) && noexcept(::cuda::std::is_nothrow_move_constructible_v<_Iter>)#

Extracts the stored base iterator.

inline constexpr auto operator*(
) const noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter>)#

Dereferences the transform_input_output_iterator.

Returns a proxy that transforms values read from the stored iterator via the stored input functor and transforms assigned values via the output functor

inline constexpr auto operator*(
) noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter>)#

Dereferences the transform_input_output_iterator.

Returns a proxy that transforms values read from the stored iterator via the stored input functor and transforms assigned values via the output functor

template<class _Iter2 = _Iter, ::cuda::std::enable_if_t<::cuda::std::random_access_iterator<_Iter2>, int> = 0>
inline constexpr auto operator[](
difference_type __n,
) const noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter2> && noexcept(__current_ + __n))#

Subscripts the transform_input_output_iterator.

Returns a proxy that transforms values read from the stored iterator adbanvd by a given number of elements via the stored input functor and transforms assigned values via the output functor

Parameters:

__n – The number of elements to advance

template<class _Iter2 = _Iter, ::cuda::std::enable_if_t<::cuda::std::random_access_iterator<_Iter2>, int> = 0>
inline constexpr auto operator[](
difference_type __n,
) noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter2> && noexcept(__current_ + __n))#

Subscripts the transform_input_output_iterator.

Returns a proxy that transforms values read from the stored iterator adbanvd by a given number of elements via the stored input functor and transforms assigned values via the output functor

Parameters:

__n – The number of elements to advance

inline constexpr transform_input_output_iterator &operator++(
) noexcept(noexcept(++__current_))#

Increments the stored iterator.

inline constexpr transform_input_output_iterator operator++(
int,
) noexcept(noexcept(++__current_) && ::cuda::std::is_nothrow_copy_constructible_v<_Iter> && ::cuda::std::is_nothrow_copy_constructible_v<_InputFn> && ::cuda::std::is_nothrow_copy_constructible_v<_OutputFn>)#

Increments the stored iterator.

template<class _Iter2 = _Iter, ::cuda::std::enable_if_t<::cuda::std::bidirectional_iterator<_Iter2>, int> = 0>
inline constexpr transform_input_output_iterator &operator--(
) noexcept(noexcept(--__current_))#

Decrements the stored iterator.

template<class _Iter2 = _Iter, ::cuda::std::enable_if_t<::cuda::std::bidirectional_iterator<_Iter2>, int> = 0>
inline constexpr transform_input_output_iterator operator--(
int,
) noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter> && noexcept(--__current_))#

Decrements the stored iterator.

template<class _Iter2 = _Iter, ::cuda::std::enable_if_t<::cuda::std::random_access_iterator<_Iter2>, int> = 0>
inline constexpr transform_input_output_iterator &operator+=(
difference_type __n,
) noexcept(noexcept(__current_ += __n))#

Advances the transform_input_output_iterator by a given number of elements.

Parameters:

__n – The number of elements to advance

template<class _Iter2 = _Iter, ::cuda::std::enable_if_t<::cuda::std::random_access_iterator<_Iter2>, int> = 0>
inline constexpr transform_input_output_iterator &operator-=(
difference_type __n,
) noexcept(noexcept(__current_ -= __n))#

Decrements the transform_input_output_iterator by a given number of elements.

Parameters:

__n – The number of elements to decrement

Friends

template<class _Iter2 = _Iter>
inline friend constexpr auto operator+(
const transform_input_output_iterator &__iter,
difference_type __n,
) noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter> && noexcept(::cuda::std::declval<const _Iter2&>() + difference_type{})) -> transform_input_output_iterator#
requires (::cuda::std::random_access_iterator<_Iter2>)

Returns a copy of a transform_input_output_iterator advanced by a given number of elements.

Parameters:
template<class _Iter2 = _Iter>
inline friend constexpr auto operator+(
difference_type __n,
const transform_input_output_iterator &__iter,
) noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter> && noexcept(::cuda::std::declval<const _Iter2&>() + difference_type{})) -> transform_input_output_iterator#
requires (::cuda::std::random_access_iterator<_Iter2>)

Returns a copy of a transform_input_output_iterator advanced by a given number of elements.

Parameters:
template<class _Iter2 = _Iter>
inline friend constexpr auto operator-(
const transform_input_output_iterator &__iter,
difference_type __n,
) noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter> && noexcept(::cuda::std::declval<const _Iter2&>() - difference_type{})) -> transform_input_output_iterator#
requires (::cuda::std::random_access_iterator<_Iter2>)

Returns a copy of a transform_input_output_iterator decremented by a given number of elements.

Parameters:
template<class _Iter2 = _Iter>
inline friend constexpr auto operator-(
const transform_input_output_iterator &__lhs,
const transform_input_output_iterator &__rhs,
) noexcept(noexcept(::cuda::std::declval<const _Iter2&>() - ::cuda::std::declval<const _Iter2&>())) -> difference_type#
requires (::cuda::std::sized_sentinel_for<_Iter2, _Iter2>)

Returns the distance between two transform_input_output_iterator.

template<class _Iter2 = _Iter>
inline friend constexpr auto operator==(
const transform_input_output_iterator &__lhs,
const transform_input_output_iterator &__rhs,
) noexcept(noexcept(::cuda::std::declval<const _Iter2&>() == ::cuda::std::declval<const _Iter2&>())) -> bool#
requires (::cuda::std::equality_comparable<_Iter2>)

Compares two transform_input_output_iterator for equality by comparing the stored iterators.

template<class _Iter2 = _Iter>
inline friend constexpr auto operator<(
const transform_input_output_iterator &__lhs,
const transform_input_output_iterator &__rhs,
) noexcept(noexcept(::cuda::std::declval<const _Iter2&>() < ::cuda::std::declval<const _Iter2&>())) -> bool#
requires (::cuda::std::random_access_iterator<_Iter2>)

Compares two transform_input_output_iterator for less than by comparing the stored iterators.

template<class _Iter2 = _Iter>
inline friend constexpr auto operator>(
const transform_input_output_iterator &__lhs,
const transform_input_output_iterator &__rhs,
) noexcept(noexcept(::cuda::std::declval<const _Iter2&>() < ::cuda::std::declval<const _Iter2&>())) -> bool#
requires (::cuda::std::random_access_iterator<_Iter2>)

Compares two transform_input_output_iterator for greater than by comparing the stored iterators.

template<class _Iter2 = _Iter>
inline friend constexpr auto operator<=(
const transform_input_output_iterator &__lhs,
const transform_input_output_iterator &__rhs,
) noexcept(noexcept(::cuda::std::declval<const _Iter2&>() < ::cuda::std::declval<const _Iter2&>())) -> bool#
requires (::cuda::std::random_access_iterator<_Iter2>)

Compares two transform_input_output_iterator for less equal by comparing the stored iterators.

template<class _Iter2 = _Iter>
inline friend constexpr auto operator>=(
const transform_input_output_iterator &__lhs,
const transform_input_output_iterator &__rhs,
) noexcept(noexcept(::cuda::std::declval<const _Iter2&>() < ::cuda::std::declval<const _Iter2&>())) -> bool#
requires (::cuda::std::random_access_iterator<_Iter2>)

Compares two transform_input_output_iterator for greater equal by comparing the stored iterators.