Any.h

Go to the documentation of this file.

#ifndef ZSERIO_ANY_H_INC
#define ZSERIO_ANY_H_INC
 
#include <cstddef>
#include <optional>
#include <type_traits>
 
#include "zserio/AllocatorHolder.h"
#include "zserio/CppRuntimeException.h"
#include "zserio/Optional.h"
#include "zserio/RebindAlloc.h"
#include "zserio/Traits.h"
#include "zserio/Types.h"
 
namespace zserio
{
 
namespace detail
{
 
class TypeIdHolder
{
public:
    using type_id = const int*;
 
    template <typename T>
    static type_id get()
    {
        static int currentTypeId;
 
        return &currentTypeId;
    }
};
 
// 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);
    }
 
    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::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 reset()
    {
        clearHolder();
    }
 
    template <typename T>
    void set(T&& value)
    {
        createHolder<typename std::decay<T>::type>()->set(std::forward<T>(value));
    }
 
    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
    {
        return hasHolder() && getUntypedHolder()->isType(detail::TypeIdHolder::get<T>());
    }
 
    bool hasValue() const
    {
        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
    {
        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()
    {
        return static_cast<detail::HeapHolder<T, ALLOC>*>(m_untypedHolder.heap);
    }
 
    template <typename T>
    const detail::HeapHolder<T, ALLOC>* getHeapHolder() const
    {
        return static_cast<detail::HeapHolder<T, ALLOC>*>(m_untypedHolder.heap);
    }
 
    template <typename T>
    detail::NonHeapHolder<T, ALLOC>* getInplaceHolder()
    {
        return reinterpret_cast<detail::NonHeapHolder<T, ALLOC>*>(&m_untypedHolder.inPlace);
    }
 
    template <typename T>
    const detail::NonHeapHolder<T, ALLOC>* getInplaceHolder() const
    {
        return reinterpret_cast<const detail::NonHeapHolder<T, ALLOC>*>(&m_untypedHolder.inPlace);
    }
 
    template <typename T>
    detail::HolderBase<T, ALLOC>* getHolder(std::true_type)
    {
        return static_cast<detail::HolderBase<T, ALLOC>*>(getInplaceHolder<T>());
    }
 
    template <typename T>
    detail::HolderBase<T, ALLOC>* getHolder(std::false_type)
    {
        return static_cast<detail::HolderBase<T, ALLOC>*>(getHeapHolder<T>());
    }
 
    template <typename T>
    const detail::HolderBase<T, ALLOC>* getHolder(std::true_type) const
    {
        return static_cast<const detail::HolderBase<T, ALLOC>*>(getInplaceHolder<T>());
    }
 
    template <typename T>
    const detail::HolderBase<T, ALLOC>* getHolder(std::false_type) const
    {
        return static_cast<const detail::HolderBase<T, ALLOC>*>(getHeapHolder<T>());
    }
 
    detail::IHolder<ALLOC>* getUntypedHolder()
    {
        return (m_isInPlace)
                ? reinterpret_cast<detail::IHolder<ALLOC>*>(&m_untypedHolder.inPlace)
                : m_untypedHolder.heap;
    }
 
    const detail::IHolder<ALLOC>* getUntypedHolder() const
    {
        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