iceoryx_hoofs 2.0.5
Loading...
Searching...
No Matches
Public Member Functions | List of all members
iox::cxx::variant< Types > Class Template Reference

Variant implementation from the C++17 standard with C++11. The interface is inspired by the C++17 standard but it has changes in get and emplace since we are not allowed to throw exceptions. More...

#include <iceoryx_hoofs/cxx/variant.hpp>

Public Member Functions

constexpr variant () noexcept=default
 the default constructor constructs a variant which does not contain an element and returns INVALID_VARIANT_INDEX when .index() is called
 
template<uint64_t N, typename... CTorArguments>
constexpr variant (const in_place_index< N > &index, CTorArguments &&... args) noexcept
 creates a variant and perform an in place construction of the type stored at index N. If the index N is out of bounds you get a compiler error.
 
template<typename T , typename... CTorArguments>
constexpr variant (const in_place_type< T > &type, CTorArguments &&... args) noexcept
 creates a variant and perform an in place construction of the type T. If T is not part of the variant you get a compiler error.
 
template<typename T , typename = std::enable_if_t<!std::is_same<std::decay_t<T>, variant>::value>, typename std::enable_if_t<!internal::is_in_place_index< std::decay_t< T > >::value, bool > = false, typename std::enable_if_t<!internal::is_in_place_type< std::decay_t< T > >::value, bool > = false>
constexpr variant (T &&arg) noexcept
 creates a variant from a user supplied value
 
constexpr variant (const variant &rhs) noexcept
 if the variant contains an element the elements copy constructor is called otherwise an empty variant is copied
 
constexpr variantoperator= (const variant &rhs) noexcept
 if the variant contains an element the elements copy assignment operator is called otherwise an empty variant is copied
 
constexpr variant (variant &&rhs) noexcept
 if the variant contains an element the elements move constructor is called otherwise an empty variant is moved
 
constexpr variantoperator= (variant &&rhs) noexcept
 if the variant contains an element the elements move assignment operator is called otherwise an empty variant is moved
 
 ~variant () noexcept
 if the variant contains an element the elements destructor is called otherwise nothing happens
 
template<typename T >
std::enable_if<!std::is_same< T, variant< Types... > & >::value, variant< Types... > >::type & operator= (T &&rhs) noexcept
 if the variant contains an element the elements assignment operator is called otherwise we have undefined behavior. It is important that you make sure that the variant really contains that type T.
 
template<uint64_t TypeIndex, typename... CTorArguments>
bool emplace_at_index (CTorArguments &&... args) noexcept
 calls the constructor of the type at index TypeIndex and perfectly forwards the arguments to this constructor. (not stl compliant)
 
template<typename T , typename... CTorArguments>
bool emplace (CTorArguments &&... args) noexcept
 calls the constructor of the type T and perfectly forwards the arguments to the constructor of T.
 
template<uint64_t TypeIndex>
internal::get_type_at_index< 0, TypeIndex, Types... >::type * get_at_index () noexcept
 returns a pointer to the type stored at index TypeIndex. (not stl compliant)
 
template<uint64_t TypeIndex>
const internal::get_type_at_index< 0, TypeIndex, Types... >::type * get_at_index () const noexcept
 returns a pointer to the type stored at index TypeIndex. (not stl compliant)
 
template<typename T >
const T * get () const noexcept
 returns a pointer to the type T stored in the variant. (not stl compliant)
 
template<typename T >
T * get () noexcept
 returns a pointer to the type T stored in the variant. (not stl compliant)
 
template<typename T >
T * get_if (T *defaultValue) noexcept
 returns a pointer to the type T if its stored in the variant otherwise it returns the provided defaultValue
 
template<typename T >
const T * get_if (const T *defaultValue) const noexcept
 returns a pointer to the type T if its stored in the variant otherwise it returns the provided defaultValue
 
constexpr uint64_t index () const noexcept
 returns the index of the stored type in the variant. if the variant does not contain any type it returns INVALID_VARIANT_INDEX
 

Detailed Description

template<typename... Types>
class iox::cxx::variant< Types >

Variant implementation from the C++17 standard with C++11. The interface is inspired by the C++17 standard but it has changes in get and emplace since we are not allowed to throw exceptions.

