#include <Variant.h>

Public Types
using	allocator_type = ALLOC

using	IndexType = INDEX

Public Member Functions
	BasicVariant ()

	BasicVariant (const ALLOC &allocator)

template<INDEX I, typename... ARGS, std::enable_if_t<!is_first_allocator_v< ARGS... >> * = nullptr>
	BasicVariant (in_place_index_t< I >, ARGS &&... args)

template<INDEX I, typename... ARGS>
	BasicVariant (in_place_index_t< I >, const ALLOC &allocator, ARGS &&... args)

	BasicVariant (const BasicVariant &other)

	BasicVariant (const BasicVariant &other, const ALLOC &allocator)

BasicVariant &	operator= (const BasicVariant &other)

	BasicVariant (BasicVariant &&other)

	BasicVariant (BasicVariant &&other, const ALLOC &allocator)

	~BasicVariant ()=default

BasicVariant &	operator= (BasicVariant &&other)

bool	valueless_by_exception () const noexcept

template<INDEX I, typename... ARGS>
decltype(auto)	emplace (ARGS &&... args)

INDEX	index () const noexcept

template<INDEX I, typename U = detail::type_at_t<I, T...>>
U *	get_if () noexcept

template<INDEX I, typename U = detail::type_at_t<I, T...>>
const U *	get_if () const noexcept

template<INDEX I, typename U = detail::type_at_t<I, T...>>
U &	get ()

template<INDEX I, typename U = detail::type_at_t<I, T...>>
const U &	get () const

void	swap (BasicVariant &other)

template<typename F >
auto	visit (F &&fun) -> decltype(fun(std::declval< detail::type_at_t< 0, T... >>()))

template<typename F >
auto	visit (F &&fun) const -> decltype(fun(std::declval< detail::type_at_t< 0, T... >>()))

bool	operator== (const BasicVariant &other) const

bool	operator!= (const BasicVariant &other) const

bool	operator< (const BasicVariant &other) const

bool	operator> (const BasicVariant &other) const

bool	operator<= (const BasicVariant &other) const

bool	operator>= (const BasicVariant &other) const

Detailed Description

template<typename ALLOC, typename INDEX, typename... T>
class zserio::BasicVariant< ALLOC, INDEX, T >

Implementation of variant type using BasicAny which allocates memory when selected type doesn't fit under 3*sizeof(void*)

Largely compatible with std::variant with following differences:

access only through index whose type has to be specified (by design)
supplied INDEX type needs to be convertible to/from size_t and std::variant_npos
holds_alternative() omitted
get/get_if() exist as member functions as well

Definition at line 102 of file Variant.h.

Member Typedef Documentation

◆ allocator_type

template<typename ALLOC , typename INDEX , typename... T>

using zserio::BasicVariant< ALLOC, INDEX, T >::allocator_type = ALLOC

Definition at line 107 of file Variant.h.

◆ IndexType

template<typename ALLOC , typename INDEX , typename... T>

using zserio::BasicVariant< ALLOC, INDEX, T >::IndexType = INDEX

Definition at line 108 of file Variant.h.

Constructor & Destructor Documentation

◆ BasicVariant() [1/8]

template<typename ALLOC , typename INDEX , typename... T>

zserio::BasicVariant< ALLOC, INDEX, T >::BasicVariant ( )

inline

Empty constructor.

Definition at line 113 of file Variant.h.

◆ BasicVariant() [2/8]

template<typename ALLOC , typename INDEX , typename... T>

zserio::BasicVariant< ALLOC, INDEX, T >::BasicVariant ( const ALLOC & allocator )

inlineexplicit

Constructor from given allocator.

Parameters

allocator Allocator to be used.

Exceptions

can	throw any exception thrown by T[0]

Definition at line 124 of file Variant.h.

◆ BasicVariant() [3/8]

template<typename ALLOC , typename INDEX , typename... T>

template<INDEX I, typename... ARGS, std::enable_if_t<!is_first_allocator_v< ARGS... >> * = nullptr>

zserio::BasicVariant< ALLOC, INDEX, T >::BasicVariant	(	in_place_index_t< I >	,
		ARGS &&...	args
	)

inlineexplicit

Constructor with initial emplacement.

Parameters

in_place_index	Index of the active element.
args	Arguments to be forwarded for element construction.

Exceptions

can	throw any exception thrown by T[I]

Definition at line 139 of file Variant.h.

◆ BasicVariant() [4/8]

template<typename ALLOC , typename INDEX , typename... T>

template<INDEX I, typename... ARGS>

zserio::BasicVariant< ALLOC, INDEX, T >::BasicVariant	(	in_place_index_t< I >	,
		const ALLOC &	allocator,
		ARGS &&...	args
	)

inline

Constructor with allocator and initial emplacement.

Parameters

in_place_index	Index of the active element.
allocator	Allocator to be used.
args	Arguments to be forwarded for element construction.

Exceptions

can	throw any exception thrown by T[I]

Definition at line 154 of file Variant.h.

◆ BasicVariant() [5/8]

