variant.hpp

Go to the documentation of this file.

// Copyright (c) 2019 by Robert Bosch GmbH. All rights reserved.
// Copyright (c) 2021 - 2022 by Apex.AI Inc. All rights reserved.
// Copyright (c) 2023 by ekxide IO GmbH. All rights reserved.
// Copyright (c) 2025 Contributors to the Eclipse Foundation
//
// See the NOTICE file(s) distributed with this work for additional
// information regarding copyright ownership.
//
// This program and the accompanying materials are made available under the
// terms of the Apache Software License 2.0 which is available at
// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
// which is available at https://opensource.org/licenses/MIT.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
 
#ifndef IOX2_BB_VOCABULARY_VARIANT_HPP
#define IOX2_BB_VOCABULARY_VARIANT_HPP
 
#include "iox2/legacy/detail/platform_correction.hpp"
 
#include "iox2/legacy/detail/variant_internal.hpp"
 
#include <algorithm>
#include <cstdint>
#include <iostream>
#include <limits>
#include <type_traits>
 
namespace iox2 {
namespace legacy {
template <uint64_t N>
struct in_place_index {
    static constexpr uint64_t value { N };
};
 
template <typename T>
struct in_place_type {
    using type = T;
};
 
static constexpr uint64_t INVALID_VARIANT_INDEX { std::numeric_limits<uint64_t>::max() };
 
template <typename... Types>
class variant final {
  private:
    static constexpr uint64_t TYPE_SIZE { std::max({ sizeof(Types)... }) };
    static constexpr uint64_t TYPE_ALIGNMENT { std::max({ alignof(Types)... }) };
 
  public:
    constexpr variant() noexcept = default;
 
    template <uint64_t N, typename... CTorArguments>
    constexpr explicit variant(const in_place_index<N>& index, CTorArguments&&... args) noexcept;
 
    template <typename T, typename... CTorArguments>
    constexpr explicit variant(const in_place_type<T>& type, CTorArguments&&... args) noexcept;
 
    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 explicit variant(T&& arg) noexcept;
 
    constexpr variant(const variant& rhs) noexcept;
 
    constexpr variant& operator=(const variant& rhs) noexcept;
 
    constexpr variant(variant&& rhs) noexcept;
 
    constexpr variant& operator=(variant&& rhs) noexcept;
 
    ~variant() noexcept;
 
    template <typename T>
    // NOLINTJUSTIFICATION Correct return type is used through enable_if
    // NOLINTNEXTLINE(cppcoreguidelines-c-copy-assignment-signature)
    typename std::enable_if<!std::is_same<T, variant<Types...>&>::value, variant<Types...>>::type&
    operator=(T&& rhs) noexcept;
 
    template <uint64_t TypeIndex, typename... CTorArguments>
    void emplace_at_index(CTorArguments&&... args) noexcept;
 
    template <typename T, typename... CTorArguments>
    void emplace(CTorArguments&&... args) noexcept;
 
    template <uint64_t TypeIndex>
    typename internal::get_type_at_index<0, TypeIndex, Types...>::type* get_at_index() noexcept;
 
    template <uint64_t TypeIndex>
    typename internal::get_type_at_index<0, TypeIndex, Types...>::type* unsafe_get_at_index_unchecked() noexcept;
 
    template <uint64_t TypeIndex>
    const typename internal::get_type_at_index<0, TypeIndex, Types...>::type* get_at_index() const noexcept;
 
    template <uint64_t TypeIndex>
    const typename internal::get_type_at_index<0, TypeIndex, Types...>::type*
    unsafe_get_at_index_unchecked() const noexcept;
 
    template <typename T>
    const T* get() const noexcept;
 
    template <typename T>
    T* get() noexcept;
 
    template <typename T>
    T* get_if(T* defaultValue) noexcept;
 
    template <typename T>
    const T* get_if(const T* defaultValue) const noexcept;
 
    constexpr uint64_t index() const noexcept;
 
  private:
    // AXIVION Next Construct AutosarC++19_03-A9.6.1 : false positive. internal::byte_t is a type alias for uint8_t
    struct alignas(TYPE_ALIGNMENT) storage_t {
        // AXIVION Next Construct AutosarC++19_03-M0.1.3 : data provides the actual storage and is accessed via m_storage since &m_storage.data = &m_storage
        // AXIVION Next Construct AutosarC++19_03-A18.1.1 : safe access is guaranteed since the c-array is wrapped inside the variant class
        // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays)
        char data[TYPE_SIZE];
    };
    storage_t m_storage {};
    uint64_t m_type_index { INVALID_VARIANT_INDEX };
 
  private:
    template <typename T>
    bool has_bad_variant_element_access() const noexcept;
    // AXIVION Next Construct AutosarC++19_03-A3.9.1 : internal convenience function to easily use IOX2_LOG
    static void error_message(const char* source, const char* msg) noexcept;
 
    void call_element_destructor() noexcept;
 
    template <typename... Ts>
    friend constexpr bool operator==(const variant<Ts...>& lhs, const variant<Ts...>& rhs) noexcept;
    template <typename... Ts>
    friend constexpr bool operator!=(const variant<Ts...>& lhs, const variant<Ts...>& rhs) noexcept;
};
 
template <typename T, typename... Types>
constexpr bool holds_alternative(const variant<Types...>& variant) noexcept;
 
template <typename... Types>
constexpr bool operator==(const variant<Types...>& lhs, const variant<Types...>& rhs) noexcept;
 
template <typename... Types>
constexpr bool operator!=(const variant<Types...>& lhs, const variant<Types...>& rhs) noexcept;
 
} // namespace legacy
} // namespace iox2
 
#include "iox2/legacy/detail/variant.inl"
 
#endif // IOX2_BB_VOCABULARY_VARIANT_HPP