iox::cxx::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. More...
#include <iceoryx_hoofs/cxx/variant.hpp>
Public Functions🔗
| Name | |
|---|---|
| constexpr | variant() =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) 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) 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 constexpr |
variant(T && arg) creates a variant from a user supplied value |
| constexpr | variant(const variant & rhs) if the variant contains an element the elements copy constructor is called otherwise an empty variant is copied |
| constexpr variant & | operator=(const variant & rhs) if the variant contains an element the elements copy assignment operator is called otherwise an empty variant is copied |
| constexpr | variant(variant && rhs) if the variant contains an element the elements move constructor is called otherwise an empty variant is moved |
| constexpr variant & | operator=(variant && rhs) if the variant contains an element the elements move assignment operator is called otherwise an empty variant is moved |
| ~variant() 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) 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) 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) 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() 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 returns a pointer to the type stored at index TypeIndex. (not stl compliant) |
| template <typename T > const T * |
get() const returns a pointer to the type T stored in the variant. (not stl compliant) |
| template <typename T > T * |
get() returns a pointer to the type T stored in the variant. (not stl compliant) |
| template <typename T > T * |
get_if(T * defaultValue) 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 returns a pointer to the type T if its stored in the variant otherwise it returns the provided defaultValue |
| constexpr uint64_t | index() const 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;
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>
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;
Public Functions Documentation🔗
function variant🔗
constexpr variant() =default
the default constructor constructs a variant which does not contain an element and returns INVALID_VARIANT_INDEX when .index() is called
function variant🔗
template <uint64_t N,
typename... CTorArguments>
constexpr variant(
const in_place_index< N > & index,
CTorArguments &&... args
)
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:
function variant🔗
template <typename T ,
typename... CTorArguments>
constexpr variant(
const in_place_type< T > & type,
CTorArguments &&... args
)
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:
function variant🔗
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
)
creates a variant from a user supplied value
Template Parameters:
function variant🔗
constexpr variant(
const variant & rhs
)
if the variant contains an element the elements copy constructor is called otherwise an empty variant is copied
Parameters:
- rhs source of the copy
function operator=🔗
constexpr variant & operator=(
const variant & rhs
)
if the variant contains an element the elements copy assignment operator is called otherwise an empty variant is copied
Parameters:
- rhs source of the copy assignment
Return: reference to the variant itself
function variant🔗
constexpr variant(
variant && rhs
)
if the variant contains an element the elements move constructor is called otherwise an empty variant is moved
Parameters:
- rhs source of the move
function operator=🔗
constexpr variant & operator=(
variant && rhs
)
if the variant contains an element the elements move assignment operator is called otherwise an empty variant is moved
Parameters:
- rhs source of the move assignment
Return: reference to the variant itself
function ~variant🔗
~variant()
if the variant contains an element the elements destructor is called otherwise nothing happens
function operator=🔗
template <typename T >
std::enable_if<!std::is_same< T, variant< Types... > & >::value, variant< Types... > >::type & operator=(
T && rhs
)
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:
function emplace_at_index🔗
template <uint64_t TypeIndex,
typename... CTorArguments>
bool emplace_at_index(
CTorArguments &&... args
)
calls the constructor of the type at index TypeIndex and perfectly forwards the arguments to this constructor. (not stl compliant)
Parameters:
- args arguments which will be forwarded to the constructor to the type at TypeIndex
Template Parameters:
- TypeIndex index of the type which will be created
- CTorArguments variadic types of the c'tor arguments
Return: if the variant already contains a different type it returns false, if the construction was successful it returns true
function emplace🔗
template <typename T ,
typename... CTorArguments>
bool emplace(
CTorArguments &&... args
)
calls the constructor of the type T and perfectly forwards the arguments to the constructor of T.
Template Parameters:
function get_at_index🔗
template <uint64_t TypeIndex>
internal::get_type_at_index< 0, TypeIndex, Types... >::type * get_at_index()
returns a pointer to the type stored at index TypeIndex. (not stl compliant)
Template Parameters:
function get_at_index🔗
template <uint64_t TypeIndex>
const internal::get_type_at_index< 0, TypeIndex, Types... >::type * get_at_index() const
returns a pointer to the type stored at index TypeIndex. (not stl compliant)
Template Parameters:
function get🔗
template <typename T >
const T * get() const
returns a pointer to the type T stored in the variant. (not stl compliant)
Template Parameters:
function get🔗
template <typename T >
T * get()
returns a pointer to the type T stored in the variant. (not stl compliant)
Template Parameters:
function get_if🔗
template <typename T >
T * get_if(
T * defaultValue
)
returns a pointer to the type T if its stored in the variant otherwise it returns the provided defaultValue
Return: pointer to the stored value if it is of type T, otherwise defaultValue
function get_if🔗
template <typename T >
const T * get_if(
const T * defaultValue
) const
returns a pointer to the type T if its stored in the variant otherwise it returns the provided defaultValue
Template Parameters:
function index🔗
constexpr uint64_t index() const
returns the index of the stored type in the variant. if the variant does not contain any type it returns INVALID_VARIANT_INDEX
Return: index of the stored type
Updated on 17 March 2022 at 12:15:57 CET