Namespaces
namespace	pf17

namespace	pf20

namespace	pmr

Classes
class	bad_optional_access

class	bad_unbounded_variant_access

class	bad_variant_access

class	basic_string_view

struct	conjunction

struct	disjunction

struct	in_place_index_t

struct	in_place_t

struct	in_place_type_t

struct	is_nothrow_swappable

struct	is_swappable

struct	monostate

struct	negation

struct	nullopt_t

class	optional

struct	overloaded

struct	overloaded< T >

struct	overloaded< T, Ts... >

class	rtti

struct	rtti_helper

class	unbounded_variant

class	VariableLengthArray

class	VariableLengthArray< bool, Allocator >

class	VariableLengthArrayBase

class	variant

struct	variant_alternative

struct	variant_size

Typedefs
using	byte = cetl::pf17::byte

template<typename T, std::size_t Extent = dynamic_extent>
using	span = cetl::pf20::span<T, Extent>

using	type_id = std::array<std::uint8_t, type_id_size>

template<std::uint8_t... Bytes>
using	type_id_type = std::integer_sequence<std::uint8_t, Bytes...>

template<typename ValueType>
using	unbounded_variant_like

template<typename...>
using	void_t

template<size_t N, typename V>
using	variant_alternative_t

using	string_view

Functions
template<typename TypeIDType>
constexpr type_id	type_id_type_value () noexcept

template<typename T>
constexpr type_id	type_id_getter () noexcept

template<>
constexpr type_id	type_id_getter< void > () noexcept

template<typename _u>
CETL_NODISCARD std::enable_if_t< is_rtti_convertible< _u >, bool >	is_instance_of (const _u &obj, const type_id &id) noexcept

template<typename Q, typename _u>
CETL_NODISCARD std::enable_if_t< is_rtti_convertible< _u >, bool >	is_instance_of (const _u &obj) noexcept

template<typename ValueType, typename UnboundedVariant>
std::add_pointer_t< ValueType >	get_if (UnboundedVariant *operand)

template<typename ValueType, typename UnboundedVariant>
std::add_pointer_t< std::add_const_t< ValueType > >	get_if (const UnboundedVariant *operand)

template<typename ValueType, typename UnboundedVariant = unbounded_variant_like<ValueType>, typename... Args, typename = detail::EnableIfNotPmrT<typename UnboundedVariant::pmr_type>>
CETL_NODISCARD UnboundedVariant	make_unbounded_variant (Args &&... args)

template<typename ValueType, typename UnboundedVariant = unbounded_variant_like<ValueType>, typename Up, typename... Args, typename = detail::EnableIfNotPmrT<typename UnboundedVariant::pmr_type>>
CETL_NODISCARD UnboundedVariant	make_unbounded_variant (std::initializer_list< Up > list, Args &&... args)

template<typename ValueType, typename UnboundedVariant = unbounded_variant_like<ValueType>, typename... Args, typename = detail::EnableIfPmrT<typename UnboundedVariant::pmr_type>>
CETL_NODISCARD UnboundedVariant	make_unbounded_variant (typename UnboundedVariant::pmr_type *const mem_res, Args &&... args)

template<typename ValueType, typename UnboundedVariant = unbounded_variant_like<ValueType>, typename Up, typename... Args, typename = detail::EnableIfPmrT<typename UnboundedVariant::pmr_type>>
CETL_NODISCARD UnboundedVariant	make_unbounded_variant (typename UnboundedVariant::pmr_type *const mem_res, std::initializer_list< Up > list, Args &&... args)

template<typename ValueType, typename UnboundedVariant>
CETL_NODISCARD ValueType	get (const UnboundedVariant &operand)

template<typename ValueType, typename UnboundedVariant>
CETL_NODISCARD ValueType	get (UnboundedVariant &operand)

template<typename ValueType, typename UnboundedVariant>
CETL_NODISCARD ValueType	get (UnboundedVariant &&operand)

template<typename ValueType, typename UnboundedVariant>
CETL_NODISCARD std::add_pointer_t< std::add_const_t< ValueType > >	get_if (const UnboundedVariant *const operand)

template<typename ValueType, typename UnboundedVariant>
CETL_NODISCARD std::add_pointer_t< ValueType >	get_if (UnboundedVariant *const operand)

template<typename... Ts>
constexpr overloaded< Ts... >	make_overloaded (Ts &&... ts)

template<typename T>
constexpr optional< std::decay_t< T > >	make_optional (T &&value)

