Optional.h

Go to the documentation of this file.

#ifndef ZSERIO_OPTIONAL_H_INC
#define ZSERIO_OPTIONAL_H_INC
 
#include <optional>
 
#include "zserio/AllocatorHolder.h"
#include "zserio/CppRuntimeException.h"
#include "zserio/HashCodeUtil.h"
#include "zserio/Traits.h"
#include "zserio/View.h"
 
namespace zserio
{
 
template <typename ALLOC, typename T>
class BasicOptional;
 
namespace detail
{
 
template <typename T, bool = (sizeof(T) > 3 * sizeof(void*))>
struct is_optional_big : std::false_type
{};
 
template <typename T>
struct is_optional_big<T, true> : std::true_type
{};
 
template <typename T, typename = void>
struct is_recursive : std::false_type
{};
 
template <typename T>
struct is_recursive<T, std::void_t<typename T::IS_RECURSIVE>> : std::true_type
{};
 
template <typename T, bool = is_recursive<T>::value>
struct is_optional_heap_allocated_impl : is_optional_big<T>::type
{};
 
template <typename T>
struct is_optional_heap_allocated_impl<T, true> : std::true_type
{};
 
template <typename T>
struct is_optional_heap_allocated : is_optional_heap_allocated_impl<T>
{};
 
template <typename T>
struct is_optional_heap_allocated<View<T>> : std::false_type
{};
 
template <typename T>
constexpr bool is_optional_heap_allocated_v = is_optional_heap_allocated<T>::value;
 
template <typename T, bool heap = is_optional_heap_allocated_v<T>>
struct optional_element
{
    using type = T;
};
 
template <typename T>
struct optional_element<T, true>
{
    using type = T*;
};
 
template <typename T>
struct is_optional : std::false_type
{};
 
template <typename A, typename T>
struct is_optional<BasicOptional<A, T>> : std::true_type
{};
 
template <typename T>
constexpr bool is_optional_v = is_optional<T>::value;
 
} // namespace detail
 
class BadOptionalAccess : public CppRuntimeException
{
public:
    using CppRuntimeException::CppRuntimeException;
 
    ~BadOptionalAccess() override;
};
 
template <typename ALLOC, typename T>
class BasicOptional : public AllocatorHolder<ALLOC>
{
    using AllocTraits = std::allocator_traits<ALLOC>;
    using AllocatorHolder<ALLOC>::set_allocator;
 
public:
    using AllocatorHolder<ALLOC>::get_allocator_ref;
    using allocator_type = ALLOC;
    using OptionalType = std::optional<typename detail::optional_element<T>::type>;
 
    constexpr BasicOptional() noexcept :
            BasicOptional(ALLOC())
    {}
 
    constexpr BasicOptional(std::nullopt_t, const ALLOC& allocator = {}) noexcept :
            BasicOptional(allocator)
    {}
 
    constexpr BasicOptional(const T& value, const ALLOC& allocator = {}) :
            BasicOptional(std::in_place, allocator, value)
    {}
 
    constexpr BasicOptional(T&& value, const ALLOC& allocator = {}) :
            BasicOptional(std::in_place, allocator, std::move(value))
    {}
 
    explicit constexpr BasicOptional(const ALLOC& allocator) :
            AllocatorHolder<ALLOC>(allocator)
    {}
 
    template <typename... ARGS, typename TT = T,
            std::enable_if_t<!detail::is_optional_heap_allocated_v<TT>>* = nullptr,
            std::enable_if_t<!is_first_allocator<ARGS...>::value>* = nullptr>
    explicit constexpr BasicOptional(std::in_place_t, ARGS&&... args) :
            m_data(std::in_place, std::forward<ARGS>(args)...)
    {}
 
    template <typename... ARGS, typename TT = T,
            std::enable_if_t<!detail::is_optional_heap_allocated_v<TT>>* = nullptr>
    constexpr BasicOptional(std::in_place_t, const ALLOC& allocator, ARGS&&... args) :
            AllocatorHolder<ALLOC>(allocator),
            m_data(std::in_place, std::forward<ARGS>(args)...)
    {}
 
