Any.h

Go to the documentation of this file.

#ifndef ZSERIO_ANY_H_INC
#define ZSERIO_ANY_H_INC
 
#include <cstddef>
#include <cstring>
#include <optional>
#include <type_traits>
#include <typeinfo>
 
#include "zserio/AllocatorHolder.h"
#include "zserio/CppRuntimeException.h"
#include "zserio/HashCodeUtil.h"
#include "zserio/Optional.h"
#include "zserio/RebindAlloc.h"
#include "zserio/Traits.h"
#include "zserio/Types.h"
 
namespace zserio
{
 
namespace detail
{
 
#if !defined(ZSERIO_TYPEID_STATIC_ONLY)
    #if !defined(_MSC_VER) && !defined(__GNUC__)
        #warning "Unsupported compiler, type identification in zserio::Any runs in fallback mode"
        #define ZSERIO_TYPEID_STATIC_ONLY
    #endif
#endif
 
class TypeIdHolder
{
public:
#if defined(ZSERIO_TYPEID_STATIC_ONLY)
    using type_id = uintptr_t;
 
    template <typename T>
    static uintptr_t get()
    {
        static const id = 0;
        return &id;
    }
 
    static bool equals(type_id lhs, type_id rhs)
    {
        return lhs == rhs;
    }
 
// in MSVC typeid works even when RTTI is disabled
#elif defined(_MSC_VER) || defined(__GXX_RTTI)
    using type_id = const std::type_info&;
 
    template <typename T>
    static type_id get()
    {
        return typeid(T);
    }
 
    static bool equals(type_id lhs, type_id rhs)
    {
    #if defined(_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION) && _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION == 3
        // libc++ on arm64 Apple platforms (see __non_unique_arm_rtti_bit_impl) marks RTTI with hidden
        // visibility as non-unique and type_info::operator== can then report a type as unequal to itself,
        // e.g. when a hidden visibility translation unit and a default visibility one use the same type.
        // Falling back to the type names gives the right answer for such types. The price is that types
        // with the same name and internal linkage, like types in anonymous namespaces in different
        // translation units, compare equal there.
        return lhs == rhs || std::strcmp(lhs.name(), rhs.name()) == 0;
    #else
        return lhs == rhs;
    #endif
    }
 
#else
    using type_id = uintptr_t;
 
    // returns uintptr_t instead of type_id to keep PRETTY_FUNCTION shorter
    template <typename T>
    static uintptr_t get()
    {
        // PRETTY_FUNCTION gives a string like:
        // static uintptr_t zserio::detail::TypeIdHolder::get() [T = int]
        // static uintptr_t zserio::detail::TypeIdHolder::get() [with T = int; uintptr_t = xyz]
        static const auto id = calcHashCode(zserio::HASH_SEED, std::string_view(__PRETTY_FUNCTION__));
        return static_cast<uintptr_t>(id);
    }
 
    static bool equals(type_id lhs, type_id rhs)
    {
        return lhs == rhs;
    }
 
#endif
};
 
// Interface for object holders
template <typename ALLOC>
class IHolder
{
public:
    virtual ~IHolder() = default;
    virtual IHolder* clone(const ALLOC& allocator) const = 0;
    virtual IHolder* clone(void* storage) const = 0;
    virtual IHolder* move(const ALLOC& allocator) = 0;
    virtual IHolder* move(void* storage) = 0;
    virtual void destroy(const ALLOC& allocator) = 0;
    virtual bool isType(detail::TypeIdHolder::type_id typeId) const = 0;
};
 
// Base of object holders, holds a value in the std::optional
template <typename T, typename ALLOC>
class HolderBase : public IHolder<ALLOC>
{
public:
    template <typename U>
    void set(U&& value)
    {
        m_typedHolder = std::forward<U>(value);
    }
 