template<std::size_t Ix, typename... Ts>
CETL_NODISCARD constexpr variant_alternative_t< Ix, variant< Ts... > > &	get (variant< Ts... > &var)

template<std::size_t Ix, typename... Ts>
CETL_NODISCARD constexpr std::add_pointer_t< variant_alternative_t< Ix, variant< Ts... > > >	get_if (variant< Ts... > *const var) noexcept

template<typename Fun, typename... Vs>
constexpr decltype(auto)	visit (Fun &&fun, Vs &&... vars)

template<typename T, typename... Ts>
CETL_NODISCARD constexpr bool	holds_alternative (const variant< Ts... > &var) noexcept


template<typename T, typename _from>
CETL_NODISCARD std::enable_if_t< is_rtti_convertible< _from > &&std::is_pointer< T >::value &&has_type_id< std::remove_pointer_t< T > >, T >	rtti_cast (_from *const obj) noexcept

template<typename T, typename _from>
CETL_NODISCARD std::enable_if_t< is_rtti_convertible< _from > &&std::is_pointer< T >::value &&has_type_id< std::remove_pointer_t< T > >, const std::remove_pointer_t< T > * >	rtti_cast (const _from *const obj) noexcept

Variables
constexpr std::size_t	dynamic_extent = cetl::pf20::dynamic_extent

constexpr std::size_t	type_id_size = 16

template<typename T>
constexpr bool	has_type_id = decltype(detail::has_type_id_impl<std::decay_t<T>>(0))::value

template<typename T>
constexpr bool	is_rtti_convertible = decltype(detail::has_cast_impl<std::decay_t<T>>(0))::value

template<typename T>
constexpr type_id	type_id_value = type_id_getter<T>()

constexpr in_place_t	in_place

template<typename T>
constexpr in_place_type_t< T >	in_place_type

template<std::size_t I>
constexpr in_place_index_t< I >	in_place_index

constexpr nullopt_t	nullopt

template<typename T>
constexpr bool	is_swappable_v

template<typename T>
constexpr bool	is_nothrow_swappable_v

template<typename... Ts>
constexpr bool	conjunction_v

template<typename... Ts>
constexpr bool	disjunction_v

template<typename T>
constexpr bool	negation_v

template<typename V>
constexpr size_t	variant_size_v

constexpr std::size_t	variant_npos

Detailed Description

This namespace contains types specific to CETL and nested namespaces that contain types adhering to target C++ specifications.

Copyright: Copyright (C) OpenCyphal Development Team <opencyphal.org> Copyright Amazon.com Inc. or its affiliates. SPDX-License-Identifier: MIT

Typedef Documentation

◆ type_id

using cetl::type_id = std::array<std::uint8_t, type_id_size>

A 16-byte UUID (GUID) that uniquely identifies a type.

The user is responsible for ensuring that each type that has opted into this RTTI capability has a unique type ID exposed via a public method static constexpr cetl::type_id get_type_id() noexcept.

◆ type_id_type

template<std::uint8_t... Bytes>

using cetl::type_id_type = std::integer_sequence<std::uint8_t, Bytes...>

This is used for representing the type ID of a type as a type, similar to std::integral_constant.

The bytes of the UUID are given as a list of template parameters; there shall be at most 16 of them; if any are missing, they are assumed to be 0. For conversion to type_id use cetl::type_id_type_value. Please don't use empty or all zeros bytes (reserved for type_id_value<void> specialization).

◆ unbounded_variant_like

template<typename ValueType>

using cetl::unbounded_variant_like

Initial value:

unbounded_variant<sizeof(ValueType),
                                             std::is_copy_constructible<ValueType>::value,
                                             std::is_move_constructible<ValueType>::value,
                                             alignof(ValueType)>

Typealias for unbounded_variant with the given ValueType with the default footprint, copyability, movability, and alignment of the ValueType.

In use by cetl::make_unbounded_variant overloads.

◆ variant_alternative_t

template<size_t N, typename V>

using cetl::pf17::variant_alternative_t

Implementation of std::variant_alternative_t.

This implementation also accepts other typelist-parameterized classes, such as std::variant.

◆ void_t

template<typename...>

using cetl::pf17::void_t

Implementation of std::void_t.

Function Documentation

◆ get() [1/4]

template<typename ValueType, typename UnboundedVariant>

CETL_NODISCARD ValueType cetl::get ( const UnboundedVariant & operand )

Performs type-safe access to the contained object.

