SbeOptional.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is
// protected by copyright law and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable
// OnixS Software Services Agreement (the Agreement) and Customer end user license
// agreements granting a non-assignable, non-transferable and non-exclusive license
// to use the software for it's own data processing purposes under the terms defined
// in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or
// reproduction of any part of this source code or associated reference material
// to any other location for further reproduction or redistribution, and any
// amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in
// accordance with the terms of the Agreement is a violation of copyright law.
//
 
#pragma once
 
#include <OnixS/ICE/BOE/ABI.h>
#include <OnixS/ICE/BOE/messaging/Aliases.h>
#include <OnixS/ICE/BOE/messaging/StrRef.h>
#include <OnixS/ICE/BOE/messaging/Memory.h>
#include <OnixS/ICE/BOE/messaging/Utils.h>
 
#ifdef ONIXS_ICEBOE_CXX17
#  include <optional>
#endif
 
ONIXS_ICEBOE_MESSAGING_NAMESPACE_BEGIN
 
[[noreturn]] ONIXS_ICEBOE_EXPORTED void throwBadOptionalAccess();
 
#ifdef ONIXS_ICEBOE_CXX17
    using NullOpt = std::nullopt_t;
    constexpr auto nullOpt = std::nullopt;
#else
    struct NullOpt
    {
        enum class _Construct { _Token };
        explicit constexpr NullOpt(_Construct) noexcept {}
    };
    constexpr NullOpt nullOpt { NullOpt::_Construct::_Token };
#endif
 
inline std::string toStr(NullOpt)
{
    return "[]";
}
 
 
template <typename Derived>
class SbeOptionalField
{
public:
    template <typename D = Derived>
    ONIXS_ICEBOE_FORCEINLINE
    auto value() const -> decltype(*std::declval<const D&>())
    {
        if (!this_().hasValue())
            throwBadOptionalAccess();
 
        return *this_();
    }
 
    ONIXS_ICEBOE_FORCEINLINE
    static constexpr Derived null() noexcept
    {
        return {};
    }
 
    explicit operator bool() const noexcept
    {
        return this_().hasValue();
    }
 
#ifdef ONIXS_ICEBOE_CXX17
    template <typename D = Derived>
    using Native = std::optional<std::decay_t<decltype(*std::declval<const D&>())>>;
 
    template <typename D = Derived>
    auto asNative() const noexcept
    {
        return this_().hasValue() ? Native<D>(*this_()) : std::nullopt;
    }
 
    template <typename D = Derived>
    operator Native<D>() const noexcept(noexcept(asNative<D>()))
    {
        return asNative();
    }
#endif
 
protected:
    ~SbeOptionalField() = default;
 
private:
    ONIXS_ICEBOE_FORCEINLINE
    const Derived& this_() const noexcept
    {
        return *static_cast<const Derived*>(this);
    }
};
 
template <typename T, typename Null, typename Enable = void> class SbeOptional;
 
template<class T, typename Null>
class SbeOptional
    <
        T
        , Null
        , typename std::enable_if
            <
                std::is_same<T, typename Null::Value>::value
                && isConstant<Null>::value
                && !isScopedEnum<T>::value
            >::type
    >
    : public SbeOptionalField<SbeOptional<T, Null>>
{
public:
    using HeldType = T;
 
    template<typename U
            , typename std::enable_if<std::is_constructible<T, U&&>::value, void*>::type = nullptr>
    SbeOptional(U&& u) noexcept(noexcept(T(std::forward<U>(u))))
        : value_(std::forward<U>(u))
    {
    }
 
    template<class U, class V, class... Rest
            , typename std::enable_if<std::is_constructible<T, U&&, V&&, Rest&&...>::value, void*>::type = nullptr>
    explicit SbeOptional(U&& u, V&& v, Rest&&... rest) noexcept(noexcept(T(std::forward<U>(u), std::forward<V>(v), std::forward<Rest>(rest)...)))
        : value_(std::forward<U>(u), std::forward<V>(v), std::forward<Rest>(rest)...)
    {
    }
 
    constexpr SbeOptional() noexcept
        : value_(Null::value())
    {
    }
 
    constexpr SbeOptional(NullOpt) noexcept
        : value_(Null::value())
    {
    }
 
    ChooseValueKind<T> raw() const noexcept
    {
        return value_;
    }
 
    bool hasValue() const noexcept
    {
        return value_ != Null::value();
    }
 
    ChooseValueKind<T> operator*() const noexcept
    {
        assert(hasValue());
        return value_;
    }
 
    const T* operator->() const noexcept
    {
        assert(hasValue());
        return &value_;
    }
 
private:
    T value_;
};