    template <typename... ARGS>
    T& construct(const ALLOC& allocator, ARGS&&... args)
    {
        // in case T is allocator-aware (e.g. std::vector) we need to construct
        // it with parent allocator but because std::optional doesn't support
        // allocators we emulate uses_allocator construction here
        if constexpr (!std::uses_allocator_v<T, ALLOC>)
        {
            return m_typedHolder.emplace(std::forward<ARGS>(args)...);
        }
        else if constexpr (std::is_constructible_v<T, std::allocator_arg_t, const ALLOC&, ARGS...>)
        {
            return m_typedHolder.emplace(std::allocator_arg, allocator, std::forward<ARGS>(args)...);
        }
        else if constexpr (std::is_constructible_v<T, ARGS..., const ALLOC&>)
        {
            return m_typedHolder.emplace(std::forward<ARGS>(args)..., allocator);
        }
        else
        {
            static_assert(always_false<T>::value,
                    "if uses_allocator_v<remove_cv_t<T>, ALLOC> is true, "
                    "T must be constructible with allocator argument");
        }
    }
 
    void setHolder(const std::optional<T>& value)
    {
        m_typedHolder = value;
    }
 
    void setHolder(std::optional<T>&& value)
    {
        m_typedHolder = std::move(value);
    }
 
    T& get()
    {
        return m_typedHolder.value();
    }
 
    const T& get() const
    {
        return m_typedHolder.value();
    }
 
    bool isType(detail::TypeIdHolder::type_id typeId) const override
    {
        return detail::TypeIdHolder::equals(detail::TypeIdHolder::get<T>(), typeId);
    }
 
protected:
    std::optional<T>& getHolder()
    {
        return m_typedHolder;
    }
 
    const std::optional<T>& getHolder() const
    {
        return m_typedHolder;
    }
 
private:
    std::optional<T> m_typedHolder;
};
 
// Holder allocated on heap
template <typename T, typename ALLOC>
class HeapHolder : public HolderBase<T, ALLOC>
{
private:
    struct ConstructTag
    {};
 
public:
    using this_type = HeapHolder<T, ALLOC>;
 
    explicit HeapHolder(ConstructTag) noexcept
    {}
 
    static this_type* create(const ALLOC& allocator)
    {
        using AllocType = RebindAlloc<ALLOC, this_type>;
        using AllocTraits = std::allocator_traits<AllocType>;
 
        AllocType typedAlloc = allocator;
        typename AllocTraits::pointer ptr = AllocTraits::allocate(typedAlloc, 1);
        // this never throws because HeapHolder constructor never throws
        AllocTraits::construct(typedAlloc, std::addressof(*ptr), ConstructTag{});
        return ptr;
    }
 
    IHolder<ALLOC>* clone(const ALLOC& allocator) const override
    {
        this_type* holder = create(allocator);
        holder->setHolder(this->getHolder());
        return holder;
    }
 
    IHolder<ALLOC>* clone(void*) const override
    {
        throw CppRuntimeException("BasicAny: Unexpected clone call.");
    }
 
    IHolder<ALLOC>* move(const ALLOC& allocator) override
    {
        this_type* holder = create(allocator);
        holder->setHolder(std::move(this->getHolder()));
        return holder;
    }
 
    IHolder<ALLOC>* move(void*) override
    {
        throw CppRuntimeException("BasicAny: Unexpected move call.");
    }
 
    void destroy(const ALLOC& allocator) override
    {
        using AllocType = RebindAlloc<ALLOC, this_type>;
        using AllocTraits = std::allocator_traits<AllocType>;
 
        AllocType typedAlloc = allocator;
        AllocTraits::destroy(typedAlloc, this);
        AllocTraits::deallocate(typedAlloc, this, 1);
    }
};
 
// Holder allocated in the in-place storage
template <typename T, typename ALLOC>
class NonHeapHolder : public HolderBase<T, ALLOC>
{
public:
    using this_type = NonHeapHolder<T, ALLOC>;
 
    static this_type* create(void* storage)
    {
        return new (storage) this_type();
    }
 
    IHolder<ALLOC>* clone(const ALLOC&) const override
    {
        throw CppRuntimeException("BasicAny: Unexpected clone call.");
    }
 
    IHolder<ALLOC>* clone(void* storage) const override
    {
        NonHeapHolder* holder = new (storage) NonHeapHolder();
        holder->setHolder(this->getHolder());
        return holder;
    }
 