Parameters

operand Target unbounded_variant object.

Returns: Returns std::static_cast<ValueType>(*cetlget_if<const U>(&operand)), where let U be std::remove_cv_t<std::remove_reference_t<ValueType>>.

References CETL_NODISCARD, and get_if().

◆ get() [2/4]

template<typename ValueType, typename UnboundedVariant>

CETL_NODISCARD ValueType cetl::get ( UnboundedVariant && operand )

Performs type-safe access to the contained object.

Parameters

operand Target unbounded_variant object.

Returns: Returns std::static_cast<ValueType>(std::move(*cetlget_if<U>(&operand))), where let U be std::remove_cv_t<std::remove_reference_t<ValueType>>.

References CETL_NODISCARD, and get_if().

◆ get() [3/4]

template<typename ValueType, typename UnboundedVariant>

CETL_NODISCARD ValueType cetl::get ( UnboundedVariant & operand )

Performs type-safe access to the contained object.

Parameters

operand Target unbounded_variant object.

Returns: Returns std::static_cast<ValueType>(*cetlget_if<U>(&operand)), where let U be std::remove_cv_t<std::remove_reference_t<ValueType>>.

References CETL_NODISCARD, and get_if().

◆ get() [4/4]

template<std::size_t Ix, typename... Ts>

CETL_NODISCARD constexpr variant_alternative_t< Ix, variant< Ts... > > & cetl::pf17::get ( variant< Ts... > & var )

constexpr

Implementation of std::get(std::variant).

◆ get_if() [1/5]

template<typename ValueType, typename UnboundedVariant>

CETL_NODISCARD std::add_pointer_t< std::add_const_t< ValueType > > cetl::get_if ( const UnboundedVariant *const operand )

noexcept

Performs type-safe access to the const contained object.

Template Parameters

ValueType	Type of the requested value; may not be a reference.
UnboundedVariant	Type of the `unbounded_variant` object.

Parameters

operand Target constant unbounded_variant object.

Returns: If operand is not a null pointer, and the typeid of the requested ValueType matches that of the contents of operand, a pointer to the value contained by operand, otherwise a null pointer.

◆ get_if() [2/5]

template<typename ValueType, typename UnboundedVariant>

std::add_pointer_t< std::add_const_t< ValueType > > cetl::get_if ( const UnboundedVariant *const operand )

noexcept

Performs type-safe access to the const contained object.

Template Parameters

ValueType	Type of the requested value; may not be a reference.
UnboundedVariant	Type of the `unbounded_variant` object.

Parameters

operand Target constant unbounded_variant object.

Returns: If operand is not a null pointer, and the typeid of the requested ValueType matches that of the contents of operand, a pointer to the value contained by operand, otherwise a null pointer.

◆ get_if() [3/5]

template<typename ValueType, typename UnboundedVariant>

CETL_NODISCARD std::add_pointer_t< ValueType > cetl::get_if ( UnboundedVariant *const operand )

noexcept

Performs type-safe access to the contained object.

Template Parameters

ValueType	Type of the requested value; may not be a reference.
UnboundedVariant	Type of the `unbounded_variant` object.

Parameters

operand Target unbounded_variant object.

Returns: If operand is not a null pointer, and the typeid of the requested ValueType matches that of the contents of operand, a pointer to the value contained by operand, otherwise a null pointer.

Referenced by cetl::pmr::function< Result(Args...), Footprint, Pmr >::function(), get(), get(), get(), cetl::pmr::function< Result(Args...), Footprint, Pmr >::operator=(), cetl::pmr::function< Result(Args...), Footprint, Pmr >::operator=(), cetl::pmr::function< Result(Args...), Footprint, Pmr >::operator=(), and cetl::pmr::function< Result(Args...), Footprint, Pmr >::swap().

Here is the caller graph for this function:

◆ get_if() [4/5]

template<typename ValueType, typename UnboundedVariant>

std::add_pointer_t< ValueType > cetl::get_if ( UnboundedVariant *const operand )

noexcept

Performs type-safe access to the contained object.

Template Parameters

ValueType	Type of the requested value; may not be a reference.
UnboundedVariant	Type of the `unbounded_variant` object.

Parameters

operand Target unbounded_variant object.

Returns: If operand is not a null pointer, and the typeid of the requested ValueType matches that of the contents of operand, a pointer to the value contained by operand, otherwise a null pointer.