Parameters
Types...variadic list of types which the variant should be able to store
#include "iceoryx_hoofs/cxx/variant.hpp"
#include <iostream>
// ... do stuff
if ( someVariant.index() == INVALID_VARIANT_INDEX )
{
someVariant.emplace<float>(123.456f);
}
else if ( someVariant.index() == 1)
{
auto blubb = someVariant.template get_at_index<1>();
std::cout << *blubb << std::endl;
auto sameAsBlubb = someVariant.get<float>();
std::cout << *sameAsBlubb << std::endl;
}
// .. do stuff
int defaultValue = 123;
int * fuu = someVariant.get_if<int>(&defaultValue);
std::cout << *fuu << std::endl;
Variant implementation from the C++17 standard with C++11. The interface is inspired by the C++17 sta...
Definition variant.hpp:107
constexpr uint64_t index() const noexcept
returns the index of the stored type in the variant. if the variant does not contain any type it retu...
T * get_if(T *defaultValue) noexcept
returns a pointer to the type T if its stored in the variant otherwise it returns the provided defaul...
bool emplace(CTorArguments &&... args) noexcept
calls the constructor of the type T and perfectly forwards the arguments to the constructor of T.
const T * get() const noexcept
returns a pointer to the type T stored in the variant. (not stl compliant)

Constructor & Destructor Documentation

◆ variant() [1/5]

template<typename... Types>
template<uint64_t N, typename... CTorArguments>
constexpr iox::cxx::variant< Types >::variant ( const in_place_index< N > &  index,
CTorArguments &&...  args 
)
constexprnoexcept

creates a variant and perform an in place construction of the type stored at index N. If the index N is out of bounds you get a compiler error.

Template Parameters

in] N index where to perform the placement new

Template Parameters

in] CTorArguments variadic types of the c'tor arguments

Parameters
[in]indexindex of the type which should be constructed
[in]argsvariadic list of arguments which will be forwarded to the constructor to the type at index

◆ variant() [2/5]

template<typename... Types>
template<typename T , typename... CTorArguments>
constexpr iox::cxx::variant< Types >::variant ( const in_place_type< T > &  type,
CTorArguments &&...  args 
)
constexprnoexcept

creates a variant and perform an in place construction of the type T. If T is not part of the variant you get a compiler error.

Template Parameters

in] T type which should be created inside the variant

Template Parameters

in] CTorArguments variadic types of the c'tor arguments

Parameters
[in]typetype which should be created inside the variant
[in]argsvariadic list of arguments which will be forwarded to the constructor to the type

◆ variant() [3/5]

template<typename... Types>
template<typename T , typename = std::enable_if_t<!std::is_same<std::decay_t<T>, variant>::value>, typename std::enable_if_t<!internal::is_in_place_index< std::decay_t< T > >::value, bool > = false, typename std::enable_if_t<!internal::is_in_place_type< std::decay_t< T > >::value, bool > = false>
constexpr iox::cxx::variant< Types >::variant ( T &&  arg)
constexprnoexcept

creates a variant from a user supplied value

Template Parameters

in] T type of the value to be stored in the variant

Parameters
[in]argarg to be forwared to the c'tor of T

◆ variant() [4/5]

template<typename... Types>
constexpr iox::cxx::variant< Types >::variant ( const variant< Types > &  rhs)
constexprnoexcept

if the variant contains an element the elements copy constructor is called otherwise an empty variant is copied

Parameters
[in]rhssource of the copy

◆ variant() [5/5]

template<typename... Types>
constexpr iox::cxx::variant< Types >::variant ( variant< Types > &&  rhs)
constexprnoexcept

if the variant contains an element the elements move constructor is called otherwise an empty variant is moved

Parameters
[in]rhssource of the move

Member Function Documentation

◆ emplace()

template<typename... Types>
template<typename T , typename... CTorArguments>
bool iox::cxx::variant< Types >::emplace ( CTorArguments &&...  args)
noexcept

calls the constructor of the type T and perfectly forwards the arguments to the constructor of T.

Template Parameters

in] T type which is created inside the variant

Template Parameters

in] CTorArguments variadic types of the c'tor arguments

Returns
if the variant already contains a different type it returns false, if the construction was successful it returns true

◆ emplace_at_index()

template<typename... Types>
template<uint64_t TypeIndex, typename... CTorArguments>
bool iox::cxx::variant< Types >::emplace_at_index ( CTorArguments &&...  args)
noexcept

calls the constructor of the type at index TypeIndex and perfectly forwards the arguments to this constructor. (not stl compliant)

