Tagged union value type that holds a value of one of the given types. More...

#include <donut/Variant.hpp>

Public Types
using	index_type = std::conditional_t< sizeof...(Ts)< 255ull, std::uint8_t, std::conditional_t< sizeof...(Ts)< 65535ull, std::uint16_t, std::conditional_t< sizeof...(Ts)< 4294967295ull, std::uint32_t, std::uint64_t > >>
	Index type used to encode the active alternative type. More...

Public Member Functions
constexpr	Variant () noexcept(std::is_nothrow_default_constructible_v< variant_alternative_t< 0, Variant >>) requires(HAS_DEFAULT_CONSTRUCTOR)
	Default-construct a variant with the first variant alternative, if it is default-constructible. More...

template<typename U >
constexpr	Variant (U &&value) noexcept(std::is_nothrow_constructible_v< decltype(F(std::forward< U >(value)))>) requires(!std
	Converting constructor. More...

template<typename T , typename... Args>
constexpr	Variant (std::in_place_type_t< T > type, Args &&... args) requires(variant_has_alternative_v< T
	Construct a variant alternative in-place given its type. More...

constexpr Variant	std::forward (args)...)

template<typename T , typename U , typename... Args>
constexpr	Variant (std::in_place_type_t< T > type, std::initializer_list< U > ilist, Args &&... args) requires(variant_has_alternative_v< T
	Construct a variant alternative in-place given its type, with an initializer list as the first constructor argument. More...

constexpr Variant	std::forward (args)...)

template<std::size_t Index, typename... Args>
constexpr	Variant (std::in_place_index_t< Index > index, Args &&... args) requires(Index< sizeof...(Ts) &&std
	Construct a variant alternative in-place given its index. More...

template<std::size_t Index, typename U , typename... Args>
constexpr	Variant (std::in_place_index_t< Index > index, std::initializer_list< U > ilist, Args &&... args) requires(Index< sizeof...(Ts) &&std
	Construct a variant alternative in-place given its index, with an initializer list as the first constructor argument. More...

constexpr	~Variant ()
	Destructor. More...

constexpr	~Variant () requires(HAS_TRIVIAL_DESTRUCTOR)=default
	Trivial destructor. More...

constexpr	Variant (const Variant &other) requires(!HAS_COPY_CONSTRUCTOR)=delete
	Deleted copy constructor. More...

constexpr	Variant (const Variant &other) requires(HAS_COPY_CONSTRUCTOR &&HAS_TRIVIAL_COPY_CONSTRUCTOR)=default
	Trivial copy constructor. More...

constexpr	Variant (const Variant &other) requires(HAS_COPY_CONSTRUCTOR &&!HAS_TRIVIAL_COPY_CONSTRUCTOR)
	Copy constructor. More...

constexpr	Variant (Variant &&other) noexcept requires(HAS_MOVE_CONSTRUCTOR &&HAS_TRIVIAL_MOVE_CONSTRUCTOR)=default
	Trivial move constructor. More...

constexpr	Variant (Variant &&other) noexcept((std::is_nothrow_move_constructible_v< Ts > &&...)) requires(HAS_MOVE_CONSTRUCTOR &&!HAS_TRIVIAL_MOVE_CONSTRUCTOR)
	Move constructor. More...

constexpr Variant &	operator= (const Variant &other) requires(!HAS_COPY_ASSIGNMENT)=delete
	Deleted copy assignment. More...

constexpr Variant &	operator= (const Variant &other) requires(HAS_COPY_ASSIGNMENT &&HAS_TRIVIAL_COPY_ASSIGNMENT)=default
	Trivial copy assignment. More...

constexpr Variant &	operator= (const Variant &other) requires(HAS_COPY_ASSIGNMENT &&!HAS_TRIVIAL_COPY_ASSIGNMENT)
	Copy assignment. More...

constexpr Variant &	operator= (Variant &&other) noexcept requires(HAS_MOVE_ASSIGNMENT &&HAS_TRIVIAL_MOVE_ASSIGNMENT)=default
	Trivial move assignment. More...

constexpr Variant &	operator= (Variant &&other) noexcept(((std::is_nothrow_move_constructible_v< Ts > &&//NOLINT(performance-noexcept-move-constructor, cppcoreguidelines-noexcept-move-operations) std::is_nothrow_move_assignable_v< Ts >)&&...)) requires(HAS_MOVE_ASSIGNMENT &&!HAS_TRIVIAL_MOVE_ASSIGNMENT)
	Move assignment. More...

template<typename U >
constexpr Variant &	operator= (U &&value) noexcept(std::is_nothrow_assignable_v< decltype(F(std::forward< U >(value)))&, U > &&std::is_nothrow_constructible_v< decltype(F(std::forward< U >(value))), U >) requires(!std
	Converting assignment. More...

template<typename T , typename... Args>
constexpr T &	emplace (Args &&... args) requires(variant_has_alternative_v< T
	Construct an alternative given its type, destroying the old value. More...

template<typename T , typename U , typename... Args>
constexpr T &	emplace (std::initializer_list< U > ilist, Args &&... args) requires(variant_has_alternative_v< T
	Construct an alternative given its type, with an initializer list as the first constructor argument, destroying the old value. More...

template<std::size_t Index, typename... Args>
constexpr variant_alternative_t< Index, Variant > &	emplace (Args &&... args) requires(std
	Construct an alternative given its index, destroying the old value. More...

template<std::size_t Index, typename U , typename... Args>
constexpr variant_alternative_t< Index, Variant > &	emplace (std::initializer_list< U > ilist, Args &&... args) requires(std
	Construct an alternative given its index, with an initializer list as the first constructor argument, destroying the old value. More...

constexpr void	swap (Variant &other) noexcept(((std::is_nothrow_move_constructible_v< Ts > &&std::is_nothrow_swappable_v< Ts >)&&...))
	Swap this variant's value with that of another. More...

constexpr index_type	index () const noexcept
	Get the alternative index of the currently active value held by the variant. More...

constexpr bool	valueless_by_exception () const noexcept
	Check if the variant is in the valueless by exception state. More...

template<typename T >
constexpr bool	is () const noexcept requires(variant_has_alternative_v< T
	Check if the variant currently holds the alternative with the given type. More...

template<std::size_t Index>
constexpr bool	is () const noexcept
	Check if the variant currently holds the alternative with the given index. More...

template<typename T >
constexpr T &	as () &noexcept requires(variant_has_alternative_v< T
	Access the underlying value with the given type without a safety check. More...

return	as ()

template<typename T >
constexpr const T &	as () const &noexcept requires(variant_has_alternative_v< T
	Access the underlying value with the given type without a safety check. More...

return	as ()

template<typename T >
constexpr T &&	as () &&noexcept requires(variant_has_alternative_v< T
	Access the underlying value with the given type without a safety check. More...

return	std::move (as< variant_index_v< T, Variant >>())

template<typename T >
constexpr const T &&	as () const &&noexcept requires(variant_has_alternative_v< T
	Access the underlying value with the given type without a safety check. More...

return	std::move (as< variant_index_v< T, Variant >>())

template<std::size_t Index>
constexpr variant_alternative_t< Index, Variant > &	as () &noexcept
	Access the underlying value with the given index without a safety check. More...

template<std::size_t Index>
constexpr const variant_alternative_t< Index, Variant > &	as () const &noexcept
	Access the underlying value with the given index without a safety check. More...

template<std::size_t Index>
constexpr variant_alternative_t< Index, Variant > &&	as () &&noexcept
	Access the underlying value with the given index without a safety check. More...

template<std::size_t Index>
constexpr const variant_alternative_t< Index, Variant > &&	as () const &&noexcept
	Access the underlying value with the given index without a safety check. More...

template<typename T >
constexpr T &	get () &requires(variant_has_alternative_v< T
	Access the underlying value with the given type. More...

template<typename T >
constexpr const T &	get () const &requires(variant_has_alternative_v< T
	Access the underlying value with the given type. More...

template<typename T >
constexpr T &&	get () &&requires(variant_has_alternative_v< T
	Access the underlying value with the given type. More...

template<typename T >
constexpr const T &&	get () const &&requires(variant_has_alternative_v< T
	Access the underlying value with the given type. More...

template<std::size_t Index>
constexpr variant_alternative_t< Index, Variant > &	get () &
	Access the underlying value with the given index. More...

template<std::size_t Index>
constexpr const variant_alternative_t< Index, Variant > &	get () const &
	Access the underlying value with the given index. More...

template<std::size_t Index>
constexpr variant_alternative_t< Index, Variant > &&	get () &&
	Access the underlying value with the given index. More...

template<std::size_t Index>
constexpr const variant_alternative_t< Index, Variant > &&	get () const &&
	Access the underlying value with the given index. More...

template<typename T >
constexpr T *	get_if () noexcept requires(variant_has_alternative_v< T
	Access the underlying value with the given type if it is the currently active alternative. More...

template<typename T >
constexpr const T *	get_if () const noexcept requires(variant_has_alternative_v< T
	Access the underlying value with the given type if it is the currently active alternative. More...

template<std::size_t Index>
constexpr variant_alternative_t< Index, Variant > *	get_if () noexcept
	Access the underlying value with the given index if it is the currently active alternative. More...

template<std::size_t Index>
constexpr const variant_alternative_t< Index, Variant > *	get_if () const noexcept
	Access the underlying value with the given index if it is the currently active alternative. More...

Static Public Member Functions
template<typename Visitor , typename V >
static constexpr decltype(auto)	visit (Visitor &&visitor, V &&variant)
	Call a visitor functor with the currently active underlying value of a variant. More...

Public Attributes
constexpr Variant	Variant

constexpr Variant	ilist

constexpr bool	Variant

constexpr T	Variant

constexpr const T	Variant

Static Public Attributes
static constexpr index_type	npos = sizeof...(Ts)
	Invalid alternative index, representing the valueless by exception state. More...

Friends
constexpr friend void	swap (Variant &a, Variant &b) noexcept(noexcept(a.swap(b)))
	Swap the values of two variants. More...

Detailed Description

template<typename... Ts>
class donut::Variant< Ts >

Tagged union value type that holds a value of one of the given types.

Its API mimics that of std::variant, with some added convenience functions such as Variant::is(), Variant::as() and match().

Template Parameters

Ts	type alternatives that can be held by the variant.

Member Typedef Documentation

◆ index_type

template<typename... Ts>

using donut::Variant< Ts >::index_type = std::conditional_t<sizeof...(Ts) < 255ull, std::uint8_t, std::conditional_t<sizeof...(Ts) < 65535ull, std::uint16_t, std::conditional_t<sizeof...(Ts) < 4294967295ull, std::uint32_t, std::uint64_t> >>

Index type used to encode the active alternative type.

This is automatically sized to the smallest possible standard unsigned integer type that can represent all of the possible variant alternatives, including the valueless by exception state.

Constructor & Destructor Documentation

◆ Variant() [1/11]

template<typename... Ts>

constexpr donut::Variant< Ts >::Variant ( )

inlineconstexprnoexcept

Default-construct a variant with the first variant alternative, if it is default-constructible.

Exceptions

any	exception thrown by the underlying constructor of the first alternative type.

◆ Variant() [2/11]

template<typename... Ts>

template<typename U >

constexpr donut::Variant< Ts >::Variant ( U && value )

inlineconstexprnoexcept

Converting constructor.

Chooses the variant alternative type to construct based on the overloading rules specified by std::variant.

Parameters

value underlying value to construct the variant from. Must be convertible to one of the variant's listed alternative types.

Exceptions

any	exception thrown by the underlying constructor of the relevant alternative type.

◆ Variant() [3/11]

template<typename... Ts>

template<typename T , typename... Args>

constexpr donut::Variant< Ts >::Variant	(	std::in_place_type_t< T >	type,
		Args &&...	args
	)

explicitconstexpr

Construct a variant alternative in-place given its type.

Parameters

type	std::in_place_type<T>, where T is the alternative type to construct, which must be one of the variant's listed alternative types.
args	arguments to pass to the underlying value's constructor.

Exceptions

any	exception thrown by the underlying constructor of the relevant alternative type.

◆ Variant() [4/11]

template<typename... Ts>

template<typename T , typename U , typename... Args>

constexpr donut::Variant< Ts >::Variant	(	std::in_place_type_t< T >	type,
		std::initializer_list< U >	ilist,
		Args &&...	args
	)

explicitconstexpr

Construct a variant alternative in-place given its type, with an initializer list as the first constructor argument.

Parameters

type	std::in_place_type<T>, where T is the alternative type to construct, which must be one of the variant's listed alternative types.
ilist	first argument to pass to the underlying value's constructor.
args	subsequent arguments to pass to the underlying value's constructor.

Exceptions

any	exception thrown by the underlying constructor of the relevant alternative type.

◆ Variant() [5/11]

template<typename... Ts>

template<std::size_t Index, typename... Args>

constexpr donut::Variant< Ts >::Variant	(	std::in_place_index_t< Index >	index,
		Args &&...	args
	)		&&

inlineexplicitconstexpr

Construct a variant alternative in-place given its index.

Parameters

index	std::in_place_index<Index>, where Index is the alternative index to construct, which must be within the range of the variant's list of alternative types.
args	arguments to pass to the underlying value's constructor.

Exceptions

any	exception thrown by the underlying constructor of the relevant alternative type.

◆ Variant() [6/11]

template<typename... Ts>

template<std::size_t Index, typename U , typename... Args>

constexpr donut::Variant< Ts >::Variant	(	std::in_place_index_t< Index >	index,
		std::initializer_list< U >	ilist,
		Args &&...	args
	)		&&

inlineexplicitconstexpr

Construct a variant alternative in-place given its index, with an initializer list as the first constructor argument.

Parameters

index	std::in_place_index<Index>, where Index is the alternative index to construct, which must be within the range of the variant's list of alternative types.
ilist	first argument to pass to the underlying value's constructor.
args	subsequent arguments to pass to the underlying value's constructor.

Exceptions

any	exception thrown by the underlying constructor of the relevant alternative type.

◆ ~Variant() [1/2]

template<typename... Ts>

constexpr donut::Variant< Ts >::~Variant ( )

inlineconstexpr

Destructor.

◆ ~Variant() [2/2]

template<typename... Ts>

constexpr donut::Variant< Ts >::~Variant ( )

constexprdefault

Trivial destructor.

◆ Variant() [7/11]

template<typename... Ts>

constexpr donut::Variant< Ts >::Variant ( const Variant< Ts > & other )

constexprdelete

Deleted copy constructor.

◆ Variant() [8/11]

template<typename... Ts>

constexpr donut::Variant< Ts >::Variant ( const Variant< Ts > & other ) &&

constexprdefault

Trivial copy constructor.

◆ Variant() [9/11]

template<typename... Ts>

constexpr donut::Variant< Ts >::Variant ( const Variant< Ts > & other ) &&

inlineconstexpr

Copy constructor.

◆ Variant() [10/11]

template<typename... Ts>

constexpr donut::Variant< Ts >::Variant ( Variant< Ts > && other ) &&

constexprdefaultnoexcept

Trivial move constructor.

◆ Variant() [11/11]

template<typename... Ts>

constexpr donut::Variant< Ts >::Variant ( Variant< Ts > && other ) &&

inlineconstexprnoexcept

Move constructor.

Member Function Documentation

◆ std::forward() [1/2]

template<typename... Ts>

constexpr Variant donut::Variant< Ts >::std::forward ( args )

inline

◆ std::forward() [2/2]

template<typename... Ts>

constexpr Variant donut::Variant< Ts >::std::forward ( args )

inline

◆ operator=() [1/6]

template<typename... Ts>

constexpr Variant& donut::Variant< Ts >::operator= ( const Variant< Ts > & other )

constexprdelete

Deleted copy assignment.

◆ operator=() [2/6]

template<typename... Ts>

constexpr Variant& donut::Variant< Ts >::operator= ( const Variant< Ts > & other ) &&

constexprdefault

Trivial copy assignment.

◆ operator=() [3/6]

template<typename... Ts>

constexpr Variant& donut::Variant< Ts >::operator= ( const Variant< Ts > & other ) &&

inlineconstexpr

Copy assignment.

Note: If an exception is thrown after the old value has been destroyed, the variant ends up in the valueless by exception state.

◆ operator=() [4/6]

template<typename... Ts>

constexpr Variant& donut::Variant< Ts >::operator= ( Variant< Ts > && other ) &&

constexprdefaultnoexcept

Trivial move assignment.

◆ operator=() [5/6]

template<typename... Ts>

constexpr Variant& donut::Variant< Ts >::operator= ( Variant< Ts > && other ) &&

inlineconstexprnoexcept

Move assignment.

Note: If an exception is thrown after the old value has been destroyed, the variant ends up in the valueless by exception state.

◆ operator=() [6/6]

template<typename... Ts>

template<typename U >

constexpr Variant& donut::Variant< Ts >::operator= ( U && value )

inlineconstexprnoexcept

Converting assignment.

Chooses the variant alternative type to construct or assign based on the overloading rules specified by std::variant.

Parameters

value underlying value to construct the new value with. Must be convertible to one of the variant's listed alternative types.

Exceptions

any	exception thrown by the underlying constructor or assignment of the relevant alternative type.

Note: If an exception is thrown after the old value has been destroyed, the variant ends up in the valueless by exception state.

◆ emplace() [1/4]

template<typename... Ts>

template<typename T , typename... Args>

constexpr T& donut::Variant< Ts >::emplace ( Args &&... args )

constexpr

Construct an alternative given its type, destroying the old value.

Template Parameters

T	the alternative type to construct. Must be one of the variant's listed alternative types.

Parameters

args	arguments to pass to the underlying value's constructor.

Exceptions

any	exception thrown by the underlying constructor of the relevant alternative type.

Note: If an exception is thrown after the old value has been destroyed, the variant ends up in the valueless by exception state.

◆ emplace() [2/4]

template<typename... Ts>

template<typename T , typename U , typename... Args>

constexpr T& donut::Variant< Ts >::emplace	(	std::initializer_list< U >	ilist,
		Args &&...	args
	)

constexpr

Construct an alternative given its type, with an initializer list as the first constructor argument, destroying the old value.

Template Parameters

T	the alternative type to construct. Must be one of the variant's listed alternative types.

Parameters

ilist	first argument to pass to the underlying value's constructor.
args	subsequent arguments to pass to the underlying value's constructor.

Exceptions

any	exception thrown by the underlying constructor of the relevant alternative type.

Note: If an exception is thrown after the old value has been destroyed, the variant ends up in the valueless by exception state.

◆ emplace() [3/4]

template<typename... Ts>

template<std::size_t Index, typename... Args>

constexpr variant_alternative_t<Index, Variant>& donut::Variant< Ts >::emplace ( Args &&... args )

inlineconstexpr

Construct an alternative given its index, destroying the old value.

Template Parameters

Index the alternative index to construct. Must be within the range of the variant's list of alternative types.

Parameters

args	arguments to pass to the underlying value's constructor.

Exceptions

any	exception thrown by the underlying constructor of the relevant alternative type.

Note: If an exception is thrown after the old value has been destroyed, the variant ends up in the valueless by exception state.

◆ emplace() [4/4]

template<typename... Ts>

template<std::size_t Index, typename U , typename... Args>

constexpr variant_alternative_t<Index, Variant>& donut::Variant< Ts >::emplace	(	std::initializer_list< U >	ilist,
		Args &&...	args
	)

inlineconstexpr

Construct an alternative given its index, with an initializer list as the first constructor argument, destroying the old value.

Template Parameters

Index the alternative index to construct. Must be within the range of the variant's list of alternative types.

Parameters

ilist	first argument to pass to the underlying value's constructor.
args	subsequent arguments to pass to the underlying value's constructor.

Exceptions

any	exception thrown by the underlying constructor of the relevant alternative type.

Note: If an exception is thrown after the old value has been destroyed, the variant ends up in the valueless by exception state.

◆ swap()

template<typename... Ts>

constexpr void donut::Variant< Ts >::swap ( Variant< Ts > & other )

inlineconstexprnoexcept

Swap this variant's value with that of another.

Parameters

other variant to swap with.

Exceptions

any	exception thrown by the underlying constructor, assignment or swap implementation of the relevant alternative types.

Note: If an exception is thrown after any value has been destroyed, and before it has been replaced with a new value, the associated variant ends up in the valueless by exception state.

◆ index()

template<typename... Ts>

constexpr index_type donut::Variant< Ts >::index ( ) const

inlineconstexprnoexcept

Get the alternative index of the currently active value held by the variant.

Returns: the active alternative index, or npos if the variant is in the valueless by exception state.

◆ valueless_by_exception()

template<typename... Ts>

constexpr bool donut::Variant< Ts >::valueless_by_exception ( ) const

inlineconstexprnoexcept

Check if the variant is in the valueless by exception state.

Returns: true if the variant is in the valueless by exception state, false otherwise.

◆ is() [1/2]

template<typename... Ts>

template<typename T >

constexpr bool donut::Variant< Ts >::is ( ) const

constexprnoexcept

Check if the variant currently holds the alternative with the given type.

Template Parameters

T	alternative type to check for. Must be one of the variant's listed alternative types.

Returns: true if the variant holds a value of the given type, false otherwise.

◆ is() [2/2]

template<typename... Ts>

template<std::size_t Index>

constexpr bool donut::Variant< Ts >::is ( ) const

inlineconstexprnoexcept

Check if the variant currently holds the alternative with the given index.

Template Parameters

Index alternative index to check for. Must be within the range of the variant's list of alternative types.

Returns: true if the variant holds a value of the given alternative index, false otherwise.

◆ as() [1/10]

template<typename... Ts>

template<typename T >

constexpr T& donut::Variant< Ts >::as ( ) &

constexprnoexcept

Access the underlying value with the given type without a safety check.

Template Parameters

T	type of the currently active value to get. Must be one of the variant's listed alternative types.

Returns: a reference to the value held by the variant.

Warning: The behavior of accessing the underlying value using the incorrect alternative type which is not currently active is undefined. The active alternative type must be known in advance in order to use this function safely, for example by checking if the variant contains the expected alternative using the is() function.

Remarks: Rather than using this function in conjunction with is(), it is usually more appropriate to use get() or to call get_if() and make sure that the returned pointer is not nullptr. This function is only meant for the cases where it is absolutely certain which alternative the variant currently holds.

See also: get(); get_if()

◆ as() [2/10]

template<typename... Ts>

return donut::Variant< Ts >::as ( )

◆ as() [3/10]

template<typename... Ts>

template<typename T >

constexpr const T& donut::Variant< Ts >::as ( ) const &

constexprnoexcept

Access the underlying value with the given type without a safety check.

Template Parameters

T	type of the currently active value to get. Must be one of the variant's listed alternative types.

Returns: a read-only reference to the value held by the variant.

Warning: The behavior of accessing the underlying value using the incorrect alternative type which is not currently active is undefined. The active alternative type must be known in advance in order to use this function safely, for example by checking if the variant contains the expected alternative using the is() function.

Remarks: Rather than using this function in conjunction with is(), it is usually more appropriate to use get() or to call get_if() and make sure that the returned pointer is not nullptr. This function is only meant for the cases where it is absolutely certain which alternative the variant currently holds.

See also: get(); get_if()

◆ as() [4/10]

template<typename... Ts>

return donut::Variant< Ts >::as ( )

◆ as() [5/10]

template<typename... Ts>

template<typename T >

constexpr T&& donut::Variant< Ts >::as ( ) &&

constexprnoexcept

Access the underlying value with the given type without a safety check.

Template Parameters

T	type of the currently active value to get. Must be one of the variant's listed alternative types.

Returns: an rvalue reference to the value held by the variant.

Warning: The behavior of accessing the underlying value using the incorrect alternative type which is not currently active is undefined. The active alternative type must be known in advance in order to use this function safely, for example by checking if the variant contains the expected alternative using the is() function.

Remarks: Rather than using this function in conjunction with is(), it is usually more appropriate to use get() or to call get_if() and make sure that the returned pointer is not nullptr. This function is only meant for the cases where it is absolutely certain which alternative the variant currently holds.

See also: get(); get_if()

◆ std::move() [1/2]

template<typename... Ts>

return donut::Variant< Ts >::std::move ( as< variant_index_v< T, Variant< Ts > >> () )

◆ as() [6/10]

template<typename... Ts>

template<typename T >

constexpr const T&& donut::Variant< Ts >::as ( ) const &&

constexprnoexcept

Access the underlying value with the given type without a safety check.

Template Parameters

T	type of the currently active value to get. Must be one of the variant's listed alternative types.

Returns: a read-only rvalue reference to the value held by the variant.

Warning: The behavior of accessing the underlying value using the incorrect alternative type which is not currently active is undefined. The active alternative type must be known in advance in order to use this function safely, for example by checking if the variant contains the expected alternative using the is() function.

Remarks: Rather than using this function in conjunction with is(), it is usually more appropriate to use get() or to call get_if() and make sure that the returned pointer is not nullptr. This function is only meant for the cases where it is absolutely certain which alternative the variant currently holds.

See also: get(); get_if()

◆ std::move() [2/2]

template<typename... Ts>

return donut::Variant< Ts >::std::move ( as< variant_index_v< T, Variant< Ts > >> () )

◆ as() [7/10]

template<typename... Ts>

template<std::size_t Index>

constexpr variant_alternative_t<Index, Variant>& donut::Variant< Ts >::as ( ) &

inlineconstexprnoexcept

Access the underlying value with the given index without a safety check.

Template Parameters

Index alternative index of the currently active value to get. Must be within the range of the variant's list of alternative types.

Returns: a reference to the value held by the variant.

Warning: The behavior of accessing the underlying value using the incorrect alternative type which is not currently active is undefined. The active alternative type must be known in advance in order to use this function safely, for example by checking if the variant contains the expected alternative using the is() function.

Remarks: Rather than using this function in conjunction with is(), it is usually more appropriate to use get() or to call get_if() and make sure that the returned pointer is not nullptr. This function is only meant for the cases where it is absolutely certain which alternative the variant currently holds.

See also: get(); get_if()

◆ as() [8/10]

template<typename... Ts>

template<std::size_t Index>

constexpr const variant_alternative_t<Index, Variant>& donut::Variant< Ts >::as ( ) const &

inlineconstexprnoexcept

Access the underlying value with the given index without a safety check.

Template Parameters

Index alternative index of the currently active value to get. Must be within the range of the variant's list of alternative types.

Returns: a read-only reference to the value held by the variant.

Warning: The behavior of accessing the underlying value using the incorrect alternative type which is not currently active is undefined. The active alternative type must be known in advance in order to use this function safely, for example by checking if the variant contains the expected alternative using the is() function.

Remarks: Rather than using this function in conjunction with is(), it is usually more appropriate to use get() or to call get_if() and make sure that the returned pointer is not nullptr. This function is only meant for the cases where it is absolutely certain which alternative the variant currently holds.

See also: get(); get_if()

◆ as() [9/10]

template<typename... Ts>

template<std::size_t Index>

constexpr variant_alternative_t<Index, Variant>&& donut::Variant< Ts >::as ( ) &&

inlineconstexprnoexcept

Access the underlying value with the given index without a safety check.

Template Parameters

Index alternative index of the currently active value to get. Must be within the range of the variant's list of alternative types.

Returns: an rvalue reference to the value held by the variant.

Warning: The behavior of accessing the underlying value using the incorrect alternative type which is not currently active is undefined. The active alternative type must be known in advance in order to use this function safely, for example by checking if the variant contains the expected alternative using the is() function.

Remarks: Rather than using this function in conjunction with is(), it is usually more appropriate to use get() or to call get_if() and make sure that the returned pointer is not nullptr. This function is only meant for the cases where it is absolutely certain which alternative the variant currently holds.

See also: get(); get_if()

◆ as() [10/10]

template<typename... Ts>

template<std::size_t Index>

constexpr const variant_alternative_t<Index, Variant>&& donut::Variant< Ts >::as ( ) const &&

inlineconstexprnoexcept

Access the underlying value with the given index without a safety check.

Template Parameters

Index alternative index of the currently active value to get. Must be within the range of the variant's list of alternative types.

Returns: a read-only rvalue reference to the value held by the variant.

Warning: The behavior of accessing the underlying value using the incorrect alternative type which is not currently active is undefined. The active alternative type must be known in advance in order to use this function safely, for example by checking if the variant contains the expected alternative using the is() function.

Remarks: Rather than using this function in conjunction with is(), it is usually more appropriate to use get() or to call get_if() and make sure that the returned pointer is not nullptr. This function is only meant for the cases where it is absolutely certain which alternative the variant currently holds.

See also: get(); get_if()

◆ get() [1/8]

template<typename... Ts>

template<typename T >

constexpr T& donut::Variant< Ts >::get ( ) &

constexpr

Access the underlying value with the given type.

Template Parameters

T	type of the currently active value to get. Must be one of the variant's listed alternative types.

Returns: a reference to the value held by the variant.

Exceptions

BadVariantAccess if the variant does not currently hold a value of the given type.

See also: as(); get_if()

◆ get() [2/8]

template<typename... Ts>

template<typename T >

constexpr const T& donut::Variant< Ts >::get ( ) const &

constexpr

Access the underlying value with the given type.

Template Parameters

T	type of the currently active value to get. Must be one of the variant's listed alternative types.

Returns: a read-only reference to the value held by the variant.

Exceptions

BadVariantAccess if the variant does not currently hold a value of the given type.

See also: as(); get_if()

◆ get() [3/8]

template<typename... Ts>

template<typename T >

constexpr T&& donut::Variant< Ts >::get ( ) &&

constexpr

Access the underlying value with the given type.

Template Parameters

T	type of the currently active value to get. Must be one of the variant's listed alternative types.

Returns: an rvalue reference to the value held by the variant.

Exceptions

BadVariantAccess if the variant does not currently hold a value of the given type.

See also: as(); get_if()

◆ get() [4/8]

template<typename... Ts>

template<typename T >

constexpr const T&& donut::Variant< Ts >::get ( ) const &&

constexpr

Access the underlying value with the given type.

Template Parameters

T	type of the currently active value to get. Must be one of the variant's listed alternative types.

Returns: a read-only rvalue reference to the value held by the variant.

Exceptions

BadVariantAccess if the variant does not currently hold a value of the given type.

See also: as(); get_if()

◆ get() [5/8]

template<typename... Ts>

template<std::size_t Index>

constexpr variant_alternative_t<Index, Variant>& donut::Variant< Ts >::get ( ) &

inlineconstexpr

Access the underlying value with the given index.

Template Parameters

Index alternative index of the currently active value to get. Must be within the range of the variant's list of alternative types.

Returns: a reference to the value held by the variant.

Exceptions

BadVariantAccess if the variant does not currently hold the given alternative.

See also: as(); get_if()

◆ get() [6/8]

template<typename... Ts>

template<std::size_t Index>

constexpr const variant_alternative_t<Index, Variant>& donut::Variant< Ts >::get ( ) const &

inlineconstexpr

Access the underlying value with the given index.

Template Parameters

Index alternative index of the currently active value to get. Must be within the range of the variant's list of alternative types.

Returns: a read-only reference to the value held by the variant.

Exceptions

BadVariantAccess if the variant does not currently hold the given alternative.

See also: as(); get_if()

◆ get() [7/8]

template<typename... Ts>

template<std::size_t Index>

constexpr variant_alternative_t<Index, Variant>&& donut::Variant< Ts >::get ( ) &&

inlineconstexpr

Access the underlying value with the given index.

Template Parameters

Index alternative index of the currently active value to get. Must be within the range of the variant's list of alternative types.

Returns: an rvalue reference to the value held by the variant.

Exceptions

BadVariantAccess if the variant does not currently hold the given alternative.

See also: as(); get_if()

◆ get() [8/8]

template<typename... Ts>

template<std::size_t Index>

constexpr const variant_alternative_t<Index, Variant>&& donut::Variant< Ts >::get ( ) const &&

inlineconstexpr

Access the underlying value with the given index.

Template Parameters

Index alternative index of the currently active value to get. Must be within the range of the variant's list of alternative types.

Returns: a read-only rvalue reference to the value held by the variant.

Exceptions

BadVariantAccess if the variant does not currently hold the given alternative.

See also: as(); get_if()

◆ get_if() [1/4]

template<typename... Ts>

template<typename T >

constexpr T* donut::Variant< Ts >::get_if ( )

constexprnoexcept

Access the underlying value with the given type if it is the currently active alternative.

Template Parameters

T	type of the value to get. Must be one of the variant's listed alternative types.

Returns: a non-owning pointer to the value held by the variant, or nullptr if the variant does not currently hold a value of the given type.

See also: as(); get()

◆ get_if() [2/4]

template<typename... Ts>

template<typename T >

constexpr const T* donut::Variant< Ts >::get_if ( ) const

constexprnoexcept

Access the underlying value with the given type if it is the currently active alternative.

Template Parameters

T	type of the value to get. Must be one of the variant's listed alternative types.

Returns: a non-owning read-only pointer to the value held by the variant, or nullptr if the variant does not currently hold a value of the given type.

See also: as(); get()

◆ get_if() [3/4]

template<typename... Ts>

template<std::size_t Index>

constexpr variant_alternative_t<Index, Variant>* donut::Variant< Ts >::get_if ( )

inlineconstexprnoexcept

Access the underlying value with the given index if it is the currently active alternative.

Template Parameters

Index alternative index of the value to get. Must be within the range of the variant's list of alternative types.

Returns: a non-owning pointer to the value held by the variant, or nullptr if the variant does not currently hold the given alternative.

See also: as(); get()

◆ get_if() [4/4]

template<typename... Ts>

template<std::size_t Index>

constexpr const variant_alternative_t<Index, Variant>* donut::Variant< Ts >::get_if ( ) const

inlineconstexprnoexcept

Access the underlying value with the given index if it is the currently active alternative.

Template Parameters

Index alternative index of the value to get. Must be within the range of the variant's list of alternative types.

Returns: a non-owning read-only pointer to the value held by the variant, or nullptr if the variant does not currently hold the given alternative.

See also: as(); get()

◆ visit()

template<typename... Ts>

template<typename Visitor , typename V >

static constexpr decltype(auto) donut::Variant< Ts >::visit	(	Visitor &&	visitor,
		V &&	variant
	)

inlinestaticconstexpr

Call a visitor functor with the currently active underlying value of a variant.

Parameters

visitor	callable object that is overloaded to accept any of the variant alternatives as a parameter.
variant	variant whose underlying value to pass to the visitor.

Returns: the result of calling the visitor with the currently active variant alternative value.

Exceptions

BadVariantAccess	if the variant is in the valueless by exception state.
any	exception thrown by the visitor.

See also: match()

Friends And Related Function Documentation

◆ swap

template<typename... Ts>

constexpr friend void swap	(	Variant< Ts > &	a,
		Variant< Ts > &	b
	)

friend

Swap the values of two variants.

Parameters

a	first variant.
b	second variant.

Exceptions

any	exception thrown by the underlying constructor, assignment or swap implementation of the relevant alternative types.

Note: If an exception is thrown after any value has been destroyed, and before it has been replaced with a new value, the associated variant ends up in the valueless by exception state.

Member Data Documentation

◆ npos

template<typename... Ts>

constexpr index_type donut::Variant< Ts >::npos = sizeof...(Ts)

staticconstexpr

Invalid alternative index, representing the valueless by exception state.

◆ Variant [1/4]

template<typename... Ts>

constexpr const T donut::Variant< Ts >::Variant

Initial value:

{

assert(is<T>())

◆ ilist

template<typename... Ts>

constexpr Variant donut::Variant< Ts >::ilist

◆ Variant [2/4]

template<typename... Ts>

constexpr bool donut::Variant< Ts >::Variant

Initial value:

{

return activeTypeIndex == variant_index_v<T, Variant>

◆ Variant [3/4]

template<typename... Ts>

constexpr T donut::Variant< Ts >::Variant

Initial value:

{

assert(is<T>())

◆ Variant [4/4]

template<typename... Ts>

constexpr const T donut::Variant< Ts >::Variant

Initial value:

{

assert(is<T>())

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

include/donut/modules/fwd/utilities.hpp
include/donut/Variant.hpp

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Friends

Detailed Description

template<typename... Ts> class donut::Variant< Ts >

Member Typedef Documentation

◆ index_type

Constructor & Destructor Documentation

◆ Variant() [1/11]

◆ Variant() [2/11]

◆ Variant() [3/11]

◆ Variant() [4/11]

◆ Variant() [5/11]

◆ Variant() [6/11]

◆ ~Variant() [1/2]

◆ ~Variant() [2/2]

◆ Variant() [7/11]

◆ Variant() [8/11]

◆ Variant() [9/11]

◆ Variant() [10/11]

◆ Variant() [11/11]

Member Function Documentation

◆ std::forward() [1/2]

◆ std::forward() [2/2]

◆ operator=() [1/6]

◆ operator=() [2/6]

◆ operator=() [3/6]

◆ operator=() [4/6]

◆ operator=() [5/6]

◆ operator=() [6/6]

◆ emplace() [1/4]

◆ emplace() [2/4]

◆ emplace() [3/4]

◆ emplace() [4/4]

◆ swap()

◆ index()

◆ valueless_by_exception()

◆ is() [1/2]

◆ is() [2/2]

◆ as() [1/10]

◆ as() [2/10]

◆ as() [3/10]

◆ as() [4/10]

◆ as() [5/10]

◆ std::move() [1/2]

◆ as() [6/10]

◆ std::move() [2/2]

◆ as() [7/10]

◆ as() [8/10]

◆ as() [9/10]

◆ as() [10/10]

◆ get() [1/8]

◆ get() [2/8]

◆ get() [3/8]

◆ get() [4/8]

◆ get() [5/8]

◆ get() [6/8]

◆ get() [7/8]

◆ get() [8/8]

◆ get_if() [1/4]

◆ get_if() [2/4]

◆ get_if() [3/4]

◆ get_if() [4/4]

◆ visit()

Friends And Related Function Documentation

◆ swap

Member Data Documentation

◆ npos

◆ Variant [1/4]

◆ ilist

◆ Variant [2/4]

◆ Variant [3/4]

◆ Variant [4/4]

template<typename... Ts>
class donut::Variant< Ts >