Referenced by cetl::pmr::function< Result(Args...), Footprint, Pmr >::function(), get(), get(), get(), cetl::pmr::function< Result(Args...), Footprint, Pmr >::operator=(), cetl::pmr::function< Result(Args...), Footprint, Pmr >::operator=(), cetl::pmr::function< Result(Args...), Footprint, Pmr >::operator=(), and cetl::pmr::function< Result(Args...), Footprint, Pmr >::swap().

Here is the caller graph for this function:

◆ get_if() [5/5]

template<std::size_t Ix, typename... Ts>

CETL_NODISCARD constexpr std::add_pointer_t< variant_alternative_t< Ix, variant< Ts... > > > cetl::pf17::get_if ( variant< Ts... > *const var )

constexprnoexcept

Implementation of std::get_if(std::variant).

◆ holds_alternative()

template<typename T, typename... Ts>

CETL_NODISCARD constexpr bool cetl::pf17::holds_alternative ( const variant< Ts... > & var )

constexprnoexcept

Implementation of std::holds_alternative.

◆ is_instance_of() [1/2]

template<typename Q, typename _u>

CETL_NODISCARD std::enable_if_t< is_rtti_convertible< _u >, bool > cetl::is_instance_of ( const _u & obj )

noexcept

Detects whether the given polymorphic object is an instance of the given type.

T shall satisfy cetl::has_type_id. Refer to the non-template overload for details.

References CETL_NODISCARD, is_instance_of(), and type_id_value.

◆ is_instance_of() [2/2]

template<typename _u>

CETL_NODISCARD std::enable_if_t< is_rtti_convertible< _u >, bool > cetl::is_instance_of	(	const _u &	obj,
		const type_id &	id )

noexcept

Detects whether the given polymorphic object is an instance of the type with the given type ID.

For example, given a polymorphic type hierarchy A<-B<-C, is_instance_of(C{}, get_type_id<X>())==true for X in {A,B,C}; while is_instance_of(A{}, get_type_id<X>())==true only for X=A.

Note that the type of the object argument is not rtti& but the actual type of the object, because in the presence of multiple inheritance implicit conversion to the base class is ambiguous.

References CETL_NODISCARD.

Referenced by is_instance_of().

Here is the caller graph for this function:

◆ make_optional()

template<typename T>

optional< std::decay_t< T > > cetl::pf17::make_optional ( T && value )

constexpr

An implementation of C++17 std::make_optional.

◆ make_overloaded()

template<typename... Ts>

overloaded< Ts... > cetl::make_overloaded ( Ts &&... ts )

constexpr

Returns an instance of overloaded that can be used with visit.

The usage is as follows:

visit(make_overloaded(
[](const auto&)        { return "fallback"; },
[](double)             { return "double";   },
[](const std::string&) { return "string";   }
),variant);

References std::forward().

◆ make_unbounded_variant() [1/4]

template<typename ValueType, typename UnboundedVariant = unbounded_variant_like<ValueType>, typename... Args, typename = detail::EnableIfNotPmrT<typename UnboundedVariant::pmr_type>>

CETL_NODISCARD UnboundedVariant cetl::make_unbounded_variant ( Args &&... args )

Makes an unbounded_variant object with in place constructed value.

Size of the value must be less than or equal to Footprint. Any failure during the construction will result in the "valueless by exception" state.

Template Parameters

ValueType	Type of the value to be stored. Its size must be less than or equal to `Footprint`.
UnboundedVariant	Template type of the result unbounded variant.
Args	Types of arguments to be passed to the constructor of `ValueType`.

Parameters

args	Arguments to be forwarded to the constructor of `ValueType`.

References CETL_NODISCARD, and std::forward().

◆ make_unbounded_variant() [2/4]

template<typename ValueType, typename UnboundedVariant = unbounded_variant_like<ValueType>, typename Up, typename... Args, typename = detail::EnableIfNotPmrT<typename UnboundedVariant::pmr_type>>

CETL_NODISCARD UnboundedVariant cetl::make_unbounded_variant	(	std::initializer_list< Up >	list,
		Args &&...	args )

Makes an unbounded_variant object with in place constructed value and initializer list.

Size of the value must be less than or equal to Footprint. Any failure during the construction will result in the "valueless by exception" state.

Template Parameters

ValueType	Type of the value to be stored. Its size must be less than or equal to `Footprint`.
UnboundedVariant	Template type of the result unbounded variant.
Up	Type of the elements of the initializer list.
Args	Types of arguments to be passed to the constructor of `ValueType`.