Template Parameters
TypeIndexindex of the type which will be created
CTorArgumentsvariadic types of the c'tor arguments
Parameters
[in]argsarguments which will be forwarded to the constructor to the type at TypeIndex
Returns
if the variant already contains a different type it returns false, if the construction was successful it returns true

◆ get() [1/2]

template<typename... Types>
template<typename T >
const T * iox::cxx::variant< Types >::get ( ) const
noexcept

returns a pointer to the type T stored in the variant. (not stl compliant)

Template Parameters

in] T type of the returned pointer

Returns
if the variant does contain the type T it returns a valid pointer otherwise if the variant does contain no type at all or a different type it returns nullptr

◆ get() [2/2]

template<typename... Types>
template<typename T >
T * iox::cxx::variant< Types >::get ( )
noexcept

returns a pointer to the type T stored in the variant. (not stl compliant)

Template Parameters

in] T type of the returned pointer

Returns
if the variant does contain the type T it returns a valid pointer otherwise if the variant does contain no type at all or a different type it returns nullptr

◆ get_at_index() [1/2]

template<typename... Types>
template<uint64_t TypeIndex>
const internal::get_type_at_index< 0, TypeIndex, Types... >::type * iox::cxx::variant< Types >::get_at_index ( ) const
noexcept

returns a pointer to the type stored at index TypeIndex. (not stl compliant)

Template Parameters

in] TypeIndex index of the stored type

Returns
if the variant does contain the type at index TypeIndex it returns a valid pointer, if it does contain no type at all or a different type it returns nullptr.
int * someNumber = someVariant.template get_at_index<0>();
helper struct to perform an emplacement of a predefined type in in the constructor of a variant
Definition variant.hpp:54

◆ get_at_index() [2/2]

template<typename... Types>
template<uint64_t TypeIndex>
internal::get_type_at_index< 0, TypeIndex, Types... >::type * iox::cxx::variant< Types >::get_at_index ( )
noexcept

returns a pointer to the type stored at index TypeIndex. (not stl compliant)

Template Parameters

in] TypeIndex index of the stored type

Returns
if the variant does contain the type at index TypeIndex it returns a valid pointer, if it does contain no type at all or a different type it returns nullptr.
int * someNumber = someVariant.template get_at_index<0>();

◆ get_if() [1/2]

template<typename... Types>
template<typename T >
const T * iox::cxx::variant< Types >::get_if ( const T *  defaultValue) const
noexcept

returns a pointer to the type T if its stored in the variant otherwise it returns the provided defaultValue

Template Parameters

in] T type of the returned pointer

Parameters
[in]defaultValuevalue which is returned in case of empty or different type in variant
Returns
pointer to the stored value if it is of type T, otherwise defaultValue

◆ get_if() [2/2]

template<typename... Types>
template<typename T >
T * iox::cxx::variant< Types >::get_if ( T *  defaultValue)
noexcept

returns a pointer to the type T if its stored in the variant otherwise it returns the provided defaultValue

Returns
pointer to the stored value if it is of type T, otherwise defaultValue

◆ index()

template<typename... Types>
constexpr uint64_t iox::cxx::variant< Types >::index ( ) const
constexprnoexcept

returns the index of the stored type in the variant. if the variant does not contain any type it returns INVALID_VARIANT_INDEX

Returns
index of the stored type

◆ operator=() [1/3]

template<typename... Types>
constexpr variant & iox::cxx::variant< Types >::operator= ( const variant< Types > &  rhs)
constexprnoexcept

if the variant contains an element the elements copy assignment operator is called otherwise an empty variant is copied

Parameters
[in]rhssource of the copy assignment
Returns
reference to the variant itself

◆ operator=() [2/3]

template<typename... Types>
template<typename T >
std::enable_if<!std::is_same< T, variant< Types... > & >::value, variant< Types... > >::type & iox::cxx::variant< Types >::operator= ( T &&  rhs)
noexcept

if the variant contains an element the elements assignment operator is called otherwise we have undefined behavior. It is important that you make sure that the variant really contains that type T.

Template Parameters

in] T Type of the rhs

Parameters
[in]rhssource object for the underlying move assignment
Returns
reference to the variant itself

◆ operator=() [3/3]

template<typename... Types>
constexpr variant & iox::cxx::variant< Types >::operator= ( variant< Types > &&  rhs)
constexprnoexcept

if the variant contains an element the elements move assignment operator is called otherwise an empty variant is moved

Parameters
[in]rhssource of the move assignment
Returns
reference to the variant itself

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