    template <typename... ARGS, typename TT = T,
            std::enable_if_t<detail::is_optional_heap_allocated_v<TT>>* = nullptr>
    constexpr BasicOptional(std::in_place_t, const ALLOC& allocator, ARGS&&... args) :
            AllocatorHolder<ALLOC>(allocator),
            m_data(std::in_place, allocateValue(std::forward<ARGS>(args)...))
    {}
 
    template <typename... ARGS, typename TT = T,
            std::enable_if_t<detail::is_optional_heap_allocated_v<TT>>* = nullptr,
            std::enable_if_t<!is_first_allocator<ARGS...>::value>* = nullptr>
    explicit constexpr BasicOptional(std::in_place_t, ARGS&&... args) :
            m_data(std::in_place, allocateValue(std::forward<ARGS>(args)...))
    {}
 
    ~BasicOptional()
    {
        clear();
    }
 
    constexpr BasicOptional(const BasicOptional& other) :
            AllocatorHolder<ALLOC>(
                    AllocTraits::select_on_container_copy_construction(other.get_allocator_ref()))
    {
        copy(other);
    }
 
    template <typename U>
    constexpr BasicOptional(const BasicOptional<ALLOC, U>& other) :
            AllocatorHolder<ALLOC>(
                    AllocTraits::select_on_container_copy_construction(other.get_allocator_ref()))
    {
        copy(other);
    }
 
    constexpr BasicOptional(const BasicOptional& other, const ALLOC& allocator) :
            AllocatorHolder<ALLOC>(allocator)
    {
        copy(other);
    }
 
    template <typename A, typename U>
    constexpr BasicOptional(const BasicOptional<A, U>& other, const ALLOC& allocator) :
            AllocatorHolder<ALLOC>(allocator)
    {
        copy(other);
    }
 
    constexpr BasicOptional& operator=(const BasicOptional& other)
    {
        if (this != &other)
        {
            clear();
            if constexpr (AllocTraits::propagate_on_container_copy_assignment::value)
            {
                set_allocator(other.get_allocator_ref());
            }
            copy(other);
        }
 
        return *this;
    }
 
    template <typename A, typename U>
    BasicOptional& operator=(const BasicOptional<A, U>& other)
    {
        clear();
        if constexpr (AllocTraits::propagate_on_container_copy_assignment::value)
        {
            set_allocator(other.get_allocator_ref());
        }
        copy(other);
 
        return *this;
    }
 
    BasicOptional& operator=(std::nullopt_t)
    {
        reset();
        return *this;
    }
 
    template <typename U = T,
            std::enable_if_t<!detail::is_optional_v<std::decay_t<U>> &&
                    !(std::is_same_v<T, std::decay_t<U>> && std::is_scalar_v<U>)>* = nullptr>
    BasicOptional& operator=(U&& value)
    {
        emplace(std::forward<U>(value));
        return *this;
    }
 
    BasicOptional(BasicOptional&& other) :
            AllocatorHolder<ALLOC>(std::move(other.get_allocator_ref()))
    {
        move(std::move(other));
    }
 
    BasicOptional(BasicOptional&& other, const ALLOC& allocator) :
            AllocatorHolder<ALLOC>(allocator)
    {
        move(std::move(other));
    }
 
