OptionalHolder.h

Go to the documentation of this file.

#ifndef ZSERIO_OPTIONAL_HOLDER_H_INC
#define ZSERIO_OPTIONAL_HOLDER_H_INC
 
#include <type_traits>
 
#include "zserio/CppRuntimeException.h"
#include "zserio/NoInit.h"
#include "zserio/Types.h"
#include "zserio/UniquePtr.h"
 
namespace zserio
{
 
struct NullOptType
{
    constexpr explicit NullOptType(int)
    {}
};
 
constexpr NullOptType NullOpt{int()};
 
struct InPlaceT
{
    constexpr explicit InPlaceT() = default;
};
 
constexpr InPlaceT InPlace{};
 
namespace detail
{
 
template <typename T, typename Derived>
class optional_holder_base
{
public:
    bool operator==(const optional_holder_base& other) const
    {
        if (this == &other)
        {
            return true;
        }
 
        if (getDerived()->hasValue() != other.getDerived()->hasValue())
        {
            return false;
        }
 
        if (getDerived()->hasValue())
        {
            return get() == other.get();
        }
 
        return true;
    }
 
    bool operator<(const optional_holder_base& other) const
    {
        if (getDerived()->hasValue() && other.getDerived()->hasValue())
        {
            return get() < other.get();
        }
 
        return !getDerived()->hasValue() && other.getDerived()->hasValue();
    }
 
    explicit operator bool() const noexcept
    {
        return getDerived()->hasValue();
    }
 
    const T* operator->() const
    {
        return std::addressof(get());
    }
 
    T* operator->()
    {
        return std::addressof(get());
    }
 
    const T& value() const
    {
        return get();
    }
 
    T& value()
    {
        return get();
    }
 
protected:
    void checkHasValue() const
    {
        if (!getDerived()->hasValue())
        {
            throwNonPresentException();
        }
    }
 
private:
    T& get()
    {
        return getDerived()->operator*();
    }
 
    const T& get() const
    {
        return getDerived()->operator*();
    }
 
    Derived* getDerived()
    {
        return static_cast<Derived*>(this);
    }
 
    const Derived* getDerived() const
    {
        return static_cast<const Derived*>(this);
    }
 
    void throwNonPresentException() const
    {
        throw CppRuntimeException("Trying to access value of non-present optional field!");
    }
};
 
template <typename T, typename ALLOC>
class heap_optional_holder : public optional_holder_base<T, heap_optional_holder<T, ALLOC>>
{
public:
    using allocator_type = ALLOC;
    using allocator_traits = std::allocator_traits<allocator_type>;
    using value_type = T;
    using storage_type = zserio::unique_ptr<T, allocator_type>;
 
    allocator_type get_allocator() const
    {
        return m_storage.get_deleter().get_allocator();
    }
 
    explicit constexpr heap_optional_holder(const allocator_type& allocator = allocator_type()) noexcept :
            m_storage(nullptr, allocator)
    {}
 
    constexpr heap_optional_holder(NullOptType, const allocator_type& allocator = allocator_type()) noexcept :
            m_storage(nullptr, allocator)
    {}
 
    heap_optional_holder(const T& val, const allocator_type& allocator = allocator_type()) :
            m_storage(zserio::allocate_unique<T, allocator_type>(allocator, val))
    {}
 
    heap_optional_holder(T&& val, const allocator_type& allocator = allocator_type()) :
            m_storage(zserio::allocate_unique<T, allocator_type>(allocator, std::move(val)))
    {}
 
    // called from allocatorPropagatingCopy
    template <typename U = T,
            typename std::enable_if<std::is_constructible<U, NoInitT, U>::value, int>::type = 0>
    heap_optional_holder(NoInitT, T&& val, const allocator_type& allocator = allocator_type()) :
            m_storage(zserio::allocate_unique<T, allocator_type>(allocator, NoInit, std::move(val)))
    {}
 
    template <typename... U>
    explicit heap_optional_holder(const allocator_type& allocator, U&&... parameters) :
            m_storage(zserio::allocate_unique<T, allocator_type>(allocator, std::forward<U>(parameters)...))
    {}
 
    ~heap_optional_holder() = default;
 
    heap_optional_holder(const heap_optional_holder& other) :
            m_storage(copy_initialize(
                    other, allocator_traits::select_on_container_copy_construction(other.get_allocator())))
    {}
 
