STD::EXPERIMENTAL::PROPAGATE_CONST(3)

💖 NAME 💖

std::experimental::propagate_const< _Tp > — a const-propagating wrapper, bestie. That's the whole thing, that's the vibe ✨

It's a Library Functions Manual page and it lives in libstdc++, so like, that's the fam we're hanging with 🫶

---

🌈 SYNOPSIS 🌈

#include <propagate_const>

---

🎀 Public Types 🎀

• using element_type — the one and only public type alias this class declares. That's the line. Short, sweet, iconic 💅

---

🦋 Public Member Functions 🦋

okay so here's the full roster, no skips, every single one 👑

• converting constructor, non-convertible flavour — only shows up when the constraints pass: _Tp has to be constructible from _Up &&, _Up && must not be convertible to _Tp, and the decayed _Up must not itself be a propagate_const. That trailing bool is false here.

template<typename _Up, typename enable_if< __and_< is_constructible< _Tp, _Up && >, __not_< is_convertible< _Up &&, _Tp > >, __not_< __is_propagate_const< typename decay< _Up >::type > > >::value, bool >::type = false> constexpr propagate_const (_Up &&__u)

• converting constructor, convertible flavour — same deal but the other way: _Tp constructible from _Up &&, _Up && is convertible to _Tp, and the decayed _Up still isn't a propagate_const. Trailing bool defaults to true this time.

template<typename _Up, typename enable_if< __and_< is_constructible< _Tp, _Up && >, is_convertible< _Up &&, _Tp >, __not_< __is_propagate_const< typename decay< _Up >::type > > >::value, bool >::type = true> constexpr propagate_const (_Up &&__u)

• copy constructor — =delete. Not happening. No copying, periodt 🚫

propagate_const (const propagate_const &__p)=delete

• move constructor — =default, so it's the compiler's own, untouched 💅

constexpr propagate_const (propagate_const &&__p)=default

• converting move constructor, non-convertible flavour — pulls from a propagate_const< _Up > && when _Tp is constructible from _Up && and _Up && is not convertible to _Tp. Trailing bool is false.

template<typename _Up, typename enable_if< __and_< is_constructible< _Tp, _Up && >, __not_< is_convertible< _Up &&, _Tp > > >::value, bool >::type = false> constexpr propagate_const (propagate_const< _Up > &&__pu)

• converting move constructor, convertible flavour — same but _Up && is convertible to _Tp. Trailing bool defaults to true.

template<typename _Up, typename enable_if< __and_< is_constructible< _Tp, _Up && >, is_convertible< _Up &&, _Tp > >::value, bool >::type = true> constexpr propagate_const (propagate_const< _Up > &&__pu)

• get (non-const) — hands you back an element_type *.

constexpr element_type * get ()

• get (const) — the const flavour, hands you back a const element_type *.

constexpr const element_type * get () const

• operator bool — the truthiness check, const, constexpr ✨

constexpr operator bool () const

• operator* — deref, non-const, gives you an element_type &.

constexpr element_type & operator* ()

• operator* (const) — deref, const, gives you a const element_type &.

constexpr const element_type & operator* () const

• operator-> — arrow, non-const, gives you an element_type *.

constexpr element_type * operator-> ()

• operator-> (const) — arrow, const, gives you a const element_type *.

constexpr const element_type * operator-> () const

• assignment from _Up && — only enabled when _Up && is convertible to _Tp and the decayed _Up is not a propagate_const. Returns propagate_const &.

template<typename _Up, typename = typename
    enable_if<__and_<is_convertible<_Up&&, _Tp>,
    __not_<__is_propagate_const<
    typename decay<_Up>::type>>
    >::value>::type> constexpr propagate_const & operator= (_Up &&__u)

• copy assignment — =delete again. Still no copying, bestie 💀

propagate_const & operator= (const propagate_const &__p)=delete

• move assignment — =default, compiler's own 👑

constexpr propagate_const & operator= (propagate_const &&__p)=default

• move assignment from propagate_const< _Up > && — enabled when _Up && is convertible to _Tp. Returns propagate_const &.

template<typename _Up, typename = typename
    enable_if<is_convertible<_Up&&, _Tp>::value>::type> constexpr
    propagate_const & operator= (propagate_const< _Up > &&__pu)

• swap — swaps with another propagate_const &. It's noexcept exactly when __is_nothrow_swappable< _Tp >::value is true, so the noexcept-ness rides entirely on _Tp 🦋

constexpr void swap (propagate_const &__pt)
    noexcept(__is_nothrow_swappable< _Tp >::value)

---

🌸 Friends 🌸

the little helper besties that get to peek inside 🫶

• get_underlying (const) — takes a const propagate_const< _Up > & and gives you back a const _Up &. It's noexcept, no drama.

template<typename _Up> constexpr const _Up & get_underlying (const
    propagate_const< _Up > &__pt) noexcept

• get_underlying (non-const) — takes a propagate_const< _Up > & and gives you back a _Up &. Also noexcept.

template<typename _Up> constexpr _Up & get_underlying (propagate_const<
    _Up > &__pt) noexcept

---

💜 Detailed Description 💜

here's the whole class, laid out in its full templated glory:

template<typename _Tp>
class std::experimental::propagate_const< _Tp >

"Const-propagating wrapper."

That's the description. It's short. It's giving minimalism. We respect it 💅

---

⭐ Author ⭐

Generated automatically by Doxygen for libstdc++ from the source code.

---

and that's a wrap, bestie 🎀 this whole page came out of libstdc++, auto-generated by Doxygen straight from the source code, and it's the std::experimental::propagate_const< _Tp >(3) page. go forth and propagate those consts 💖✨🦋