Variant.h

Go to the documentation of this file.

#ifndef ZSERIO_VARIANT_H_INC
#define ZSERIO_VARIANT_H_INC
 
#include "zserio/AllocatorHolder.h"
#include "zserio/Any.h"
#include "zserio/CppRuntimeException.h"
#include "zserio/HashCodeUtil.h"
#include "zserio/Traits.h"
 
namespace zserio
{
 
namespace detail
{
 
template <size_t I, typename... T>
struct type_at
{
    using type = std::tuple_element_t<I, std::tuple<T...>>;
};
 
template <auto I, typename... T>
using type_at_t = typename type_at<static_cast<size_t>(I), T...>::type;
 
template <size_t N, typename V, typename F>
void for_active_item(const V&, F&&, std::false_type)
{}
 
template <size_t N, typename V, typename F>
void for_active_item(const V& var, F&& fun, std::true_type = {})
{
    using INDEX = typename V::IndexType;
    if (static_cast<size_t>(var.index()) == N - 1)
    {
        std::forward<F>(fun)(*var.template get_if<static_cast<INDEX>(N - 1)>());
    }
    for_active_item<N - 1>(var, std::forward<F>(fun), std::bool_constant<(N - 1 > 0)>());
}
 
template <size_t N, typename V, typename F>
void for_active_item(V& var, F&& fun, std::true_type = {})
{
    using INDEX = typename V::IndexType;
    if (static_cast<size_t>(var.index()) == N - 1)
    {
        std::forward<F>(fun)(*var.template get_if<static_cast<INDEX>(N - 1)>());
    }
    for_active_item<N - 1>(var, std::forward<F>(fun), std::bool_constant<(N - 1 > 0)>());
}
 
template <size_t N, typename V, typename F>
void for_active_item_2(const V&, const V&, F&&, std::false_type)
{}
 
template <size_t N, typename V, typename F>
void for_active_item_2(const V& var1, const V& var2, F&& fun, std::true_type = {})
{
    // assert(var1.index() == var2.index());
    using INDEX = typename V::IndexType;
    if (static_cast<size_t>(var1.index()) == N - 1)
    {
        std::forward<F>(fun)(*var1.template get_if<static_cast<INDEX>(N - 1)>(),
                *var2.template get_if<static_cast<INDEX>(N - 1)>());
    }
    for_active_item_2<N - 1>(var1, var2, std::forward<F>(fun), std::bool_constant<(N - 1 > 0)>());
}
 
} // namespace detail
 
class BadVariantAccess : public CppRuntimeException
{
public:
    using CppRuntimeException::CppRuntimeException;
 
    ~BadVariantAccess() override;
};
 
template <auto I>
struct in_place_index_t
{};
 
template <auto I>
constexpr in_place_index_t<I> in_place_index{};
 
template <typename ALLOC, typename INDEX, typename... T>
class BasicVariant
{
    using AllocTraits = std::allocator_traits<ALLOC>;
 
public:
    using allocator_type = ALLOC;
    using IndexType = INDEX;
 
    BasicVariant() :
            BasicVariant(ALLOC())
    {}
 
    explicit BasicVariant(const ALLOC& allocator) :
            m_data(allocator)
    {
        emplace<INDEX{}>(); // enforce no empty state like std::variant
    }
 
    template <INDEX I, typename... ARGS, std::enable_if_t<!is_first_allocator_v<ARGS...>>* = nullptr>
    explicit BasicVariant(in_place_index_t<I>, ARGS&&... args)
    {
        emplace<I>(std::forward<ARGS>(args)...);
    }
 
    template <INDEX I, typename... ARGS>
    BasicVariant(in_place_index_t<I>, const ALLOC& allocator, ARGS&&... args) :
            m_data(allocator)
    {
        emplace<I>(std::forward<ARGS>(args)...);
    }
 
    BasicVariant(const BasicVariant& other) :
            m_data(other.m_data),
            m_index(other.m_index)
    {}
 
    BasicVariant(const BasicVariant& other, const ALLOC& allocator) :
            m_data(other.m_data, allocator),
            m_index(other.m_index)
    {}
 