    template <typename U = T,
            typename std::enable_if<std::is_constructible<U, NoInitT, U>::value, int>::type = 0>
    heap_optional_holder(NoInitT, const heap_optional_holder& other) :
            m_storage(copy_initialize(NoInit, other,
                    allocator_traits::select_on_container_copy_construction(other.get_allocator())))
    {}
 
    heap_optional_holder(const heap_optional_holder& other, const allocator_type& allocator) :
            m_storage(copy_initialize(other, allocator))
    {}
 
    heap_optional_holder(heap_optional_holder&& other) noexcept = default;
 
    template <typename U = T,
            typename std::enable_if<std::is_constructible<U, NoInitT, U>::value, int>::type = 0>
    heap_optional_holder(NoInitT, heap_optional_holder&& other) :
            m_storage(move_initialize(NoInit, std::move(other), other.get_allocator()))
    {}
 
    heap_optional_holder(heap_optional_holder&& other, const allocator_type& allocator) :
            m_storage(move_initialize(std::move(other), allocator))
    {}
 
    heap_optional_holder& operator=(const heap_optional_holder& other)
    {
        if (this == &other)
        {
            return *this;
        }
 
        m_storage = copy_initialize(other,
                select_allocator(other.get_allocator(),
                        typename allocator_traits::propagate_on_container_copy_assignment()));
 
        return *this;
    }
 
    template <typename U = T,
            typename std::enable_if<std::is_constructible<U, NoInitT, U>::value, int>::type = 0>
    heap_optional_holder& assign(NoInitT, const heap_optional_holder& other)
    {
        if (this == &other)
        {
            return *this;
        }
 
        m_storage = copy_initialize(NoInit, other,
                select_allocator(other.get_allocator(),
                        typename allocator_traits::propagate_on_container_copy_assignment()));
 
        return *this;
    }
 
    heap_optional_holder& operator=(heap_optional_holder&& other)
    {
        if (this == &other)
        {
            return *this;
        }
 
        m_storage = move_initialize(std::move(other),
                select_allocator(other.get_allocator(),
                        typename allocator_traits::propagate_on_container_move_assignment()));
 
        return *this;
    }
 
    template <typename U = T,
            typename std::enable_if<std::is_constructible<U, NoInitT, U>::value, int>::type = 0>
    heap_optional_holder& assign(NoInitT, heap_optional_holder&& other)
    {
        if (this == &other)
        {
            return *this;
        }
 
        m_storage = move_initialize(NoInit, std::move(other),
                select_allocator(other.get_allocator(),
                        typename allocator_traits::propagate_on_container_move_assignment()));
 
        return *this;
    }
 
    heap_optional_holder& operator=(const T& val)
    {
        set(val);
 
        return *this;
    }
 
    heap_optional_holder& operator=(T&& val)
    {
        set(std::move(val));
 
        return *this;
    }
 
    void reset() noexcept
    {
        m_storage.reset();
    }
 
    bool hasValue() const noexcept
    {
        return static_cast<bool>(m_storage);
    }
 
    const T& operator*() const
    {
        this->checkHasValue();
        return *m_storage.get();
    }
 
    T& operator*()
    {
        this->checkHasValue();
        return *m_storage.get();
    }
 
private:
    allocator_type select_allocator(allocator_type other_allocator, std::true_type)
    {
        return other_allocator;
    }
 
    allocator_type select_allocator(allocator_type, std::false_type)
    {
        return get_allocator(); // current allocator
    }
 
    template <typename U = T>
    void set(U&& val)
    {
        reset();
        m_storage = zserio::allocate_unique<T, allocator_type>(get_allocator(), std::forward<U>(val));
    }
 
    static storage_type copy_initialize(const heap_optional_holder& other, const allocator_type& allocator)
    {
        if (other.hasValue())
        {
            return zserio::allocate_unique<T, allocator_type>(allocator, *other);
        }
        else
        {
            return storage_type(nullptr, allocator);
        }
    }
 
    static storage_type copy_initialize(
            NoInitT, const heap_optional_holder& other, const allocator_type& allocator)
    {
        if (other.hasValue())
        {
            return zserio::allocate_unique<T, allocator_type>(allocator, NoInit, *other);
        }
        else
        {
            return storage_type(nullptr, allocator);
        }
    }
 