    IHolder<ALLOC>* move(const ALLOC&) override
    {
        throw CppRuntimeException("BasicAny: Unexpected move call.");
    }
 
    IHolder<ALLOC>* move(void* storage) override
    {
        NonHeapHolder* holder = new (storage) NonHeapHolder();
        holder->setHolder(std::move(this->getHolder()));
        return holder;
    }
 
    void destroy(const ALLOC&) override
    {
        this->~NonHeapHolder();
    }
 
private:
    NonHeapHolder() = default;
};
 
template <typename ALLOC>
union UntypedHolder
{
    // 2 * sizeof(void*) for T + sizeof(void*) for Holder's vptr
    using MaxInPlaceType = std::aligned_storage<3 * sizeof(void*), alignof(void*)>::type;
 
    detail::IHolder<ALLOC>* heap;
    MaxInPlaceType inPlace;
};
 
template <typename T, typename ALLOC>
using has_non_heap_holder = std::integral_constant<bool,
        sizeof(NonHeapHolder<T, ALLOC>) <= sizeof(typename UntypedHolder<ALLOC>::MaxInPlaceType) &&
                std::is_nothrow_move_constructible<T>::value &&
                alignof(T) <= alignof(typename UntypedHolder<ALLOC>::MaxInPlaceType)>;
 
} // namespace detail
 
template <typename ALLOC = std::allocator<uint8_t>>
class BasicAny : public AllocatorHolder<ALLOC>
{
    using AllocTraits = std::allocator_traits<ALLOC>;
    using AllocatorHolder<ALLOC>::get_allocator_ref;
    using AllocatorHolder<ALLOC>::set_allocator;
 
public:
    using AllocatorHolder<ALLOC>::get_allocator;
    using allocator_type = ALLOC;
 
    BasicAny() :
            BasicAny(ALLOC())
    {}
 
    explicit BasicAny(const ALLOC& allocator) :
            AllocatorHolder<ALLOC>(allocator)
    {
        m_untypedHolder.heap = nullptr;
    }
 
    template <typename T,
            typename std::enable_if<!std::is_same<typename std::decay<T>::type, BasicAny>::value &&
                            !std::is_same<typename std::decay<T>::type, ALLOC>::value,
                    int>::type = 0>
    explicit BasicAny(T&& value, const ALLOC& allocator = ALLOC()) :
            AllocatorHolder<ALLOC>(allocator)
    {
        m_untypedHolder.heap = nullptr;
        set(std::forward<T>(value));
    }
 
    ~BasicAny()
    {
        clearHolder();
    }
 
    BasicAny(const BasicAny& other) :
            AllocatorHolder<ALLOC>(
                    AllocTraits::select_on_container_copy_construction(other.get_allocator_ref()))
    {
        copy(other);
    }
 
    BasicAny(const BasicAny& other, const ALLOC& allocator) :
            AllocatorHolder<ALLOC>(allocator)
    {
        copy(other);
    }
 
    BasicAny& operator=(const BasicAny& other)
    {
        if (this != &other)
        {
            // TODO: do not dealloc unless necessary
            clearHolder();
            if constexpr (AllocTraits::propagate_on_container_copy_assignment::value)
            {
                set_allocator(other.get_allocator_ref());
            }
            copy(other);
        }
 
        return *this;
    }
 
    BasicAny(BasicAny&& other) noexcept :
            AllocatorHolder<ALLOC>(std::move(other.get_allocator_ref()))
    {
        move(std::move(other));
    }
 
    BasicAny(BasicAny&& other, const ALLOC& allocator) :
            AllocatorHolder<ALLOC>(allocator)
    {
        move(std::move(other));
    }
 
    BasicAny& operator=(BasicAny&& other)
    {
        if (this != &other)
        {
            clearHolder();
            if constexpr (AllocTraits::propagate_on_container_move_assignment::value)
            {
                set_allocator(std::move(other.get_allocator_ref()));
            }
            move(std::move(other));
        }
 
        return *this;
    }
 
    template <typename T,
            typename std::enable_if<!std::is_same<typename std::decay<T>::type, BasicAny>::value, int>::type =
                    0>
    BasicAny& operator=(T&& value)
    {
        set(std::forward<T>(value));
 
        return *this;
    }
 
