Template Class variant

• Defined in File variant.hpp

Class Documentation

template<typename ...Types>
class variant

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.

#include "iceoryx_hoofs/cxx/variant.hpp"
#include <iostream>

cxx::variant<int, float, double> someVariant;

// ... 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;

Param Types…:

variadic list of types which the variant should be able to store

Public 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.

Tparam :

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.

Tparam :

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

Tparam :

constexpr variant(const variant &rhs) noexcept

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

Parameters:

rhs – [in] source of the copy

constexpr variant &operator=(const variant &rhs) noexcept

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

Parameters:

rhs – [in] source of the copy assignment

Returns:

reference to the variant itself

constexpr variant(variant &&rhs) noexcept

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

Parameters:

rhs – [in] source of the move

constexpr variant &operator=(variant &&rhs) noexcept

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

Parameters:

rhs – [in] source of the move assignment

Returns:

reference to the variant itself

~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.

Tparam :

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 Parameters:

• TypeIndex – index of the type which will be created

• CTorArguments – variadic types of the c’tor arguments

Parameters:

args – [in] arguments 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

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.

Tparam :

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)

Tparam :

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)

Tparam :

template<typename T>
const T *get() const noexcept

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

Tparam :

template<typename T>
T *get() noexcept

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

Tparam :

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

Returns:

pointer to the stored value if it is of type T, otherwise 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

Tparam :

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

Returns:

index of the stored type