Non-propagating cache (C++20) - cppreference.com (original) (raw)
| template< class T > requires std::is_object_v<T> class /*non-propagating-cache*/; | | (since C++20) (exposition only*) | | --------------------------------------------------------------------------------------------------------------------- | | --------------------------------- |
Some range adaptors such as ranges::join_view and ranges::lazy_split_view conditionally store value (e.g. an iterator) which is specified in terms of an exposition-only class template _non-propagating-cache_.
The wrapper behaves exactly like std::optional<T>, except that:
- it does not copy the value of the source when it is copy constructed or assigned to,
- it resets the value of the source when it is moved-from,
- it resets its value when it is assigned from, and
- it additionally provides a member function template to enable an input view to temporarily cache values as it is iterated over.
The wrapper encapsulates a cache containing a value. Clearing cache is an operation equivalent to resetting a contained value. Such operation is performed when copying or moving a wrapper.
Contents
- 1 Template parameters
- 2 Member functions
- 3 Copy and move constructors
- 4 Copy and move assignment operators
- 5 non-propagating-cache::emplace-deref
- 6 Members identical to std::optional
[edit] Template parameters
| T | - | the type of the contained value, must be an object type |
|---|
[edit] Member functions
Copy and move constructors
| constexpr /*non-propagating-cache*/ ( const /*non-propagating-cache*/& ) noexcept {} | (1) | (since C++20) |
|---|---|---|
| constexpr /*non-propagating-cache*/ ( /*non-propagating-cache*/&& other ) noexcept { other.reset(); } | (2) | (since C++20) |
The copy constructor has no effect.
The move constructor clears the cache of other.
Copy and move assignment operators
| constexpr /*non-propagating-cache*/& operator=( const /*non-propagating-cache*/& other ) noexcept { if (std::addressof(other) != this) reset(); return *this; } | (1) | (since C++20) |
|---|---|---|
| constexpr /*non-propagating-cache*/& operator=( /*non-propagating-cache*/&& other ) noexcept { reset(); other.reset(); return *this; } | (2) | (since C++20) |
The copy assignment operator clears the cache of *this.
The move assignment operator clears caches of both *this and other.
_non-propagating-cache_<T>::_emplace-deref_
| template< class I > constexpr T& /*emplace-deref*/( const I& i ); | | (since C++20) (exposition only*) | | -------------------------------------------------------------------- | | --------------------------------- |
Initializes the contained value by direct-initializing (but not direct-list-initializing) with *i. If *this already contains a value before the call, reset() is called.
Returns a reference to the new contained value.
The program is ill-formed unless the declaration T t(*i); is well-formed for some invented variable t. If *i is a prvalue of possibly cv-qualified T, then it is not required to be movable.
Members identical to std::optional
Member functions
| (constructor) | constructs the optional object (public member function of std::optional) [edit] |
|---|---|
| (destructor) | destroys the contained value, if there is one (public member function of std::optional) [edit] |
| operator= | assigns contents (public member function of std::optional) [edit] |
| Observers | |
| operator->operator* | accesses the contained value (public member function of std::optional) [edit] |
| operator boolhas_value | checks whether the object contains a value (public member function of std::optional) [edit] |
| Modifiers | |
| reset | destroys any contained value (public member function of std::optional) [edit] |
| emplace | constructs the contained value in-place (public member function of std::optional) [edit] |
[edit] Notes
_non-propagating-cache_ is used in implementations to cache the result of begin() to provide an amortized constant time complexity of the method.