    void swap(BasicAny& other)
    {
        if (!m_isInPlace && m_untypedHolder.heap != nullptr && !other.m_isInPlace &&
                other.m_untypedHolder.heap != nullptr && get_allocator_ref() == other.get_allocator_ref())
        {
            std::swap(m_untypedHolder.heap, other.m_untypedHolder.heap);
        }
        else
        {
            BasicAny tmp(std::move(*this), get_allocator_ref());
            move(std::move(other));
            other.move(std::move(tmp));
 
            if constexpr (AllocTraits::propagate_on_container_swap::value)
            {
                using std::swap;
                swap(get_allocator_ref(), other.get_allocator_ref());
            }
        }
    }
 
    void reset()
    {
        clearHolder();
    }
 
    template <typename T>
    void set(T&& value)
    {
        createHolder<typename std::decay<T>::type>()->set(std::forward<T>(value));
    }
 
    template <typename T, typename... ARGS>
    T& emplace(ARGS&&... args)
    {
        return createHolder<typename std::decay<T>::type>()->construct(
                get_allocator_ref(), std::forward<ARGS>(args)...);
    }
 
    template <typename T>
    T* get_if() noexcept
    {
        if (!isType<T>())
        {
            return nullptr;
        }
        // TODO: remove try-catch as part of issue #46
        try
        {
            return &getHolder<T>(detail::has_non_heap_holder<T, ALLOC>())->get();
        }
        catch (const std::exception&)
        {
            return nullptr;
        }
    }
 
    template <typename T>
    const T* get_if() const noexcept
    {
        if (!isType<T>())
        {
            return nullptr;
        }
        // TODO: remove try-catch as part of issue #46
        try
        {
            return &getHolder<T>(detail::has_non_heap_holder<T, ALLOC>())->get();
        }
        catch (const std::exception&)
        {
            return nullptr;
        }
    }
 
    template <typename T>
    T& get()
    {
        checkType<T>();
        return getHolder<T>(detail::has_non_heap_holder<T, ALLOC>())->get();
    }
 
    template <typename T>
    const T& get() const
    {
        checkType<T>();
        return getHolder<T>(detail::has_non_heap_holder<T, ALLOC>())->get();
    }
 
    template <typename T>
    bool isType() const noexcept
    {
        return hasHolder() && getUntypedHolder()->isType(detail::TypeIdHolder::get<T>());
    }
 
    bool hasValue() const noexcept
    {
        return hasHolder();
    }
 
private:
    void copy(const BasicAny& other)
    {
        if (other.m_isInPlace)
        {
            other.getUntypedHolder()->clone(&m_untypedHolder.inPlace);
            m_isInPlace = true;
        }
        else if (other.m_untypedHolder.heap != nullptr)
        {
            m_untypedHolder.heap = other.getUntypedHolder()->clone(get_allocator_ref());
        }
        else
        {
            m_untypedHolder.heap = nullptr;
        }
    }
 
    void move(BasicAny&& other)
    {
        if (other.m_isInPlace)
        {
            other.getUntypedHolder()->move(&m_untypedHolder.inPlace);
            m_isInPlace = true;
            other.clearHolder();
        }
        else if (other.m_untypedHolder.heap != nullptr)
        {
            if (get_allocator_ref() == other.get_allocator_ref())
            {
                // take over the other's storage
                m_untypedHolder.heap = other.m_untypedHolder.heap;
                other.m_untypedHolder.heap = nullptr;
            }
            else
            {
                // cannot steal the storage, allocate our own and move the holder
                m_untypedHolder.heap = other.getUntypedHolder()->move(get_allocator_ref());
                other.clearHolder();
            }
        }
        else
        {
            m_untypedHolder.heap = nullptr;
        }
    }
 
    void clearHolder()
    {
        if (hasHolder())
        {
            getUntypedHolder()->destroy(get_allocator_ref());
            m_isInPlace = false;
            m_untypedHolder.heap = nullptr;
        }
    }
 