    static storage_type move_initialize(heap_optional_holder&& other, const allocator_type& allocator)
    {
        if (other.hasValue())
        {
            if (allocator == other.get_allocator())
            {
                return std::move(other.m_storage);
            }
 
            return zserio::allocate_unique<T, allocator_type>(allocator, std::move(*other));
        }
        else
        {
            return storage_type(nullptr, allocator);
        }
    }
 
    static storage_type move_initialize(NoInitT, heap_optional_holder&& other, const allocator_type& allocator)
    {
        if (other.hasValue())
        {
            if (allocator == other.get_allocator())
            {
                return std::move(other.m_storage);
            }
 
            return zserio::allocate_unique<T, allocator_type>(allocator, NoInit, std::move(*other));
        }
        else
        {
            return storage_type(nullptr, allocator);
        }
    }
 
    storage_type m_storage;
};
 
template <typename T>
class in_place_storage
{
public:
    in_place_storage() = default;
 
    ~in_place_storage() = default;
 
    in_place_storage(const in_place_storage&) = delete;
    in_place_storage& operator=(const in_place_storage&) = delete;
    in_place_storage(in_place_storage&& other) = delete;
 
    in_place_storage& operator=(in_place_storage&& other) noexcept(std::is_nothrow_move_constructible<T>::value)
    {
        new (&m_inPlace) T(std::move(*other.getObject()));
        other.getObject()->~T(); // ensure that destructor of object in original storage is called
 
        return *this;
    }
 
    in_place_storage& assign(NoInitT, in_place_storage&& other) noexcept(
            std::is_nothrow_move_constructible<T>::value)
    {
        new (&m_inPlace) T(NoInit, std::move(*other.getObject()));
        other.getObject()->~T(); // ensure that destructor of object in original storage is called
 
        return *this;
    }
 
    void* getStorage()
    {
        return &m_inPlace;
    }
 
    T* getObject()
    {
        return reinterpret_cast<T*>(&m_inPlace);
    }
 
    const T* getObject() const
    {
        return reinterpret_cast<const T*>(&m_inPlace);
    }
 
private:
    // Caution!
    // We use static constants as a WORKAROUND for a GCC 8/9 bug observed when cross-compiling with -m32 flag.
    // The compilers somehow spoils the aligned storage when alignof(T) is used directly as the template
    // argument which leads to "*** stack smashing detected ***" error (as observed in some language tests).
    static constexpr size_t SIZEOF_T = sizeof(T);
    static constexpr size_t ALIGNOF_T = alignof(T);
    using AlignedStorage = typename std::aligned_storage<SIZEOF_T, ALIGNOF_T>::type;
    AlignedStorage m_inPlace;
};
 
template <typename T>
class inplace_optional_holder : public optional_holder_base<T, inplace_optional_holder<T>>
{
public:
    using value_type = T;
 
    constexpr inplace_optional_holder() noexcept = default;
 
    constexpr inplace_optional_holder(NullOptType) noexcept
    {}
 
    inplace_optional_holder(const T& val)
    {
        new (m_storage.getStorage()) T(val);
        m_hasValue = true;
    }
 
    inplace_optional_holder(T&& val) noexcept(std::is_nothrow_constructible<T>::value)
    {
        new (m_storage.getStorage()) T(std::move(val));
        m_hasValue = true;
    }
 
    // called from allocatorPropagatingCopy
    template <typename U = T,
            typename std::enable_if<std::is_constructible<U, NoInitT, U>::value, int>::type = 0>
    inplace_optional_holder(NoInitT, T&& val) noexcept(std::is_nothrow_move_constructible<T>::value)
    {
        new (m_storage.getStorage()) T(NoInit, std::move(val));
        m_hasValue = true;
    }
 
    inplace_optional_holder(const inplace_optional_holder& other)
    {
        if (other.hasValue())
        {
            new (m_storage.getStorage()) T(*other.m_storage.getObject());
            m_hasValue = true;
        }
    }
 
    template <typename U = T,
            typename std::enable_if<std::is_constructible<U, NoInitT, U>::value, int>::type = 0>
    inplace_optional_holder(NoInitT, const inplace_optional_holder& other)
    {
        if (other.hasValue())
        {
            new (m_storage.getStorage()) T(NoInit, *other.m_storage.getObject());
            m_hasValue = true;
        }
    }
 