    BasicVariant& operator=(const BasicVariant& other)
    {
        m_data = other.m_data;
        m_index = other.m_index;
        return *this;
    }
 
    BasicVariant(BasicVariant&& other) :
            m_data(std::move(other.m_data)),
            m_index(other.m_index)
    {}
 
    BasicVariant(BasicVariant&& other, const ALLOC& allocator) :
            m_data(std::move(other.m_data), allocator),
            m_index(other.m_index)
    {}
 
    ~BasicVariant() = default;
 
    BasicVariant& operator=(BasicVariant&& other)
    {
        if (this != &other)
        {
            m_data = std::move(other.m_data);
            m_index = other.m_index;
        }
 
        return *this;
    }
 
    bool valueless_by_exception() const noexcept
    {
        return static_cast<size_t>(index()) == std::variant_npos || !m_data.hasValue();
    }
 
    template <INDEX I, typename... ARGS>
    decltype(auto) emplace(ARGS&&... args)
    {
        using U = detail::type_at_t<I, T...>;
        auto& ret = m_data.template emplace<U>(std::forward<ARGS>(args)...);
        m_index = I;
        return ret;
    }
 
    INDEX index() const noexcept
    {
        return m_data.hasValue() ? m_index : static_cast<INDEX>(std::variant_npos);
    }
 
    template <INDEX I, typename U = detail::type_at_t<I, T...>>
    U* get_if() noexcept
    {
        if (I != index())
        {
            return nullptr;
        }
        return m_data.template get_if<U>();
    }
 
    template <INDEX I, typename U = detail::type_at_t<I, T...>>
    const U* get_if() const noexcept
    {
        if (I != index())
        {
            return nullptr;
        }
        return m_data.template get_if<U>();
    }
 
    template <INDEX I, typename U = detail::type_at_t<I, T...>>
    U& get()
    {
        auto ptr = get_if<I>();
        if (!ptr)
        {
            throw BadVariantAccess("Variant: Attempt to retrieve an inactive element at index ")
                    << static_cast<size_t>(I) << ". Active element index is " << static_cast<size_t>(index());
        }
        return *ptr;
    }
 
    template <INDEX I, typename U = detail::type_at_t<I, T...>>
    const U& get() const
    {
        auto ptr = get_if<I>();
        if (!ptr)
        {
            throw BadVariantAccess("Variant: Attempt to retrieve an inactive element at index ")
                    << static_cast<size_t>(I) << ". Active element index is " << static_cast<size_t>(index());
        }
        return *ptr;
    }
 
    void swap(BasicVariant& other)
    {
        m_data.swap(other.m_data);
        std::swap(m_index, other.m_index);
    }
 
    template <typename F>
    auto visit(F&& fun) -> decltype(fun(std::declval<detail::type_at_t<0, T...>>()))
    {
        if (valueless_by_exception())
        {
            throw BadVariantAccess("Variant: Cannot visit variant in valueless state");
        }
        using R = decltype(fun(std::declval<detail::type_at_t<0, T...>>()));
        if constexpr (std::is_same_v<R, void>)
        {
            detail::for_active_item<sizeof...(T)>(*this, [func = std::forward<F>(fun)](auto& elem) {
                std::move(func)(elem);
            });
        }
        else
        {
            R ret;
            detail::for_active_item<sizeof...(T)>(*this, [&ret, func = std::forward<F>(fun)](auto& elem) {
                ret = std::move(func)(elem);
            });
            return ret;
        }
    }
 
    template <typename F>
    auto visit(F&& fun) const -> decltype(fun(std::declval<detail::type_at_t<0, T...>>()))
    {
        if (valueless_by_exception())
        {
            throw BadVariantAccess("Variant: Cannot visit variant in valueless state");
        }
        using R = decltype(fun(std::declval<detail::type_at_t<0, T...>>()));
        if constexpr (std::is_same_v<R, void>)
        {
            detail::for_active_item<sizeof...(T)>(*this, [func = std::forward<F>(fun)](auto& elem) {
                std::move(func)(elem);
            });
        }
        else
        {
            R ret;
            detail::for_active_item<sizeof...(T)>(*this, [&ret, func = std::forward<F>(fun)](auto& elem) {
                ret = std::move(func)(elem);
            });
            return ret;
        }
    }
 