    bool hasHolder() const noexcept
    {
        return (m_isInPlace || m_untypedHolder.heap != nullptr);
    }
 
    template <typename T>
    detail::HolderBase<T, ALLOC>* createHolder()
    {
        if (hasHolder())
        {
            if (getUntypedHolder()->isType(detail::TypeIdHolder::get<T>()))
            {
                return getHolder<T>(detail::has_non_heap_holder<T, ALLOC>());
            }
 
            clearHolder();
        }
 
        return createHolderImpl<T>(detail::has_non_heap_holder<T, ALLOC>());
    }
 
    template <typename T>
    detail::HolderBase<T, ALLOC>* createHolderImpl(std::true_type)
    {
        detail::NonHeapHolder<T, ALLOC>* holder =
                detail::NonHeapHolder<T, ALLOC>::create(&m_untypedHolder.inPlace);
        m_isInPlace = true;
        return holder;
    }
 
    template <typename T>
    detail::HolderBase<T, ALLOC>* createHolderImpl(std::false_type)
    {
        detail::HeapHolder<T, ALLOC>* holder = detail::HeapHolder<T, ALLOC>::create(get_allocator_ref());
        m_untypedHolder.heap = holder;
        return holder;
    }
 
    template <typename T>
    void checkType() const
    {
        if (!isType<T>())
        {
            throwBadType();
        }
    }
 
    void throwBadType() const
    {
        throw CppRuntimeException("Bad type in BasicAny");
    }
 
    template <typename T>
    detail::HeapHolder<T, ALLOC>* getHeapHolder() noexcept
    {
        return static_cast<detail::HeapHolder<T, ALLOC>*>(m_untypedHolder.heap);
    }
 
    template <typename T>
    const detail::HeapHolder<T, ALLOC>* getHeapHolder() const noexcept
    {
        return static_cast<detail::HeapHolder<T, ALLOC>*>(m_untypedHolder.heap);
    }
 
    template <typename T>
    detail::NonHeapHolder<T, ALLOC>* getInplaceHolder() noexcept
    {
        return reinterpret_cast<detail::NonHeapHolder<T, ALLOC>*>(&m_untypedHolder.inPlace);
    }
 
    template <typename T>
    const detail::NonHeapHolder<T, ALLOC>* getInplaceHolder() const noexcept
    {
        return reinterpret_cast<const detail::NonHeapHolder<T, ALLOC>*>(&m_untypedHolder.inPlace);
    }
 
    template <typename T>
    detail::HolderBase<T, ALLOC>* getHolder(std::true_type) noexcept
    {
        return static_cast<detail::HolderBase<T, ALLOC>*>(getInplaceHolder<T>());
    }
 
    template <typename T>
    detail::HolderBase<T, ALLOC>* getHolder(std::false_type) noexcept
    {
        return static_cast<detail::HolderBase<T, ALLOC>*>(getHeapHolder<T>());
    }
 
    template <typename T>
    const detail::HolderBase<T, ALLOC>* getHolder(std::true_type) const noexcept
    {
        return static_cast<const detail::HolderBase<T, ALLOC>*>(getInplaceHolder<T>());
    }
 
    template <typename T>
    const detail::HolderBase<T, ALLOC>* getHolder(std::false_type) const noexcept
    {
        return static_cast<const detail::HolderBase<T, ALLOC>*>(getHeapHolder<T>());
    }
 
    detail::IHolder<ALLOC>* getUntypedHolder() noexcept
    {
        return (m_isInPlace)
                ? reinterpret_cast<detail::IHolder<ALLOC>*>(&m_untypedHolder.inPlace)
                : m_untypedHolder.heap;
    }
 
    const detail::IHolder<ALLOC>* getUntypedHolder() const noexcept
    {
        return (m_isInPlace)
                ? reinterpret_cast<const detail::IHolder<ALLOC>*>(&m_untypedHolder.inPlace)
                : m_untypedHolder.heap;
    }
 
    detail::UntypedHolder<ALLOC> m_untypedHolder;
    bool m_isInPlace = false;
};
 
using Any = BasicAny<>;
 
} // namespace zserio
 
#endif // ifndef ZSERIO_ANY_H_INC