#include <bdlb_variant.h>

Inheritance diagram for bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >:

Public Member Functions
	BSLMF_NESTED_TRAIT_DECLARATION_IF (Variant, bslma::UsesBslmaAllocator, Traits::k_VARIANT_USES_BSLMA_ALLOCATOR)

	BSLMF_NESTED_TRAIT_DECLARATION_IF (Variant, bslmf::IsBitwiseCopyable, Traits::k_VARIANT_IS_BITWISE_COPYABLE)

	BSLMF_NESTED_TRAIT_DECLARATION_IF (Variant, bslmf::IsBitwiseMoveable, Traits::k_VARIANT_IS_BITWISE_MOVEABLE)

	BSLMF_NESTED_TRAIT_DECLARATION (Variant, HasPrintMethod)

	Variant ()

template<class TYPE_OR_ALLOCATOR >
	Variant (const TYPE_OR_ALLOCATOR &valueOrAllocator)

template<class TYPE >
	Variant (const TYPE &value, bslma::Allocator *basicAllocator)

template<class TYPE >
	Variant (bslmf::MovableRef< TYPE > value)

template<class TYPE >
	Variant (bslmf::MovableRef< TYPE > value, bslma::Allocator *basicAllocator)

	Variant (const Variant &original, bslma::Allocator *basicAllocator=0)

	Variant (bslmf::MovableRef< Variant > original)

	Variant (bslmf::MovableRef< Variant > original, bslma::Allocator *basicAllocator)

template<class TYPE >
Variant &	operator= (const TYPE &value)

template<class TYPE >
Variant &	operator= (bslmf::MovableRef< TYPE > value)

Variant &	operator= (const Variant &rhs)

Variant &	operator= (bslmf::MovableRef< Variant > rhs)

template<class TYPE >
Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 > &	operator= (const TYPE &value)

template<class TYPE >
Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 > &	operator= (bslmf::MovableRef< TYPE > value)

Public Member Functions inherited from bdlb::VariantImp< TYPES >
	BSLMF_NESTED_TRAIT_DECLARATION_IF (VariantImp, bslma::UsesBslmaAllocator, Traits::k_VARIANT_USES_BSLMA_ALLOCATOR)

	BSLMF_NESTED_TRAIT_DECLARATION_IF (VariantImp, bslmf::IsBitwiseCopyable, Traits::k_VARIANT_IS_BITWISE_COPYABLE)

	BSLMF_NESTED_TRAIT_DECLARATION_IF (VariantImp, bslmf::IsBitwiseMoveable, Traits::k_VARIANT_IS_BITWISE_MOVEABLE)

	BSLMF_NESTED_TRAIT_DECLARATION (VariantImp, HasPrintMethod)

	VariantImp ()

template<class TYPE_OR_ALLOCATOR >
	VariantImp (const TYPE_OR_ALLOCATOR &valueOrAllocator)

template<class TYPE >
	VariantImp (const TYPE &value, bslma::Allocator *basicAllocator)

template<class TYPE >
	VariantImp (bslmf::MovableRef< TYPE > value)

template<class TYPE >
	VariantImp (bslmf::MovableRef< TYPE > value, bslma::Allocator *basicAllocator)

	VariantImp (const VariantImp &original, bslma::Allocator *basicAllocator=0)

	VariantImp (bslmf::MovableRef< VariantImp > original)

	VariantImp (bslmf::MovableRef< VariantImp > original, bslma::Allocator *basicAllocator)

	~VariantImp ()

template<class TYPE >
VariantImp &	operator= (const TYPE &value)

template<class TYPE >
VariantImp &	operator= (bslmf::MovableRef< TYPE > value)

VariantImp &	operator= (const VariantImp &rhs)

VariantImp &	operator= (bslmf::MovableRef< VariantImp > rhs)

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==1, typenameVISITOR::ResultType >::type	apply (VISITOR &visitor)

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==1, typenameVISITOR::ResultType >::type	apply (const VISITOR &visitor)

template<class VISITOR , class TYPE >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==1, typenameVISITOR::ResultType >::type	apply (VISITOR &visitor, const TYPE &defaultValue)

template<class VISITOR , class TYPE >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==1, typenameVISITOR::ResultType >::type	apply (const VISITOR &visitor, const TYPE &defaultValue)

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==0, void >::type	apply (VISITOR &visitor)

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==0, void >::type	apply (const VISITOR &visitor)

template<class VISITOR , class TYPE >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==0, void >::type	apply (VISITOR &visitor, const TYPE &defaultValue)

