#include "cetl/unbounded_variant.hpp"

Classes
struct	in_place_type_t

Public Types
using	pmr_type = Pmr

Public Member Functions
template<typename PmrAlias = Pmr, typename = detail::EnableIfNotPmrT<PmrAlias>>
	unbounded_variant ()

template<typename PmrAlias = Pmr, typename = detail::EnableIfPmrT<PmrAlias>>
	unbounded_variant (Pmr *const mem_res)

	unbounded_variant (const unbounded_variant &other)=default

	unbounded_variant (unbounded_variant &&other) noexcept=default

template<typename ValueType, typename Tp = std::decay_t<ValueType>, typename PmrAlias = Pmr, typename = detail::EnableIfNotPmrT<PmrAlias>, typename = std::enable_if_t<!std::is_same<Tp, unbounded_variant>::value && !is_in_place_type<ValueType>::value>>
	unbounded_variant (ValueType &&value)

template<typename ValueType, typename Tp = std::decay_t<ValueType>, typename PmrAlias = Pmr, typename = detail::EnableIfPmrT<PmrAlias>, typename = std::enable_if_t<!std::is_same<Tp, unbounded_variant>::value && !is_in_place_type<ValueType>::value>>
	unbounded_variant (Pmr *const mem_res, ValueType &&value)

template<typename ValueType, typename... Args, typename Tp = std::decay_t<ValueType>, typename PmrAlias = Pmr, typename = detail::EnableIfNotPmrT<PmrAlias>>
	unbounded_variant (in_place_type_t< ValueType >, Args &&... args)

template<typename ValueType, typename... Args, typename Tp = std::decay_t<ValueType>, typename PmrAlias = Pmr, typename = detail::EnableIfPmrT<PmrAlias>>
	unbounded_variant (Pmr *const mem_res, in_place_type_t< ValueType >, Args &&... args)

template<typename ValueType, typename Up, typename... Args, typename Tp = std::decay_t<ValueType>, typename PmrAlias = Pmr, typename = detail::EnableIfNotPmrT<PmrAlias>>
	unbounded_variant (in_place_type_t< ValueType >, std::initializer_list< Up > list, Args &&... args)

template<typename ValueType, typename Up, typename... Args, typename Tp = std::decay_t<ValueType>, typename PmrAlias = Pmr, typename = detail::EnableIfPmrT<PmrAlias>>
	unbounded_variant (Pmr *const mem_res, in_place_type_t< ValueType >, std::initializer_list< Up > list, Args &&... args)

	~unbounded_variant ()

unbounded_variant &	operator= (const unbounded_variant &rhs)

unbounded_variant &	operator= (unbounded_variant &&rhs) noexcept

template<typename ValueType, typename Tp = std::decay_t<ValueType>, typename = std::enable_if_t<!std::is_same<Tp, unbounded_variant>::value>>
unbounded_variant &	operator= (ValueType &&value)

template<typename ValueType, typename... Args, typename Tp = std::decay_t<ValueType>>
Tp *	emplace (Args &&... args)

template<typename ValueType, typename Up, typename... Args, typename Tp = std::decay_t<ValueType>>
Tp *	emplace (std::initializer_list< Up > list, Args &&... args)

void	swap (unbounded_variant &rhs) noexcept(Movable)

template<typename PmrAlias = Pmr, typename = detail::EnableIfPmrT<PmrAlias>>
CETL_NODISCARD Pmr *	get_memory_resource () const noexcept

template<typename PmrAlias = Pmr, typename = detail::EnableIfPmrT<PmrAlias>>
void	reset (Pmr *const mem_res) noexcept

Friends
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)

Detailed Description

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>
class cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >

The class unbounded_variant describes a type-safe container for single values of unbounded_variant copy and/or move constructible type.

Size of a contained value must be less than or equal to Footprint to benefit small object optimization, and it can't be bigger than Footprint in case of disabled Polymorphic Memory Resource (PMR) support.

Template Parameters

Footprint	Maximum size of an in-place stored object (in bytes).
Copyable	Determines whether a contained object is copy constructible.
Movable	Determines whether a contained object is move constructible.
Alignment	Alignment of storage for a contained object.
Pmr	Type of Polymorphic Memory Resource (PMR). Use `void` to disable PMR support.

Member Typedef Documentation

◆ pmr_type

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

using cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::pmr_type = Pmr

Type of the Polymorphic Memory Resource (PMR) used by the variant.

void if PMR support is disabled.

Constructor & Destructor Documentation

◆ unbounded_variant() [1/10]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename PmrAlias = Pmr, typename = detail::EnableIfNotPmrT<PmrAlias>>

cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::unbounded_variant ( )

inline

Constructs an empty unbounded_variant object.