Parameters

mem_res	Pointer to a memory resource to be used by the variant.
list	Initializer list to be forwarded to the constructor of `ValueType`.
args	Arguments to be forwarded to the constructor of `ValueType`.

References CETL_NODISCARD, and std::forward().

◆ make_unbounded_variant() [3/4]

template<typename ValueType, typename UnboundedVariant = unbounded_variant_like<ValueType>, typename... Args, typename = detail::EnableIfPmrT<typename UnboundedVariant::pmr_type>>

CETL_NODISCARD UnboundedVariant cetl::make_unbounded_variant	(	typename UnboundedVariant::pmr_type *const	mem_res,
		Args &&...	args )

Makes a PMR-enabled unbounded_variant object with in place constructed value.

Size of the value must be less than or equal to Footprint to benefit small object optimization, otherwise the value will be stored into PMR allocated storage. Any failure during the construction will result in the "valueless by exception" state.

Template Parameters

ValueType	Type of the value to be stored. Its size must be less than or equal to `Footprint`.
UnboundedVariant	Template type of the result unbounded variant.
Args	Types of arguments to be passed to the constructor of `ValueType`.

Parameters

mem_res	Pointer to a memory resource to be used by the variant.
list	Initializer list to be forwarded to the constructor of `ValueType`.
args	Arguments to be forwarded to the constructor of `ValueType`.

References CETL_NODISCARD, and std::forward().

◆ make_unbounded_variant() [4/4]

template<typename ValueType, typename UnboundedVariant = unbounded_variant_like<ValueType>, typename Up, typename... Args, typename = detail::EnableIfPmrT<typename UnboundedVariant::pmr_type>>

CETL_NODISCARD UnboundedVariant cetl::make_unbounded_variant	(	typename UnboundedVariant::pmr_type *const	mem_res,
		std::initializer_list< Up >	list,
		Args &&...	args )

Makes a PMR-enabled unbounded_variant object with in place constructed value and initializer list.

Size of the value must be less than or equal to Footprint to benefit small object optimization, otherwise the value will be stored into PMR allocated storage. Any failure during the construction will result in the "valueless by exception" state.

Template Parameters

ValueType	Type of the value to be stored. Its size must be less than or equal to `Footprint`.
UnboundedVariant	Template type of the result unbounded variant.
Up	Type of the elements of the initializer list.
Args	Types of arguments to be passed to the constructor of `ValueType`.

Parameters

mem_res	Pointer to a memory resource to be used by the variant.
list	Initializer list to be forwarded to the constructor of `ValueType`.
args	Arguments to be forwarded to the constructor of `ValueType`.

References CETL_NODISCARD, and std::forward().

◆ rtti_cast() [1/2]

template<typename T, typename _from>

CETL_NODISCARD std::enable_if_t< is_rtti_convertible< _from > &&std::is_pointer< T >::value &&has_type_id< std::remove_pointer_t< T > >, T > cetl::rtti_cast ( _from *const obj )

noexcept

Performs a safe dynamic type up-/down-conversion in constant time by invoking cetl::rtti::_cast_.

T shall be a pointer and std::remove_pointer_t<T> shall satisfy cetl::has_type_id. Returns nullptr if a safe dynamic type conversion to T is not possible.

References type_id_value.

◆ rtti_cast() [2/2]

template<typename T, typename _from>

CETL_NODISCARD std::enable_if_t< is_rtti_convertible< _from > &&std::is_pointer< T >::value &&has_type_id< std::remove_pointer_t< T > >, const std::remove_pointer_t< T > * > cetl::rtti_cast ( const _from *const obj )

noexcept

Performs a safe dynamic type up-/down-conversion in constant time by invoking cetl::rtti::_cast_.

T shall be a pointer and std::remove_pointer_t<T> shall satisfy cetl::has_type_id. Returns nullptr if a safe dynamic type conversion to T is not possible.

References type_id_value.

◆ type_id_getter()

template<typename T>

type_id cetl::type_id_getter ( )

constexprnoexcept

The type ID getter for the given type.

This helper is provided for regularity; it returns the same value as T::_get_type_id_(). The type shall satisfy cetl::has_type_id. Specialize this getter to add RTTI support to types where it is not possible to define a static method (e.g., builtins, pointers, third-party classes, etc).

◆ type_id_getter< void >()

template<>

type_id cetl::type_id_getter< void > ( )

constexprnoexcept

The type ID getter specialization reserved for void type - returns all zeros.