template<class VISITOR , class TYPE >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==0, void >::type	apply (const VISITOR &visitor, const TYPE &defaultValue)

template<class RET_TYPE , class VISITOR >
RET_TYPE	apply (VISITOR &visitor)

template<class RET_TYPE , class VISITOR >
RET_TYPE	apply (const VISITOR &visitor)

template<class RET_TYPE , class VISITOR , class TYPE >
RET_TYPE	apply (VISITOR &visitor, const TYPE &defaultValue)

template<class RET_TYPE , class VISITOR , class TYPE >
RET_TYPE	apply (const VISITOR &visitor, const TYPE &defaultValue)

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==1, typenameVISITOR::ResultType >::type	applyRaw (VISITOR &visitor)

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==1, typenameVISITOR::ResultType >::type	applyRaw (const VISITOR &visitor)

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==0, void >::type	applyRaw (VISITOR &visitor)

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==0, void >::type	applyRaw (const VISITOR &visitor)

template<class RET_TYPE , class VISITOR >
RET_TYPE	applyRaw (VISITOR &visitor)

template<class RET_TYPE , class VISITOR >
RET_TYPE	applyRaw (const VISITOR &visitor)

template<class TYPE >
VariantImp &	assign (const TYPE &value)

template<class TYPE >
VariantImp &	assign (bslmf::MovableRef< TYPE > value)

template<class TYPE , class SOURCE_TYPE >
VariantImp &	assignTo (const SOURCE_TYPE &value)

template<class TYPE , class... ARGS>
TYPE &	createInPlace (ARGS &&... arguments)

void	reset ()

void	swap (VariantImp &other)

template<class TYPE >
TYPE &	the ()

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==1, typenameVISITOR::ResultType >::type	apply (VISITOR &visitor) const

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==1, typenameVISITOR::ResultType >::type	apply (const VISITOR &visitor) const

template<class VISITOR , class TYPE >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==1, typenameVISITOR::ResultType >::type	apply (VISITOR &visitor, const TYPE &defaultValue) const

template<class VISITOR , class TYPE >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==1, typenameVISITOR::ResultType >::type	apply (const VISITOR &visitor, const TYPE &defaultValue) const

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==0, void >::type	apply (VISITOR &visitor) const

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==0, void >::type	apply (const VISITOR &visitor) const

template<class VISITOR , class TYPE >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==0, void >::type	apply (VISITOR &visitor, const TYPE &defaultValue) const

template<class VISITOR , class TYPE >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==0, void >::type	apply (const VISITOR &visitor, const TYPE &defaultValue) const

template<class RET_TYPE , class VISITOR >
RET_TYPE	apply (VISITOR &visitor) const

template<class RET_TYPE , class VISITOR >
RET_TYPE	apply (const VISITOR &visitor) const

template<class RET_TYPE , class VISITOR , class TYPE >
RET_TYPE	apply (VISITOR &visitor, const TYPE &defaultValue) const

template<class RET_TYPE , class VISITOR , class TYPE >
RET_TYPE	apply (const VISITOR &visitor, const TYPE &defaultValue) const

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==1, typenameVISITOR::ResultType >::type	applyRaw (VISITOR &visitor) const

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==1, typenameVISITOR::ResultType >::type	applyRaw (const VISITOR &visitor) const

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==0, void >::type	applyRaw (VISITOR &visitor) const

template<class VISITOR >
bsl::enable_if< Variant_ReturnValueHelper< VISITOR >::value==0, void >::type	applyRaw (const VISITOR &visitor) const

template<class RET_TYPE , class VISITOR >
RET_TYPE	applyRaw (VISITOR &visitor) const

template<class RET_TYPE , class VISITOR >
RET_TYPE	applyRaw (const VISITOR &visitor) const

template<class TYPE >
bool	is () const

bool	isUnset () const

bsl::ostream &	print (bsl::ostream &stream, int level=0, int spacesPerLevel=4) const

template<class TYPE >
const TYPE &	the () const

int	typeIndex () const

const bsl::type_info &	typeInfo () const

template<class STREAM >
STREAM &	bdexStreamIn (STREAM &stream, int version)
	DEPRECATED: Do not use.

int	maxSupportedBdexVersion () const
	DEPRECATED: Do not use.

template<class STREAM >
STREAM &	bdexStreamOut (STREAM &stream, int version) const
	DEPRECATED: Do not use.

