std:: indirectly_writable

From cppreference.com
C++
Iterator library
Iterator concepts
Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)
Iterator adaptors
Range access
(C++11) (C++14)
(C++14) (C++14)
(C++11) (C++14)
(C++14) (C++14)
(C++17) (C++20)
(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 .

Retrieved from " https://en.cppreference.com/mwiki/index.php?title=cpp/iterator/indirectly_writable&oldid=159909 "