    BasicOptional& operator=(BasicOptional&& other)
    {
        if (this != &other)
        {
            clear();
            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 U>
    constexpr BasicOptional(BasicOptional<ALLOC, U>&& other) :
            AllocatorHolder<ALLOC>(std::move(other.get_allocator_ref()))
    {
        move(std::move(other));
    }
 
    template <typename U>
    constexpr BasicOptional(BasicOptional<ALLOC, U>&& other, const ALLOC& allocator) :
            AllocatorHolder<ALLOC>(allocator)
    {
        move(std::move(other));
    }
 
    template <typename U>
    BasicOptional& operator=(BasicOptional<ALLOC, U>&& other)
    {
        static_assert(!std::is_same_v<T, U>);
 
        clear();
        if constexpr (AllocTraits::propagate_on_container_move_assignment::value)
        {
            set_allocator(std::move(other.get_allocator_ref()));
        }
        move(std::move(other));
        return *this;
    }
 
    constexpr bool has_value() const noexcept
    {
        if (!m_data.has_value())
        {
            return false;
        }
        if constexpr (detail::is_optional_heap_allocated_v<T>)
        {
            if (!m_data.value())
            {
                return false;
            }
        }
        return true;
    }
 
    void reset()
    {
        clear();
        m_data.reset();
    }
 
    void swap(BasicOptional& other)
    {
        m_data.swap(other.m_data);
        if constexpr (AllocTraits::propagate_on_container_swap::value)
        {
            using std::swap;
            swap(get_allocator_ref(), other.get_allocator_ref());
        }
    }
 
    constexpr explicit operator bool() const noexcept
    {
        return has_value();
    }
 
    template <typename... ARGS>
    T& emplace(ARGS&&... args)
    {
        clear();
        if constexpr (detail::is_optional_heap_allocated_v<T>)
        {
            T* ptr = allocateValue(std::forward<ARGS>(args)...);
            return *m_data.emplace(ptr);
        }
        else
        {
            return m_data.emplace(std::forward<ARGS>(args)...);
        }
    }
 
    constexpr T& value() &
    {
        if (!has_value())
        {
            throw BadOptionalAccess("Optional is empty");
        }
        if constexpr (detail::is_optional_heap_allocated_v<T>)
        {
            return *m_data.value();
        }
        else
        {
            return m_data.value();
        }
    }
 
    constexpr T&& value() &&
    {
        return std::move(value());
    }
 
    constexpr const T& value() const&
    {
        if (!has_value())
        {
            throw BadOptionalAccess("Optional is empty");
        }
        if constexpr (detail::is_optional_heap_allocated_v<T>)
        {
            return *m_data.value();
        }
        else
        {
            return m_data.value();
        }
    }
 
    constexpr const T&& value() const&&
    {
        return std::move(value());
    }
 
    T& operator*() &
    {
        return value();
    }
 
    T&& operator*() &&
    {
        return std::move(value());
    }
 
    const T& operator*() const&
    {
        return value();
    }
 
    const T&& operator*() const&&
    {
        return std::move(value());
    }
 
    T* operator->()
    {
        return &value();
    }
 
    const T* operator->() const
    {
        return &value();
    }
 
    template <typename U>
    T value_or(U&& def)
    {
        if (!has_value())
        {
            return static_cast<T>(std::forward<U>(def));
        }
        return value();
    }
 
    template <typename U>
    T value_or(U&& def) const
    {
        if (!has_value())
        {
            return static_cast<T>(std::forward<U>(def));
        }
        return value();
    }
 
private:
    // enables move(BasicOptional<ALLOC, U>&&) implementation to access m_data
    template <typename A, typename U>
    friend class BasicOptional;
 
    template <typename... ARGS>
    T* allocateValue(ARGS&&... args)
    {
        using MyAllocType = RebindAlloc<ALLOC, T>;
        using MyAllocTraits = std::allocator_traits<MyAllocType>;
        MyAllocType typedAlloc = get_allocator_ref();
        auto ptr = MyAllocTraits::allocate(typedAlloc, 1);
        try
        {
            MyAllocTraits::construct(typedAlloc, std::addressof(*ptr), std::forward<ARGS>(args)...);
        }
        catch (...)
        {
            MyAllocTraits::deallocate(typedAlloc, ptr, 1);
            throw;
        }
        return ptr;
    }
 
    // same as for std::Optional throwing dtors are not supported see
    // https://stackoverflow.com/questions/78602733/should-stdOptional-be-nothrow-destructible-when-its-alternative-has-potentially
    void destroyValue(T* ptr)
    {
        if (ptr)
        {
            using MyAllocType = RebindAlloc<ALLOC, T>;
            using MyAllocTraits = std::allocator_traits<MyAllocType>;
            MyAllocType typedAlloc = get_allocator_ref();
            MyAllocTraits::destroy(typedAlloc, ptr);
            MyAllocTraits::deallocate(typedAlloc, ptr, 1);
        }
    }
 
    template <typename A, typename U>
    void copy(const BasicOptional<A, U>& other)
    {
        // assumes this holder is cleared
 
        if (!other.has_value())
        {
            reset();
        }
        else
        {
            emplace(other.value());
        }
    }
 
    void move(BasicOptional&& other)
    {
        // assumes this holder is cleared
 
        if (!other.has_value())
        {
            reset();
        }
        else
        {
            if constexpr (detail::is_optional_heap_allocated_v<T>)
            {
                if (get_allocator_ref() == other.get_allocator_ref())
                {
                    // non-standard optimization to reuse memory from the same resource
                    // note that other will be unset after move in this case
                    auto& ptr = other.m_data.value();
                    m_data.emplace(ptr);
                    ptr = nullptr;
                }
                else
                {
                    auto& value = *other.m_data.value();
                    T* ptr = allocateValue(std::move(value));
                    m_data.emplace(ptr);
                }
            }
            else // not on heap
            {
                auto& value = other.m_data.value();
                m_data.emplace(std::move(value));
            }
        }
    }
 
    template <typename U>
    void move(BasicOptional<ALLOC, U>&& other)
    {
        // assumes this holder is cleared
        static_assert(!std::is_same_v<T, U>);
 
        if (!other.has_value())
        {
            reset();
        }
        else
        {
            if constexpr (detail::is_optional_heap_allocated_v<T> && detail::is_optional_heap_allocated_v<U>)
            {
                auto& value = *other.m_data.value();
                T* ptr = allocateValue(std::move(value));
                m_data.emplace(ptr);
            }
            else if constexpr (detail::is_optional_heap_allocated_v<T>) // only T on heap
            {
                auto& value = other.m_data.value();
                T* ptr = allocateValue(std::move(value));
                m_data.emplace(ptr);
            }
            else if constexpr (detail::is_optional_heap_allocated_v<U>) // only U is on heap
            {
                auto& value = *other.m_data.value();
                m_data.emplace(std::move(value));
            }
            else // both not on heap
            {
                auto& value = other.m_data.value();
                m_data.emplace(std::move(value));
            }
        }
    }
 
    void clear()
    {
        if (!has_value())
        {
            return;
        }
        if constexpr (detail::is_optional_heap_allocated_v<T>)
        {
            auto& ptr = m_data.value();
            destroyValue(ptr);
            ptr = nullptr;
        }
    }
 
    OptionalType m_data;
};
 
// Using declarations
 
template <typename T>
using Optional = BasicOptional<std::allocator<uint8_t>, T>;
 
template <typename ALLOC, typename T>
uint32_t calcHashCode(uint32_t seed, const BasicOptional<ALLOC, T>& opt)
{
    uint32_t result = seed;
    if (opt)
    {
        result = calcHashCode(result, *opt);
    }
    return result;
}
 
template <typename T>
constexpr auto make_optional(T&& value)
{
    return Optional<std::decay_t<T>>(std::forward<T>(value));
}
 
template <typename T, typename... ARGS>
constexpr Optional<T> make_optional(ARGS&&... args)
{
    return Optional<T>(std::in_place, std::forward<ARGS>(args)...);
}
 
template <typename A1, typename T, typename A2, typename U>
constexpr bool operator==(const BasicOptional<A1, T>& first, const BasicOptional<A2, U>& second)
{
    if (first.has_value() && second.has_value())
    {
        return first.value() == second.value();
    }
    return first.has_value() == second.has_value();
}
 
template <typename A, typename T>
constexpr bool operator==(const BasicOptional<A, T>& opt, std::nullopt_t)
{
    return !opt.has_value();
}
 
template <typename A, typename T>
constexpr bool operator==(std::nullopt_t, const BasicOptional<A, T>& opt)
{
    return !opt.has_value();
}
 
template <typename A, typename T, typename U>
constexpr bool operator==(const BasicOptional<A, T>& opt, const U& value)
{
    return opt.has_value() && opt.value() == value;
}
 
template <typename A, typename T, typename U>
constexpr bool operator==(const U& value, const BasicOptional<A, T>& opt)
{
    return opt.has_value() && opt.value() == value;
}
 
template <typename A1, typename T, typename A2, typename U>
constexpr bool operator!=(const BasicOptional<A1, T>& first, const BasicOptional<A2, U>& second)
{
    return !(first == second);
}
 
template <typename A, typename T>
constexpr bool operator!=(const BasicOptional<A, T>& opt, std::nullopt_t)
{
    return !(opt == std::nullopt);
}
 
template <typename A, typename T>
constexpr bool operator!=(std::nullopt_t, const BasicOptional<A, T>& opt)
{
    return !(std::nullopt == opt);
}
 
template <typename A, typename T, typename U>
constexpr bool operator!=(const BasicOptional<A, T>& opt, const U& value)
{
    return !(opt == value);
}
 
template <typename A, typename T, typename U>
constexpr bool operator!=(const U& value, const BasicOptional<A, T>& opt)
{
    return !(value == opt);
}
 
template <typename A1, typename T, typename A2, typename U>
constexpr bool operator<(const BasicOptional<A1, T>& first, const BasicOptional<A2, U>& second)
{
    if (first.has_value() && second.has_value())
    {
        return first.value() < second.value();
    }
    return first.has_value() < second.has_value();
}
 
template <typename A, typename T>
constexpr bool operator<(const BasicOptional<A, T>&, std::nullopt_t)
{
    return false;
}
 
template <typename A, typename T>
constexpr bool operator<(std::nullopt_t, const BasicOptional<A, T>& opt)
{
    return opt.has_value();
}
 
template <typename A, typename T, typename U>
constexpr bool operator<(const BasicOptional<A, T>& opt, const U& value)
{
    return !opt.has_value() || opt.value() < value;
}
 
template <typename A, typename T, typename U>
constexpr bool operator<(const U& value, const BasicOptional<A, T>& opt)
{
    return opt.has_value() && value < opt.value();
}
 
template <typename A1, typename T, typename A2, typename U>
constexpr bool operator>(const BasicOptional<A1, T>& first, const BasicOptional<A2, U>& second)
{
    if (first.has_value() && second.has_value())
    {
        return first.value() > second.value();
    }
    return first.has_value() > second.has_value();
}
 
template <typename A, typename T>
constexpr bool operator>(const BasicOptional<A, T>& opt, std::nullopt_t)
{
    return opt.has_value();
}
 
template <typename A, typename T>
constexpr bool operator>(std::nullopt_t, const BasicOptional<A, T>&)
{
    return false;
}
 
template <typename A, typename T, typename U>
constexpr bool operator>(const BasicOptional<A, T>& opt, const U& value)
{
    return opt.has_value() && opt.value() > value;
}
 
template <typename A, typename T, typename U>
constexpr bool operator>(const U& value, const BasicOptional<A, T>& opt)
{
    return !opt.has_value() || value > opt.value();
}
 
template <typename A1, typename T, typename A2, typename U>
constexpr bool operator<=(const BasicOptional<A1, T>& first, const BasicOptional<A2, U>& second)
{
    return !(first > second);
}
 
template <typename A, typename T>
constexpr bool operator<=(const BasicOptional<A, T>& opt, std::nullopt_t)
{
    return !(opt > std::nullopt);
}
 
template <typename A, typename T>
constexpr bool operator<=(std::nullopt_t, const BasicOptional<A, T>& opt)
{
    return !(std::nullopt > opt);
}
 
template <typename A, typename T, typename U>
constexpr bool operator<=(const BasicOptional<A, T>& opt, const U& value)
{
    return !(opt > value);
}
 
template <typename A, typename T, typename U>
constexpr bool operator<=(const U& value, const BasicOptional<A, T>& opt)
{
    return !(value > opt);
}
 
template <typename A1, typename T, typename A2, typename U>
constexpr bool operator>=(const BasicOptional<A1, T>& first, const BasicOptional<A2, U>& second)
{
    return !(first < second);
}
 
template <typename A, typename T>
constexpr bool operator>=(const BasicOptional<A, T>& opt, std::nullopt_t)
{
    return !(opt < std::nullopt);
}
 
template <typename A, typename T>
constexpr bool operator>=(std::nullopt_t, const BasicOptional<A, T>& opt)
{
    return !(std::nullopt < opt);
}
 
template <typename A, typename T, typename U>
constexpr bool operator>=(const BasicOptional<A, T>& opt, const U& value)
{
    return !(opt < value);
}
 
template <typename A, typename T, typename U>
constexpr bool operator>=(const U& value, const BasicOptional<A, T>& opt)
{
    return !(value < opt);
}
 
} // namespace zserio
 
namespace std
{
 
template <typename ALLOC, typename T>
struct hash<zserio::BasicOptional<ALLOC, T>>
{
    size_t operator()(const zserio::BasicOptional<ALLOC, T>& opt) const
    {
        return zserio::calcHashCode(zserio::HASH_SEED, opt);
    }
};
 
} // namespace std
 
#endif // ZSERIO_OPTIONAL_H_INC