template<class TYPE >
VariantImp< TYPES > &	operator= (const TYPE &value)

template<class TYPE >
VariantImp< TYPES > &	operator= (bslmf::MovableRef< TYPE > value)

template<class TYPE >
VariantImp< TYPES > &	assign (const TYPE &value)

template<class TYPE >
VariantImp< TYPES > &	assign (bslmf::MovableRef< TYPE > value)

template<class TYPE , class SOURCE_TYPE >
VariantImp< TYPES > &	assignTo (const SOURCE_TYPE &value)

Constructor & Destructor Documentation

◆ Variant() [1/8]

template<class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 , class A15 , class A16 , class A17 , class A18 , class A19 , class A20 >

bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::Variant ( )

inline

Create a variant object in the unset state that uses the currently installed default allocator to supply memory.

◆ Variant() [2/8]

template<class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 , class A15 , class A16 , class A17 , class A18 , class A19 , class A20 >

template<class TYPE_OR_ALLOCATOR >

bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::Variant ( const TYPE_OR_ALLOCATOR & valueOrAllocator )

inlineexplicit

Create a variant object with the specified valueOrAllocator that can be either a value of a type that the variant can hold or an allocator to supply memory. If valueOrAllocator is not a bslma::Allocator *, then the variant will hold the value and type of valueOrAllocator, and use the currently installed default allocator to supply memory. Otherwise, the variant will be unset and use valueOrAllocator to supply memory. TYPE_OR_ALLOCATOR must be the same as one of the types that this variant can hold or be convertible to bslma::Allocator *. Note that this parameterized constructor is defined instead of two constructors (one taking a bslma::Allocator * and the other not) because template parameter arguments are always a better match than derived-to-base conversion (a concrete allocator pointer converted to bslma::Allocator *).

◆ Variant() [3/8]

template<class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 , class A15 , class A16 , class A17 , class A18 , class A19 , class A20 >

template<class TYPE >

bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::Variant	(	const TYPE &	value,
		bslma::Allocator *	basicAllocator
	)

inline

Create a variant object having the specified value of template parameter TYPE and that uses the specified basicAllocator to supply memory. If basicAllocator is 0, the currently installed default allocator is used. TYPE must be the same as one of the types that this variant can hold.

◆ Variant() [4/8]

template<class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 , class A15 , class A16 , class A17 , class A18 , class A19 , class A20 >

template<class TYPE >

bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::Variant ( bslmf::MovableRef< TYPE > value )

inlineexplicit

◆ Variant() [5/8]

template<class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 , class A15 , class A16 , class A17 , class A18 , class A19 , class A20 >

template<class TYPE >

bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::Variant	(	bslmf::MovableRef< TYPE >	value,
		bslma::Allocator *	basicAllocator
	)

inline

◆ Variant() [6/8]

template<class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 , class A15 , class A16 , class A17 , class A18 , class A19 , class A20 >

bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::Variant	(	const Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 > &	original,
		bslma::Allocator *	basicAllocator = `0`
	)

inline

Create a variant object having the type and value of the specified original variant. Optionally specify a basicAllocator used to supply memory. If basicAllocator is 0, the currently installed default allocator is used.

◆ Variant() [7/8]

template<class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 , class A15 , class A16 , class A17 , class A18 , class A19 , class A20 >

bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::Variant ( bslmf::MovableRef< Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 > > original )

inline

Create a variant object having the type and value of the specified original object by moving the contents of original to the newly-created object. The allocator associated with original (if any) is propagated for use in the newly-created object. original is left in a valid but unspecified state.

◆ Variant() [8/8]

template<class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 , class A15 , class A16 , class A17 , class A18 , class A19 , class A20 >

bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::Variant	(	bslmf::MovableRef< Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 > >	original,
		bslma::Allocator *	basicAllocator
	)

inline

Create a variant object having the type and value of the specified original object that uses the specified basicAllocator to supply memory. If basicAllocator is 0, the currently installed default allocator is used. The contents of original are moved to the newly-created object with original left in a valid but unspecified state.

Member Function Documentation

◆ BSLMF_NESTED_TRAIT_DECLARATION()

template<class A1 = bslmf::Nil, class A2 = bslmf::Nil, class A3 = bslmf::Nil, class A4 = bslmf::Nil, class A5 = bslmf::Nil, class A6 = bslmf::Nil, class A7 = bslmf::Nil, class A8 = bslmf::Nil, class A9 = bslmf::Nil, class A10 = bslmf::Nil, class A11 = bslmf::Nil, class A12 = bslmf::Nil, class A13 = bslmf::Nil, class A14 = bslmf::Nil, class A15 = bslmf::Nil, class A16 = bslmf::Nil, class A17 = bslmf::Nil, class A18 = bslmf::Nil, class A19 = bslmf::Nil, class A20 = bslmf::Nil>

bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::BSLMF_NESTED_TRAIT_DECLARATION	(	Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >	,
		HasPrintMethod
	)

◆ BSLMF_NESTED_TRAIT_DECLARATION_IF() [1/3]

template<class A1 = bslmf::Nil, class A2 = bslmf::Nil, class A3 = bslmf::Nil, class A4 = bslmf::Nil, class A5 = bslmf::Nil, class A6 = bslmf::Nil, class A7 = bslmf::Nil, class A8 = bslmf::Nil, class A9 = bslmf::Nil, class A10 = bslmf::Nil, class A11 = bslmf::Nil, class A12 = bslmf::Nil, class A13 = bslmf::Nil, class A14 = bslmf::Nil, class A15 = bslmf::Nil, class A16 = bslmf::Nil, class A17 = bslmf::Nil, class A18 = bslmf::Nil, class A19 = bslmf::Nil, class A20 = bslmf::Nil>

bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::BSLMF_NESTED_TRAIT_DECLARATION_IF	(	Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >	,
		bslma::UsesBslmaAllocator	,
		Traits::k_VARIANT_USES_BSLMA_ALLOCATOR
	)

◆ BSLMF_NESTED_TRAIT_DECLARATION_IF() [2/3]

template<class A1 = bslmf::Nil, class A2 = bslmf::Nil, class A3 = bslmf::Nil, class A4 = bslmf::Nil, class A5 = bslmf::Nil, class A6 = bslmf::Nil, class A7 = bslmf::Nil, class A8 = bslmf::Nil, class A9 = bslmf::Nil, class A10 = bslmf::Nil, class A11 = bslmf::Nil, class A12 = bslmf::Nil, class A13 = bslmf::Nil, class A14 = bslmf::Nil, class A15 = bslmf::Nil, class A16 = bslmf::Nil, class A17 = bslmf::Nil, class A18 = bslmf::Nil, class A19 = bslmf::Nil, class A20 = bslmf::Nil>

bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::BSLMF_NESTED_TRAIT_DECLARATION_IF	(	Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >	,
		bslmf::IsBitwiseCopyable	,
		Traits::k_VARIANT_IS_BITWISE_COPYABLE
	)

◆ BSLMF_NESTED_TRAIT_DECLARATION_IF() [3/3]

template<class A1 = bslmf::Nil, class A2 = bslmf::Nil, class A3 = bslmf::Nil, class A4 = bslmf::Nil, class A5 = bslmf::Nil, class A6 = bslmf::Nil, class A7 = bslmf::Nil, class A8 = bslmf::Nil, class A9 = bslmf::Nil, class A10 = bslmf::Nil, class A11 = bslmf::Nil, class A12 = bslmf::Nil, class A13 = bslmf::Nil, class A14 = bslmf::Nil, class A15 = bslmf::Nil, class A16 = bslmf::Nil, class A17 = bslmf::Nil, class A18 = bslmf::Nil, class A19 = bslmf::Nil, class A20 = bslmf::Nil>

bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::BSLMF_NESTED_TRAIT_DECLARATION_IF	(	Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >	,
		bslmf::IsBitwiseMoveable	,
		Traits::k_VARIANT_IS_BITWISE_MOVEABLE
	)

◆ operator=() [1/6]

template<class A1 = bslmf::Nil, class A2 = bslmf::Nil, class A3 = bslmf::Nil, class A4 = bslmf::Nil, class A5 = bslmf::Nil, class A6 = bslmf::Nil, class A7 = bslmf::Nil, class A8 = bslmf::Nil, class A9 = bslmf::Nil, class A10 = bslmf::Nil, class A11 = bslmf::Nil, class A12 = bslmf::Nil, class A13 = bslmf::Nil, class A14 = bslmf::Nil, class A15 = bslmf::Nil, class A16 = bslmf::Nil, class A17 = bslmf::Nil, class A18 = bslmf::Nil, class A19 = bslmf::Nil, class A20 = bslmf::Nil>

template<class TYPE >

Variant & bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::operator= ( bslmf::MovableRef< TYPE > value )

◆ operator=() [2/6]