    bool operator==(const BasicVariant& other) const
    {
        if (index() != other.index())
        {
            return false;
        }
 
        bool ret = false;
        detail::for_active_item_2<sizeof...(T)>(*this, other, [&ret](auto& elem1, auto& elem2) {
            ret = elem1 == elem2;
        });
        return ret;
    }
 
    bool operator!=(const BasicVariant& other) const
    {
        return !(*this == other);
    }
 
    bool operator<(const BasicVariant& other) const
    {
        if (index() != other.index())
        {
            return index() < other.index();
        }
 
        bool ret = false;
        detail::for_active_item_2<sizeof...(T)>(*this, other, [&ret](auto& elem1, auto& elem2) {
            ret = elem1 < elem2;
        });
        return ret;
    }
 
    bool operator>(const BasicVariant& other) const
    {
        return other < *this;
    }
 
    bool operator<=(const BasicVariant& other) const
    {
        return !(other < *this);
    }
 
    bool operator>=(const BasicVariant& other) const
    {
        return !(other > *this);
    }
 
private:
    BasicAny<ALLOC> m_data;
    INDEX m_index;
};
 
// Using declarations
 
template <typename INDEX, typename... T>
using Variant = BasicVariant<std::allocator<uint8_t>, INDEX, T...>;
 
template <auto I, typename ALLOC, typename INDEX, typename... T>
decltype(auto) get(BasicVariant<ALLOC, INDEX, T...>& var)
{
    static_assert(std::is_same_v<decltype(I), INDEX>, "Index has a wrong type");
    return var.template get<I>();
}
 
template <auto I, typename ALLOC, typename INDEX, typename... T>
decltype(auto) get(const BasicVariant<ALLOC, INDEX, T...>& var)
{
    static_assert(std::is_same_v<decltype(I), INDEX>, "Index has a wrong type");
    return var.template get<I>();
}
 
template <auto I, typename ALLOC, typename INDEX, typename... T>
decltype(auto) get_if(BasicVariant<ALLOC, INDEX, T...>* var)
{
    static_assert(std::is_same_v<decltype(I), INDEX>, "Index has a wrong type");
    return var->template get_if<I>();
}
 
template <auto I, typename ALLOC, typename INDEX, typename... T>
decltype(auto) get_if(const BasicVariant<ALLOC, INDEX, T...>* var)
{
    static_assert(std::is_same_v<decltype(I), INDEX>, "Index has a wrong type");
    return var->template get_if<I>();
}
 
template <typename F, typename ALLOC, typename INDEX, typename... T>
decltype(auto) visit(F&& fun, BasicVariant<ALLOC, INDEX, T...>& var)
{
    return var.visit(std::forward<F>(fun));
}
 
template <typename F, typename ALLOC, typename INDEX, typename... T>
decltype(auto) visit(F&& fun, const BasicVariant<ALLOC, INDEX, T...>& var)
{
    return var.visit(std::forward<F>(fun));
}
 
template <typename ALLOC, typename INDEX, typename... T>
uint32_t calcHashCode(uint32_t seed, const BasicVariant<ALLOC, INDEX, T...>& var)
{
    uint32_t result = seed;
    result = calcHashCode(result, static_cast<size_t>(var.index()));
    var.visit([&result](const auto& value) {
        result = calcHashCode(result, value);
    });
    return result;
}
 
} // namespace zserio
 
namespace std
{
 
template <typename ALLOC, typename INDEX, typename... T>
struct hash<zserio::BasicVariant<ALLOC, INDEX, T...>>
{
    size_t operator()(const zserio::BasicVariant<ALLOC, INDEX, T...>& var) const
    {
        return zserio::calcHashCode(zserio::HASH_SEED, var);
    }
};
 
} // namespace std
 
#endif // ZSERIO_VARIANT_H_INC