    inplace_optional_holder(inplace_optional_holder&& other) noexcept(
            std::is_nothrow_move_assignable<in_place_storage<T>>::value)
    {
        if (other.hasValue())
        {
            m_storage = std::move(other.m_storage);
            other.m_hasValue = false;
            m_hasValue = true;
        }
    }
 
    template <typename U = T,
            typename std::enable_if<std::is_constructible<U, NoInitT, U>::value, int>::type = 0>
    inplace_optional_holder(NoInitT, inplace_optional_holder&& other) noexcept(
            std::is_nothrow_move_assignable<in_place_storage<T>>::value)
    {
        if (other.hasValue())
        {
            m_storage.assign(NoInit, std::move(other.m_storage));
            other.m_hasValue = false;
            m_hasValue = true;
        }
    }
 
    template <typename... U>
    explicit inplace_optional_holder(InPlaceT, U&&... parameters)
    {
        new (m_storage.getStorage()) T(std::forward<U>(parameters)...);
        m_hasValue = true;
    }
 
    ~inplace_optional_holder()
    {
        reset();
    }
 
    inplace_optional_holder& operator=(const inplace_optional_holder& other)
    {
        if (this != &other)
        {
            reset();
            if (other.hasValue())
            {
                new (m_storage.getStorage()) T(*other.m_storage.getObject());
                m_hasValue = true;
            }
        }
 
        return *this;
    }
 
    template <typename U = T,
            typename std::enable_if<std::is_constructible<U, NoInitT, U>::value, int>::type = 0>
    inplace_optional_holder& assign(NoInitT, const inplace_optional_holder& other)
    {
        if (this != &other)
        {
            reset();
            if (other.hasValue())
            {
                new (m_storage.getStorage()) T(NoInit, *other.m_storage.getObject());
                m_hasValue = true;
            }
        }
 
        return *this;
    }
 
    inplace_optional_holder& operator=(inplace_optional_holder&& other) noexcept(
            std::is_nothrow_move_assignable<in_place_storage<T>>::value)
    {
        if (this != &other)
        {
            reset();
            if (other.hasValue())
            {
                m_storage = std::move(other.m_storage);
                other.m_hasValue = false;
                m_hasValue = true;
            }
        }
 
        return *this;
    }
 
    template <typename U = T,
            typename std::enable_if<std::is_constructible<U, NoInitT, U>::value, int>::type = 0>
    inplace_optional_holder& assign(NoInitT, inplace_optional_holder&& other) noexcept(
            std::is_nothrow_move_assignable<in_place_storage<T>>::value)
    {
        if (this != &other)
        {
            reset();
            if (other.hasValue())
            {
                m_storage.assign(NoInit, std::move(other.m_storage));
                other.m_hasValue = false;
                m_hasValue = true;
            }
        }
 
        return *this;
    }
 
    inplace_optional_holder& operator=(const T& val)
    {
        set(val);
 
        return *this;
    }
 
    inplace_optional_holder& operator=(T&& val)
    {
        set(std::move(val));
 
        return *this;
    }
 
    void reset() noexcept
    {
        if (hasValue())
        {
            m_storage.getObject()->~T();
            m_hasValue = false;
        }
    }
 
    bool hasValue() const noexcept
    {
        return m_hasValue;
    }
 
    const T& operator*() const
    {
        this->checkHasValue();
        return *m_storage.getObject();
    }
 
    T& operator*()
    {
        this->checkHasValue();
        return *m_storage.getObject();
    }
 
private:
    template <typename U = T>
    void set(U&& val)
    {
        reset();
        new (m_storage.getStorage()) T(std::forward<U>(val));
        m_hasValue = true;
    }
 
    in_place_storage<T> m_storage;
    bool m_hasValue = false;
};
 
} // namespace detail
 
// Be aware that if Inplace/HeapOptionalHolder is defined by typename, C++ compiler will have problem with
// template function overload, see HashCodeUtil.h (overloads for objects and for Inplace/HeapOptionalHolder).
template <typename T>
using InplaceOptionalHolder = detail::inplace_optional_holder<T>;
 
template <typename T, typename ALLOC = std::allocator<T>>
using HeapOptionalHolder = detail::heap_optional_holder<T, ALLOC>;
 
} // namespace zserio
 
#endif // ifndef ZSERIO_OPTIONAL_HOLDER_H_INC