template<class T, typename Null>
class SbeOptionalEnumeration
    : public SbeOptionalField<SbeOptionalEnumeration<T, Null>>
{
    static_assert(isScopedEnum<T>::value, "");
    static_assert(std::is_same<typename underlyingType<T>::type, typename Null::Value>::value, "");
 
public:
    using HeldType = T;
 
    SbeOptionalEnumeration(T v) noexcept
        : value_(v)
    {
    }
 
    constexpr SbeOptionalEnumeration() noexcept
        : value_(static_cast<T>(Null::value()))
    {
    }
 
    constexpr SbeOptionalEnumeration(NullOpt) noexcept
        : value_(static_cast<T>(Null::value()))
    {
    }
 
    T raw() const noexcept
    {
        return value_;
    }
 
    bool hasValue() const noexcept
    {
        return toUnderlying(value_) != Null::value();
    }
 
    T operator*() const noexcept
    {
        assert(hasValue());
        return value_;
    }
 
private:
    T value_;
};
 

class SbeOptionalStr
    : public SbeOptionalField<SbeOptionalStr>
{
public:
    using HeldType = StrRef;
 
    constexpr SbeOptionalStr(StrRef v) noexcept
        : value_(v)
    {
    }
 
    constexpr SbeOptionalStr() noexcept
        : value_(StrRef{})
    {
    }
 
    constexpr SbeOptionalStr(NullOpt) noexcept
        : value_(StrRef{})
    {
    }
 
    StrRef raw() const noexcept
    {
        return value_;
    }
 
    bool hasValue() const noexcept
    {
        return !value_.empty();
    }
 
    StrRef operator*() const noexcept
    {
        assert(hasValue());
        return value_;
    }
 
    const StrRef* operator->() const noexcept
    {
        return &value_;
    }
 
private:
    StrRef value_;
};

template<class T>
class SbeOptionalConverted
    : public SbeOptionalField<SbeOptionalConverted<T>>
{
public:
    using HeldType = T;
 
    SbeOptionalConverted(T&& value) noexcept
        : valid_(true)
    {
        new (static_cast<void*>(storage_)) T(std::forward<T&&>(value));
    }
 
    constexpr SbeOptionalConverted() noexcept
        : valid_(false)
    {
    }
 
    constexpr SbeOptionalConverted(NullOpt) noexcept
        : valid_(false)
    {
    }
 
    static_assert(std::is_trivially_destructible<T>::value, "");
    ~SbeOptionalConverted() = default;
 
    bool hasValue() const noexcept
    {
        return valid_;
    }
 
    ChooseValueKind<T> operator*() const noexcept
    {
        assert(hasValue());
        return *ptr();
    }
 
    const T* operator->() const noexcept
    {
        assert(hasValue());
        return ptr();
    }
 
 
private:
    const T* ptr() const noexcept
    {
        return reinterpret_cast<const T*>(storage_);
    }
 
    alignas(T) uint8_t storage_[sizeof(T)];
    bool valid_;
};
 
template <typename T> using SbeOptionalT = SbeOptional<typename T::Value, T>;
 
class OptionalTag {};
constexpr OptionalTag optional{};
 
template<typename T> struct isOptional
    : std::integral_constant
    <
        bool,
        std::is_base_of<SbeOptionalField<cleanType<T>>, cleanType<T>>::value
    >
    {};
 
 
template <typename T>
typename std::enable_if<isOptional<T>::value, bool>::type
    operator==(const T& t, NullOpt) noexcept
{
    return !t;
}
 
template <typename T>
typename std::enable_if<isOptional<T>::value, bool>::type
    operator==(NullOpt, const T& t) noexcept
{
    return !t;
}
 
template <typename T>
typename std::enable_if<isOptional<T>::value, bool>::type
    operator!=(const T& t, NullOpt) noexcept
{
    return !!t;
}
 
template <typename T>
typename std::enable_if<isOptional<T>::value, bool>::type
    operator!=(NullOpt, const T& t) noexcept
{
    return !!t;
}
 
template <typename T>
std::string toStr(const T& value, typename std::enable_if<isOptional<T>::value, void*>::type = nullptr)
{
    return value == nullOpt ? toStr(nullOpt) : toStr(*value);
}
 
template <typename T>
typename std::enable_if<isOptional<T>::value, std::ostream&>::type
    operator<<(std::ostream& stream, const T& value)
{
    stream << toStr(value);
    return stream;
}
 
ONIXS_ICEBOE_MESSAGING_NAMESPACE_END