template<class A1 = bslmf::Nil, class A2 = bslmf::Nil, class A3 = bslmf::Nil, class A4 = bslmf::Nil, class A5 = bslmf::Nil, class A6 = bslmf::Nil, class A7 = bslmf::Nil, class A8 = bslmf::Nil, class A9 = bslmf::Nil, class A10 = bslmf::Nil, class A11 = bslmf::Nil, class A12 = bslmf::Nil, class A13 = bslmf::Nil, class A14 = bslmf::Nil, class A15 = bslmf::Nil, class A16 = bslmf::Nil, class A17 = bslmf::Nil, class A18 = bslmf::Nil, class A19 = bslmf::Nil, class A20 = bslmf::Nil>

template<class TYPE >

Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 > & bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::operator= ( bslmf::MovableRef< TYPE > value )

inline

◆ operator=() [3/6]

template<class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 , class A15 , class A16 , class A17 , class A18 , class A19 , class A20 >

Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 > & bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::operator= ( bslmf::MovableRef< Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 > > rhs )

inline

Assign to this object the type and value currently held by the specified rhs object, and return a reference providing modifiable access to this object. The value currently held by this variant (if any) is destroyed if that value's type is not the same as the type held by the rhs object. The contents of rhs are either move-inserted into or move-assigned to this object with rhs left in a valid but unspecified state.

◆ operator=() [4/6]

template<class A1 = bslmf::Nil, class A2 = bslmf::Nil, class A3 = bslmf::Nil, class A4 = bslmf::Nil, class A5 = bslmf::Nil, class A6 = bslmf::Nil, class A7 = bslmf::Nil, class A8 = bslmf::Nil, class A9 = bslmf::Nil, class A10 = bslmf::Nil, class A11 = bslmf::Nil, class A12 = bslmf::Nil, class A13 = bslmf::Nil, class A14 = bslmf::Nil, class A15 = bslmf::Nil, class A16 = bslmf::Nil, class A17 = bslmf::Nil, class A18 = bslmf::Nil, class A19 = bslmf::Nil, class A20 = bslmf::Nil>

template<class TYPE >

Variant & bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::operator= ( const TYPE & value )

Assign to this object the specified value of template parameter TYPE, and return a reference providing modifiable access to this object. The value currently held by this variant (if any) is destroyed if that value's type is not the same as TYPE. TYPE must be the same as one of the types that this variant can hold.

◆ operator=() [5/6]

template<class A1 = bslmf::Nil, class A2 = bslmf::Nil, class A3 = bslmf::Nil, class A4 = bslmf::Nil, class A5 = bslmf::Nil, class A6 = bslmf::Nil, class A7 = bslmf::Nil, class A8 = bslmf::Nil, class A9 = bslmf::Nil, class A10 = bslmf::Nil, class A11 = bslmf::Nil, class A12 = bslmf::Nil, class A13 = bslmf::Nil, class A14 = bslmf::Nil, class A15 = bslmf::Nil, class A16 = bslmf::Nil, class A17 = bslmf::Nil, class A18 = bslmf::Nil, class A19 = bslmf::Nil, class A20 = bslmf::Nil>

template<class TYPE >

Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 > & bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::operator= ( const TYPE & value )

inline

◆ operator=() [6/6]

template<class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 , class A15 , class A16 , class A17 , class A18 , class A19 , class A20 >

Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 > & bdlb::Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 >::operator= ( const Variant< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 > & rhs )

inline

Assign to this object the type and value currently held by the specified rhs object, and return a reference providing modifiable access to this object. The value currently held by this variant (if any) is destroyed if that value's type is not the same as the type held by the rhs object.

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

bdlb_variant.h

Public Member Functions

Constructor & Destructor Documentation

◆ Variant() [1/8]

◆ Variant() [2/8]

◆ Variant() [3/8]

◆ Variant() [4/8]

◆ Variant() [5/8]

◆ Variant() [6/8]

◆ Variant() [7/8]

◆ Variant() [8/8]

Member Function Documentation

◆ BSLMF_NESTED_TRAIT_DECLARATION()

◆ BSLMF_NESTED_TRAIT_DECLARATION_IF() [1/3]

◆ BSLMF_NESTED_TRAIT_DECLARATION_IF() [2/3]

◆ BSLMF_NESTED_TRAIT_DECLARATION_IF() [3/3]

◆ operator=() [1/6]

◆ operator=() [2/6]

◆ operator=() [3/6]

◆ operator=() [4/6]

◆ operator=() [5/6]

◆ operator=() [6/6]