Utils.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 <cassert>
#include <tuple>
#include <type_traits>
 
#include <OnixS/ICE/BOE/ABI.h>
 
#if !(defined(ONIXS_ICEBOE_DOXYGEN) && ONIXS_ICEBOE_DOXYGEN)
ONIXS_ICEBOE_MESSAGING_NAMESPACE_BEGIN
 
#define CHECK_TYPE_INTEGRAL(Type) \
          static_assert( \
              std::is_integral<Type>::value, \
              #Type " must be an integral type, consider adding MemberTraits" \
              );
 
namespace details {
 
    template <class T, class U>
    struct IsSameSignedness
    {
        enum { value = (static_cast<bool>(std::is_signed<T>::value) == static_cast<bool>(std::is_signed<U>::value)) };
    };
 
    template<typename T>
    struct HasMantissa
    {
        template<typename U> struct SFINAE {};
        template<typename U> static char test(SFINAE<typename U::Mantissa>*);
        template<typename U> static int test(...);
        enum { value = sizeof(test<T>(nullptr)) == sizeof(char) };
    };
 
    template<typename T>
    struct HasExponent
    {
        template<typename U> struct SFINAE {};
        template<typename U> static char test(SFINAE<typename U::Exponent>*);
        template<typename U> static int test(...);
        enum { value = sizeof(test<T>(nullptr)) == sizeof(char) };
    };
 
    template<typename T>
    struct IsDecimal
    {
        enum { value = HasMantissa<T>::value && HasExponent<T>::value };
    };
 
    template
        <
            class Decimal1,
            class Decimal2
        >
    struct AreBothDecimals
    {
        enum { value = IsDecimal<Decimal1>::value && IsDecimal<Decimal2>::value };
    };
 
    template<typename T>
    struct HasMemberTraits
    {
        template<typename U> struct SFINAE {};
        template<typename U> static char test(SFINAE<struct U::MemberTraits>*);
        template<typename U> static int test(...);
        enum { value = sizeof(test<T>(nullptr)) == sizeof(char) };
    };
 
    template<typename T>
    struct HasValueStaticMember
    {
        template<typename U, typename U::Value (*)()> struct SFINAE {};
        template<typename U> static char test(SFINAE<U, &U::value>*);
        template<typename U> static int test(...);
        enum { value = sizeof(test<T>(nullptr)) == sizeof(char) };
    };
 
    template<typename T>
    struct HasSerializeMember
    {
        template<typename U, void (U::*)(void*) const noexcept> struct SFINAE {};
        template<typename U> static char test(SFINAE<U, &U::serialize>*);
        template<typename U> static int test(...);
        enum { value = sizeof(test<T>(nullptr)) == sizeof(char) };
    };
}
 
template <class To, class From>
ONIXS_ICEBOE_PURE
inline
typename std::enable_if<details::IsSameSignedness<To, From>::value, To>::type
    numericCast(From from) noexcept
{
    const To to = static_cast<To>(from);
    assert(static_cast<From>(to) == from);
    return to;
}
 
template <class To, class From>
ONIXS_ICEBOE_PURE
inline
typename std::enable_if<!details::IsSameSignedness<To, From>::value, To>::type
    numericCast(From from) noexcept
{
    const To to = static_cast<To>(from);
 
    assert(static_cast<From>(to) == from);
 
    // The sign is lost during the conversion
    assert((to > static_cast<To>(0)) == (from > static_cast<From>(0)));
 
    return to;
}
 
 
namespace details {
    template <typename...> struct make_void { typedef void type; };
}
 
template<class T> using cleanType = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 
 
namespace details {
    template <typename T, bool = std::is_enum<T>::value>  struct isScopedEnumImpl : std::false_type{};
    template <typename T> struct isScopedEnumImpl<T, true> : std::integral_constant<bool, !std::is_convertible<T, typename std::underlying_type<T>::type>::value>{};
}
 
template <typename T> struct isScopedEnum : public details::isScopedEnumImpl<cleanType<T>> {};
template <typename T> struct isEnum : public std::is_enum<cleanType<T>> {};
 