◆ type_id_type_value()

template<typename TypeIDType>

type_id cetl::type_id_type_value ( )

constexprnoexcept

A helper that converts cetl::type_id_type to cetl::type_id.

Referenced by cetl::rtti_helper< TypeIDType, Bases >::_get_type_id_().

Here is the caller graph for this function:

◆ visit()

template<typename Fun, typename... Vs>

decltype(auto) cetl::pf17::visit	(	Fun &&	fun,
		Vs &&...	vars )

constexpr

Implementation of std::visit.

Variable Documentation

◆ conjunction_v

template<typename... Ts>

bool cetl::pf17::conjunction_v

constexpr

Implementation of std::conjunction_v.

◆ disjunction_v

template<typename... Ts>

bool cetl::pf17::disjunction_v

constexpr

Implementation of std::disjunction_v.

◆ has_type_id

template<typename T>

bool cetl::has_type_id = decltype(detail::has_type_id_impl<std::decay_t<T>>(0))::value

constexpr

True iff T has a public static method _get_type_id_().

◆ in_place

in_place_t cetl::pf17::in_place

constexpr

Polyfill for std::in_place.

◆ in_place_index

template<std::size_t I>

in_place_index_t<I> cetl::pf17::in_place_index

constexpr

Implementation of std::in_place_index.

◆ in_place_type

template<typename T>

in_place_type_t<T> cetl::pf17::in_place_type

constexpr

Implementation of std::in_place_type.

◆ is_nothrow_swappable_v

template<typename T>

bool cetl::pf17::is_nothrow_swappable_v

constexpr

Implementation of std::is_nothrow_swappable_v.

◆ is_rtti_convertible

template<typename T>

bool cetl::is_rtti_convertible = decltype(detail::has_cast_impl<std::decay_t<T>>(0))::value

constexpr

True iff T has a public method _cast_().

◆ is_swappable_v

template<typename T>

bool cetl::pf17::is_swappable_v

constexpr

Implementation of std::is_swappable_v.

◆ negation_v

template<typename T>

bool cetl::pf17::negation_v

constexpr

Implementation of std::negation_v.

◆ nullopt

nullopt_t cetl::pf17::nullopt

constexpr

An implementation of C++17 std::nullopt.

◆ type_id_size

std::size_t cetl::type_id_size = 16

constexpr

This many bytes are used to represent a type ID. This is enough to hold a standard UUID (GUID).

◆ type_id_value

template<typename T>

type_id cetl::type_id_value = type_id_getter<T>()

constexpr

The type ID value of the given type.

This helper is provided for regularity; it has the same value as T::_get_type_id_(). The type shall satisfy cetl::has_type_id.

Referenced by is_instance_of(), rtti_cast(), and rtti_cast().

◆ variant_npos

std::size_t cetl::pf17::variant_npos

constexpr

Implementation of std::variant_npos.

◆ variant_size_v

template<typename V>

size_t cetl::pf17::variant_size_v

constexpr

Implementation of std::variant_size_v.

This implementation also accepts other typelist-parameterized classes, such as std::variant.

	CETL 0.0.0

Namespaces

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

◆ type_id

◆ type_id_type

◆ unbounded_variant_like

◆ variant_alternative_t

◆ void_t

Function Documentation

◆ get() [1/4]

◆ get() [2/4]

◆ get() [3/4]

◆ get() [4/4]

◆ get_if() [1/5]

◆ get_if() [2/5]

◆ get_if() [3/5]

◆ get_if() [4/5]

◆ get_if() [5/5]

◆ holds_alternative()

◆ is_instance_of() [1/2]

◆ is_instance_of() [2/2]

◆ make_optional()

◆ make_overloaded()

◆ make_unbounded_variant() [1/4]

◆ make_unbounded_variant() [2/4]

◆ make_unbounded_variant() [3/4]

◆ make_unbounded_variant() [4/4]

◆ rtti_cast() [1/2]

◆ rtti_cast() [2/2]

◆ type_id_getter()

◆ type_id_getter< void >()

◆ type_id_type_value()

◆ visit()

Variable Documentation

◆ conjunction_v

◆ disjunction_v

◆ has_type_id

◆ in_place

◆ in_place_index

◆ in_place_type

◆ is_nothrow_swappable_v

◆ is_rtti_convertible

◆ is_swappable_v

◆ negation_v

◆ nullopt

◆ type_id_size

◆ type_id_value

◆ variant_npos

◆ variant_size_v