template<typename ALLOC , typename INDEX , typename... T>

zserio::BasicVariant< ALLOC, INDEX, T >::BasicVariant ( const BasicVariant< ALLOC, INDEX, T > & other )

inline

Copy constructor.

Parameters

other Variant to copy.

Definition at line 165 of file Variant.h.

◆ BasicVariant() [6/8]

template<typename ALLOC , typename INDEX , typename... T>

zserio::BasicVariant< ALLOC, INDEX, T >::BasicVariant	(	const BasicVariant< ALLOC, INDEX, T > &	other,
		const ALLOC &	allocator
	)

inline

Allocator-extended copy constructor.

Parameters

other	Variant to copy.
allocator	Allocator to be used for dynamic memory allocations.

Exceptions

can	throw any exception thrown by the active element in other

Definition at line 178 of file Variant.h.

◆ BasicVariant() [7/8]

template<typename ALLOC , typename INDEX , typename... T>

zserio::BasicVariant< ALLOC, INDEX, T >::BasicVariant ( BasicVariant< ALLOC, INDEX, T > && other )

inline

Move constructor.

Parameters

other Variant to move from.

Exceptions

can	throw any exception thrown by the active element in other

Definition at line 206 of file Variant.h.

◆ BasicVariant() [8/8]

template<typename ALLOC , typename INDEX , typename... T>

zserio::BasicVariant< ALLOC, INDEX, T >::BasicVariant	(	BasicVariant< ALLOC, INDEX, T > &&	other,
		const ALLOC &	allocator
	)

inline

Allocator-extended move constructor.

Parameters

other	Variant to move from.
allocator	Allocator to be used for dynamic memory allocations.

Exceptions

can	throw any exception thrown by the active element in other

Definition at line 219 of file Variant.h.

◆ ~BasicVariant()

template<typename ALLOC , typename INDEX , typename... T>

zserio::BasicVariant< ALLOC, INDEX, T >::~BasicVariant ( )

default

Desctructor.

Member Function Documentation

◆ emplace()

template<typename ALLOC , typename INDEX , typename... T>

template<INDEX I, typename... ARGS>

decltype(auto) zserio::BasicVariant< ALLOC, INDEX, T >::emplace ( ARGS &&... args )

inline

Constructs a value of type U at index I with given arguments.

Parameters

args	Arguments to be forwarded for element construction.

Definition at line 266 of file Variant.h.

◆ get() [1/2]

template<typename ALLOC , typename INDEX , typename... T>

template<INDEX I, typename U = detail::type_at_t<I, T...>>

U& zserio::BasicVariant< ALLOC, INDEX, T >::get ( )

inline

Returns element at index I. Throws if index doesn't match

Exceptions

BadVariantAccess if the requested index doesn't match.

Definition at line 314 of file Variant.h.

◆ get() [2/2]

template<typename ALLOC , typename INDEX , typename... T>

template<INDEX I, typename U = detail::type_at_t<I, T...>>

const U& zserio::BasicVariant< ALLOC, INDEX, T >::get ( ) const

inline

Returns element at index I. Throws if index doesn't match

Exceptions

BadVariantAccess if the requested index doesn't match.

Definition at line 331 of file Variant.h.

◆ get_if() [1/2]

template<typename ALLOC , typename INDEX , typename... T>

template<INDEX I, typename U = detail::type_at_t<I, T...>>

const U* zserio::BasicVariant< ALLOC, INDEX, T >::get_if ( ) const

inlinenoexcept

Returns a pointer to an element at index I or nullptr if index doesn't match.

Definition at line 299 of file Variant.h.

◆ get_if() [2/2]

template<typename ALLOC , typename INDEX , typename... T>

template<INDEX I, typename U = detail::type_at_t<I, T...>>

U* zserio::BasicVariant< ALLOC, INDEX, T >::get_if ( )

inlinenoexcept

Returns a pointer to an element at index I or nullptr if index doesn't match.

Definition at line 286 of file Variant.h.

◆ index()

template<typename ALLOC , typename INDEX , typename... T>

INDEX zserio::BasicVariant< ALLOC, INDEX, T >::index ( ) const

inlinenoexcept

Returns an index of active element.

Definition at line 277 of file Variant.h.

◆ operator!=()

template<typename ALLOC , typename INDEX , typename... T>

bool zserio::BasicVariant< ALLOC, INDEX, T >::operator!= ( const BasicVariant< ALLOC, INDEX, T > & other ) const

inline

Variant inequality test.

Parameters

other Variant to compare with.

Definition at line 439 of file Variant.h.

◆ operator<()

template<typename ALLOC , typename INDEX , typename... T>

bool zserio::BasicVariant< ALLOC, INDEX, T >::operator< ( const BasicVariant< ALLOC, INDEX, T > & other ) const

inline

Variant less-than test.

Parameters

other Variant to compare with.

Definition at line 449 of file Variant.h.

◆ operator<=()

template<typename ALLOC , typename INDEX , typename... T>

bool zserio::BasicVariant< ALLOC, INDEX, T >::operator<= ( const BasicVariant< ALLOC, INDEX, T > & other ) const