namespace details {
    template <typename T>
    struct underlyingTypeImpl
    {
        static_assert(isScopedEnum<T>::value, "");
        using type = typename std::underlying_type<T>::type;
        static_assert(std::is_integral<type>::value, "");
    };
}
 
template <typename T> struct underlyingType : public details::underlyingTypeImpl<cleanType<T>> {};
 
 
template <class T> constexpr ONIXS_ICEBOE_FORCEINLINE typename underlyingType<T>::type toUnderlying(T t) noexcept
{
    return static_cast<typename underlyingType<T>::type>(t);
}
 
namespace details {
    template<typename T, typename = void> struct isCompositeImpl : std::false_type {};
    template<typename T>
    struct isCompositeImpl
        <
            T,
            typename make_void
            <
                typename T::MemberTraits, decltype(T::Size), decltype(T::MemberTraits::Count), decltype(std::declval<const T&>().serialize(nullptr))
            >::type
        >
        : std::integral_constant
          <
              bool,
              std::is_same<void, decltype(std::declval<const T&>().serialize(nullptr))>::value
              && std::is_enum<decltype(T::Size)>::value
              && std::is_enum<decltype(T::MemberTraits::Count)>::value
          >
    {};
}
 
template <typename T> struct isComposite : public details::isCompositeImpl<cleanType<T>> {};
 
namespace details {
 
template <typename T, typename = void> struct hasCallReturningValue : std::false_type {};
template <typename T>
struct hasCallReturningValue
    <
        T,
        typename make_void<decltype(std::declval<const T&>()())>::type
    >
    : std::integral_constant
    <
        bool,
        std::is_convertible
        <
            decltype(std::declval<const T&>()()),
            typename T::Value
        >::value
    >
{};
 
template <typename T, typename = void>
struct hasStaticValueReturningValue : std::false_type {};
 
template <typename T>
struct hasStaticValueReturningValue
    <
        T,
        typename make_void<decltype(T::value())>::type
    >
    : std::integral_constant
    <
        bool,
        std::is_convertible
        <
            decltype(T::value()),
            typename T::Value
        >::value
    >
{};
}
 
template <typename T, typename = void> struct isConstant : std::false_type {};
 
template <typename T>
struct isConstant
    <
        T,
        typename details::make_void<typename T::Value>::type
    >
    : std::integral_constant
    <
        bool,
        std::is_convertible<const T&, typename T::Value>::value
        && details::hasCallReturningValue<T>::value
        && details::hasStaticValueReturningValue<T>::value
    >
{};
 
 
 
namespace details {
template<std::size_t...> struct indexSequence{};
template<std::size_t N, std::size_t... I> struct makeIndexSequenceImpl : makeIndexSequenceImpl<N - 1, N - 1, I...> {};
template<std::size_t... I> struct makeIndexSequenceImpl<0, I...> {typedef indexSequence<I...> type;};
template<std::size_t N> using makeIndexSequence = typename makeIndexSequenceImpl<N>::type;
 
template<class T, class Tuple, std::size_t... I>
T makeFromTupleImpl(Tuple&& t, indexSequence<I...>) noexcept(std::is_nothrow_constructible<T, decltype(std::get<I>(std::forward<Tuple>(t)))...>::value)
{
    return T{std::get<I>(std::forward<Tuple>(t))...};
}
 
}
 
template <class T, class Tuple>
T makeFromTuple(Tuple&& t) noexcept(noexcept(details::makeFromTupleImpl<T>(std::forward<Tuple>(t), details::makeIndexSequence<std::tuple_size<typename std::remove_reference<Tuple>::type>::value>())))
{
    using Tup = typename std::remove_reference<Tuple>::type ;
    return details::makeFromTupleImpl<T>(std::forward<Tuple>(t), details::makeIndexSequence<std::tuple_size<Tup>::value>());
}
 
template <typename> struct ArgType;
 
template <typename T, typename A, typename V>
struct ArgType<T(A::*)(V) const>
{
    using type = cleanType<V>;
};
 
#if ONIXS_ICEBOE_CXX17_NOEXCEPT
template <typename T, typename A, typename V> struct ArgType<T(A::*)(V) const noexcept> : public ArgType<T(A::*)(V) const>{};
template <typename T, typename A, typename V> struct ArgType<T(A::*)(V) noexcept> : public ArgType<T(A::*)(V)>{};
#endif
 
