std::indirectly_writable

From cppreference.com
< cpp‎ | iterator
 
 
Iterator library
Iterator concepts
indirectly_writable
(C++20)
Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
Utilities
(C++20)
Iterator adaptors
Stream iterators
Iterator customization points
Iterator operations
(C++11)
(C++11)
Range access
(C++11)(C++14)
(C++11)(C++14)
(C++17)(C++20)
(C++14)(C++14)
(C++14)(C++14)
(C++17)
(C++17)
 
Defined in header <iterator>
template< class Out, class T >

  concept indirectly_writable =
    requires(Out&& o, T&& t) {
      *o = std::forward<T>(t);
      *std::forward<Out>(o) = std::forward<T>(t);
      const_cast<const std::iter_reference_t<Out>&&>(*o) = std::forward<T>(t);
      const_cast<const std::iter_reference_t<Out>&&>(*std::forward<Out>(o)) =
        std::forward<T>(t);
    };

    /* none of the four expressions above are required to be equality-preserving */
(since C++20)

The concept indirectly_writable<Out, T> specifies the requirements for writing a value whose type and value category are encoded by T into an iterator Out's referenced object.

Semantic requirements

Let e be an expression such that decltype((e)) is T, and o be a dereferenceable object of type Out, then indirectly_writable<Out, T> is modeled only if:

o is not required to be dereferenceable after evaluating any of the assignment expressions above. If e is an xvalue, the resulting state of the object it denotes is valid but unspecified.

Equality preservation

Expressions declared in requires-expressions of the standard library concepts are required to be equality-preserving (except where stated otherwise).

Notes

The only valid use of operator* is on the left side of an assignment expression. Assignment through the same value of an indirectly writable type may happen only once.

The required expressions with const_cast prevent indirectly_readable objects with prvalue reference types from satisfying the syntactic requirements of indirectly_writable by accident, while permitting proxy references to continue to work as long as their constness is shallow. See Ranges TS issue 381.