inline

Variant less-or-equal test.

Parameters

other Variant to compare with.

Definition at line 478 of file Variant.h.

◆ operator=() [1/2]

template<typename ALLOC , typename INDEX , typename... T>

BasicVariant& zserio::BasicVariant< ALLOC, INDEX, T >::operator= ( BasicVariant< ALLOC, INDEX, T > && other )

inline

Move assignment operator.

Parameters

other Variant to move from.

Returns: Reference to this.

Definition at line 236 of file Variant.h.

◆ operator=() [2/2]

template<typename ALLOC , typename INDEX , typename... T>

BasicVariant& zserio::BasicVariant< ALLOC, INDEX, T >::operator= ( const BasicVariant< ALLOC, INDEX, T > & other )

inline

Copy assignment operator.

Parameters

other Variant to copy.

Returns: Reference to this.

Exceptions

can	throw any exception thrown by the active element in other

Definition at line 192 of file Variant.h.

◆ operator==()

template<typename ALLOC , typename INDEX , typename... T>

bool zserio::BasicVariant< ALLOC, INDEX, T >::operator== ( const BasicVariant< ALLOC, INDEX, T > & other ) const

inline

Variant equality test.

Parameters

other Variant to compare with.

Definition at line 420 of file Variant.h.

◆ operator>()

template<typename ALLOC , typename INDEX , typename... T>

bool zserio::BasicVariant< ALLOC, INDEX, T >::operator> ( const BasicVariant< ALLOC, INDEX, T > & other ) const

inline

Variant greater-than test.

Parameters

other Variant to compare with.

Definition at line 468 of file Variant.h.

◆ operator>=()

template<typename ALLOC , typename INDEX , typename... T>

bool zserio::BasicVariant< ALLOC, INDEX, T >::operator>= ( const BasicVariant< ALLOC, INDEX, T > & other ) const

inline

Variant greater-or-equal test.

Parameters

other Variant to compare with.

Definition at line 488 of file Variant.h.

◆ swap()

template<typename ALLOC , typename INDEX , typename... T>

void zserio::BasicVariant< ALLOC, INDEX, T >::swap ( BasicVariant< ALLOC, INDEX, T > & other )

inline

Swaps content of variant with other.

Parameters

other Other variant to swap content with.

Definition at line 347 of file Variant.h.

◆ valueless_by_exception()

template<typename ALLOC , typename INDEX , typename... T>

bool zserio::BasicVariant< ALLOC, INDEX, T >::valueless_by_exception ( ) const

inlinenoexcept

Reports if variant is in nonstandard empty state. Note: which operations lead to an empty state is not specified by ISO C++

As an zserio extension, the valueless state can arise after move. This happens only When the held alternative is stored on the heap, and the used allocator is the same in both variants. In that case, the underlying pointer is stolen and the moved-out variant remains in the valueless state.

Definition at line 255 of file Variant.h.

◆ visit() [1/2]

template<typename ALLOC , typename INDEX , typename... T>

template<typename F >

auto zserio::BasicVariant< ALLOC, INDEX, T >::visit ( F && fun ) -> decltype(fun(std::declval<detail::type_at_t<0, T...>>()))

inline

Calls a given functor with active element.

Parameters

fun	Functor to be called on the active element.

Exceptions

BadVariantAccess if variant is in valueless state.

Definition at line 361 of file Variant.h.

◆ visit() [2/2]

template<typename ALLOC , typename INDEX , typename... T>

template<typename F >

auto zserio::BasicVariant< ALLOC, INDEX, T >::visit ( F && fun ) const -> decltype(fun(std::declval<detail::type_at_t<0, T...>>()))

inline

Calls a given functor with active element.

Parameters

fun	Functor to be called on the active element.

Exceptions

BadVariantAccess if variant is in valueless state.

Definition at line 392 of file Variant.h.

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

zserio/Variant.h

Public Types

Public Member Functions

Detailed Description

template<typename ALLOC, typename INDEX, typename... T> class zserio::BasicVariant< ALLOC, INDEX, T >

Member Typedef Documentation

◆ allocator_type

◆ IndexType

Constructor & Destructor Documentation

◆ BasicVariant() [1/8]

◆ BasicVariant() [2/8]

◆ BasicVariant() [3/8]

◆ BasicVariant() [4/8]

◆ BasicVariant() [5/8]

◆ BasicVariant() [6/8]

◆ BasicVariant() [7/8]

◆ BasicVariant() [8/8]

◆ ~BasicVariant()

Member Function Documentation

◆ emplace()

◆ get() [1/2]

◆ get() [2/2]

◆ get_if() [1/2]

◆ get_if() [2/2]

◆ index()

◆ operator!=()

◆ operator<()

◆ operator<=()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ operator>()

◆ operator>=()

◆ swap()

◆ valueless_by_exception()

◆ visit() [1/2]

◆ visit() [2/2]

template<typename ALLOC, typename INDEX, typename... T>
class zserio::BasicVariant< ALLOC, INDEX, T >