template <typename T, typename A, typename V>
struct ArgType<T(A::*)(V)>
{
    using type = cleanType<V>;
};
 
template <typename T, typename V>
struct ArgType<T(*)(V)>
{
    using type = cleanType<V>;
};
 
template <typename Func, Func F> struct FuncWrapper;
template <typename R, typename V, R(*F)(V)> struct FuncWrapper<R(*)(V), F>
{
    using ArgType = V;
    using ReturnType = R;
 
    static_assert(!std::is_convertible<ArgType, ReturnType>::value, "Direct conversion can be done.");
 
    static constexpr bool Nothrow = noexcept(F(std::declval<ArgType>()));
 
    ONIXS_ICEBOE_FORCEINLINE ReturnType operator()(ArgType x) const noexcept(Nothrow) { return F(x); }
};
 
#if ONIXS_ICEBOE_CXX17_NOEXCEPT
template <typename R, typename V, R(*F)(V) noexcept>
struct FuncWrapper<R(*)(V) noexcept, F> : public FuncWrapper<R(*)(V), F>{};
#endif
 
 
template <typename R, typename V, R(*F)(V)>
struct ArgType<FuncWrapper<R(*)(V), F>>
{
    using type = cleanType<typename FuncWrapper<R(*)(V), F>::ArgType>;
};
 
#if ONIXS_ICEBOE_CXX17_NOEXCEPT
template <typename R, typename V, R(*F)(V) noexcept>
struct ArgType<FuncWrapper<R(*)(V) noexcept, F>> : public ArgType<FuncWrapper<R(*)(V), F>>{};
#endif
 
#define ONIXS_ICEBOE_WRAP_F(F) FuncWrapper<decltype(&F), &F>
 
 
#if defined ONIXS_NO_RETURN_TYPE_DEDUCTION
#if defined(ONIXS_ICEBOE_CXX14)
#  define ONIXS_ICEBOE_FIELD_TYPE(...) ONIXS_ICEBOE_NODISCARD auto
#  define ONIXS_ICEBOE_FIELD_TYPE_C(...) ONIXS_ICEBOE_NODISCARD auto
#else
namespace details {struct DummyLength {enum {length};};}
#define __ONIXS_ICEBOE_FIELD_TYPE_IMPL(Name, ...) \
struct Name : public details::DummyLength { \
    template<typename T = ThisType> \
    using type = decltype(std::declval<const T&>().template __VA_ARGS__(std::declval<BlockLength>(), std::declval<OptionalTag>())); \
}; typename Name::type<ThisType>
#define ONIXS_ICEBOE_FIELD_TYPE(...) __ONIXS_ICEBOE_FIELD_TYPE_IMPL(ONIXS_ICEBOE_MAKE_UNIQUE_NAME(Dummy), __VA_ARGS__)
 
template <typename T> struct RetType;
template <typename T> struct RetType : RetType<typename std::remove_pointer<T>::type> {};
template <typename R, typename... A> struct RetType<R(A...)> { using type = R; };
#if ONIXS_ICEBOE_CXX17_NOEXCEPT
template <typename R, typename... A> struct RetType<R(A...) noexcept> : public RetType<R(A...)>{};
#endif
#define ONIXS_ICEBOE_FIELD_TYPE_C(...) typename RetType<decltype(&__VA_ARGS__)>::type
#endif
#endif
 
namespace details {
template<class T>
struct smallType
{
    static constexpr bool value = (sizeof(T) <= 2 * sizeof(void*));
};
 
template<class T, typename = void> struct ChooseValueKindImpl;
template<class T> struct ChooseValueKindImpl<T, typename std::enable_if<smallType<T>::value>::type> {using type = cleanType<T>;};
template<class T> struct ChooseValueKindImpl<T, typename std::enable_if<!smallType<T>::value>::type> {using type = const cleanType<T>&;};
}
 
template<class T> using ChooseValueKind = typename details::ChooseValueKindImpl<T>::type;
 
ONIXS_ICEBOE_MESSAGING_NAMESPACE_END
#endif