◆ unbounded_variant() [2/10]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename PmrAlias = Pmr, typename = detail::EnableIfPmrT<PmrAlias>>

cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::unbounded_variant ( Pmr *const mem_res )

inlineexplicit

Constructs an empty unbounded_variant object with PMR support.

Parameters

mem_res Pointer to a memory resource to be used by the variant.

◆ unbounded_variant() [3/10]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::unbounded_variant ( const unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr > & other )

default

Constructs an unbounded_variant object with a copy of the content of other.

Any failure during the copy operation will result in the "valueless by exception" state. In case of enabled PMR support, the memory resource pointer is copied from the other variant.

◆ unbounded_variant() [4/10]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::unbounded_variant ( unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr > && other )

defaultnoexcept

Constructs an unbounded_variant object with the content of other using move semantics.

Any failure during the move operation will result in the "valueless by exception" state. In case of enabled PMR support, the memory resource pointer is copied from the other variant.

◆ unbounded_variant() [5/10]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename ValueType, typename Tp = std::decay_t<ValueType>, typename PmrAlias = Pmr, typename = detail::EnableIfNotPmrT<PmrAlias>, typename = std::enable_if_t<!std::is_same<Tp, unbounded_variant>::value && !is_in_place_type<ValueType>::value>>

cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::unbounded_variant ( ValueType && value )

inline

Constructs an unbounded_variant object by forwarding a value into variant's storage.

Size of the value must be less than or equal to Footprint. Any failure during the value forwarding 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 in case of PMR support.

Parameters

value Value to be stored.

◆ unbounded_variant() [6/10]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename ValueType, typename Tp = std::decay_t<ValueType>, typename PmrAlias = Pmr, typename = detail::EnableIfPmrT<PmrAlias>, typename = std::enable_if_t<!std::is_same<Tp, unbounded_variant>::value && !is_in_place_type<ValueType>::value>>

cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::unbounded_variant	(	Pmr *const	mem_res,
		ValueType &&	value )

inline

Constructs an unbounded_variant object by forwarding a value into variant's storage.

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 value forwarding will result in the "valueless by exception" state.

Template Parameters

ValueType Type of the value to be stored.

Parameters

mem_res	Pointer to a memory resource to be used by the variant.
value	Value to be stored.

◆ unbounded_variant() [7/10]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename ValueType, typename... Args, typename Tp = std::decay_t<ValueType>, typename PmrAlias = Pmr, typename = detail::EnableIfNotPmrT<PmrAlias>>

cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::unbounded_variant	(	in_place_type_t< ValueType >	,
		Args &&...	args )

inlineexplicit

Constructs an unbounded_variant object with in place constructed value.

Please consider using cetl::make_unbounded_variant helper instead.

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.
Args	Types of arguments to be passed to the constructor of `ValueType`.

Parameters

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

◆ unbounded_variant() [8/10]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename ValueType, typename... Args, typename Tp = std::decay_t<ValueType>, typename PmrAlias = Pmr, typename = detail::EnableIfPmrT<PmrAlias>>

cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::unbounded_variant	(	Pmr *const	mem_res,
		in_place_type_t< ValueType >	,
		Args &&...	args )

inlineexplicit

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

Please consider using cetl::make_unbounded_variant helper instead.

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.
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.
args	Arguments to be forwarded to the constructor of `ValueType`.

◆ unbounded_variant() [9/10]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename ValueType, typename Up, typename... Args, typename Tp = std::decay_t<ValueType>, typename PmrAlias = Pmr, typename = detail::EnableIfNotPmrT<PmrAlias>>

cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::unbounded_variant	(	in_place_type_t< ValueType >	,
		std::initializer_list< Up >	list,
		Args &&...	args )

inlineexplicit

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

Please consider using cetl::make_unbounded_variant helper instead.

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`.
Up	Type of the elements of the initializer list.
Args	Types of arguments to be passed to the constructor of `ValueType`.

Parameters

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

◆ unbounded_variant() [10/10]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename ValueType, typename Up, typename... Args, typename Tp = std::decay_t<ValueType>, typename PmrAlias = Pmr, typename = detail::EnableIfPmrT<PmrAlias>>

cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::unbounded_variant	(	Pmr *const	mem_res,
		in_place_type_t< ValueType >	,
		std::initializer_list< Up >	list,
		Args &&...	args )

inlineexplicit

Constructs 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`.
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`.

◆ ~unbounded_variant()

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::~unbounded_variant ( )

inline

Destroys the contained object if there is one.

Member Function Documentation

◆ emplace() [1/2]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename ValueType, typename... Args, typename Tp = std::decay_t<ValueType>>

Tp * cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::emplace ( Args &&... args )

inline

Emplaces a new value to *this.

Size of the value must be less than or equal to Footprint to benefit small object optimization, and it can't be bigger than Footprint in case of PMR support is disabled. Any failure during the forwarding will result in the "valueless by exception" state.

Template Parameters

ValueType	Type of the value to be stored.
Args	Types of arguments to be passed to the constructor of `ValueType`.

Parameters

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

◆ emplace() [2/2]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename ValueType, typename Up, typename... Args, typename Tp = std::decay_t<ValueType>>

Tp * cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::emplace	(	std::initializer_list< Up >	list,
		Args &&...	args )

inline

Emplaces a new value to *this using initializer list.

Size of the value must be less than or equal to Footprint to benefit small object optimization, and it can't be bigger than Footprint in case of PMR support is disabled. Any failure during the emplacement will result in the "valueless by exception" state.

Template Parameters

ValueType	Type of the value to be stored.
Up	Type of the elements of the initializer list.
Args	Types of arguments to be passed to the constructor of `ValueType`.

Parameters

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

◆ get_memory_resource()

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename PmrAlias = Pmr, typename = detail::EnableIfPmrT<PmrAlias>>

CETL_NODISCARD Pmr * cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::get_memory_resource ( ) const

inlinenoexcept

Gets current memory resource in use by the variant.

◆ operator=() [1/3]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

unbounded_variant & cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::operator= ( const unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr > & rhs )

inline

Assigns the content of rhs to *this using copy semantics.

Any failure during the copy operation will result in the "valueless by exception" state. In case of enabled PMR support, the memory resource pointer is copied from the rhs variant.

◆ operator=() [2/3]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

unbounded_variant & cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::operator= ( unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr > && rhs )

inlinenoexcept

Assigns the content of rhs to *this using move semantics.

Any failure during the move operation will result in the "valueless by exception" state. In case of enabled PMR support, the memory resource pointer is copied from the rhs variant.

◆ operator=() [3/3]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename ValueType, typename Tp = std::decay_t<ValueType>, typename = std::enable_if_t<!std::is_same<Tp, unbounded_variant>::value>>

unbounded_variant & cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::operator= ( ValueType && value )

inline

Assigns value to *this by forwarding its value.

Size of the value must be less than or equal to Footprint to benefit small object optimization, and it can't be bigger than Footprint in case of PMR support is disabled. Any failure during the forwarding will result in the "valueless by exception" state.

Template Parameters

ValueType Type of the value to be stored.

◆ reset()

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename PmrAlias = Pmr, typename = detail::EnableIfPmrT<PmrAlias>>

void cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::reset ( Pmr *const mem_res )

inlinenoexcept

Resets the variant to empty state and assigns a new memory resource.

Useful to recover from the "valueless by exception" state (see swap method).

◆ swap()

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

void cetl::unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr >::swap ( unbounded_variant< Footprint, Copyable, Movable, Alignment, Pmr > & rhs )

inlinenoexcept

Swaps the content of *this with the content of rhs using either move (if available) or copy semantics.

In case of enabled PMR support, memory resource pointers are swapped as well.

Any failure during the swap could result in the "valueless by exception" state, and depending on which stage of swapping the failure happened it could affect (invalidate) either of *this or rhs variants. Use valueless_by_exception() method to check if a variant is in such failure state, and reset (or reset(Pmr*)) method (or assign a new value) to recover from it.

Friends And Related Symbol Documentation

◆ get_if [1/2]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename ValueType, typename UnboundedVariant>

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

friend

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/2]

template<std::size_t Footprint, bool Copyable = true, bool Movable = Copyable, std::size_t Alignment = alignof(std::max_align_t), typename Pmr = void>

template<typename ValueType, typename UnboundedVariant>

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

friend

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.

The documentation for this class was generated from the following file:

/__w/CETL/CETL/include/cetl/unbounded_variant.hpp

	CETL 0.0.0

Classes

Public Types

Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ pmr_type

Constructor & Destructor Documentation

◆ unbounded_variant() [1/10]

◆ unbounded_variant() [2/10]

◆ unbounded_variant() [3/10]

◆ unbounded_variant() [4/10]

◆ unbounded_variant() [5/10]

◆ unbounded_variant() [6/10]

◆ unbounded_variant() [7/10]

◆ unbounded_variant() [8/10]

◆ unbounded_variant() [9/10]

◆ unbounded_variant() [10/10]

◆ ~unbounded_variant()

Member Function Documentation

◆ emplace() [1/2]

◆ emplace() [2/2]

◆ get_memory_resource()

◆ operator=() [1/3]

◆ operator=() [2/3]

◆ operator=() [3/3]

◆ reset()

◆ swap()

Friends And Related Symbol Documentation

◆ get_if [1/2]

◆ get_if [2/2]