SYS_TypeTraits.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        SYS_TypeTraits.h (SYS Library, C++)
 *
 * COMMENTS:    Type trait utilities
 */

#ifndef __SYS_TYPETRAITS_H_INCLUDED__
#define __SYS_TYPETRAITS_H_INCLUDED__

#include "SYS_TypeDecorate.h"
#include "SYS_Inline.h"
#include <type_traits>

/// @file

// In C++17, this could be std::bool_constant
template< bool v >
struct SYS_BoolConstant : std::integral_constant< bool, v > {};

using SYS_FalseType = SYS_BoolConstant< false >;
using SYS_TrueType = SYS_BoolConstant< true >;

/// Alternative for C++17's std::void that can be used in C++14:
template< typename ... >
using SYS_Void_t = void;

/// SYS_IsIntegral is true if std::is_integral
/// but is also true for additional types,
/// which may be declared using SYS_DECLARE_IS_INTEGRAL
template< typename T >
struct SYS_IsIntegral : SYS_BoolConstant<
    std::is_integral< T >::value ||
    AddIntegralNoCV< std::remove_cv_t< T > >::value
> {};

template< typename T >
constexpr auto SYS_IsIntegral_v = SYS_IsIntegral< T >::value;

/// SYS_IsFloatingPoint is true if std::is_floating_point,
/// but is also true for additional types,
/// which may be declared using SYS_DECLARE_IS_FLOATING_POINT
template< typename T >
struct SYS_IsFloatingPoint : SYS_BoolConstant<
    std::is_floating_point< T >::value ||
    AddFloatingPointNoCV< std::remove_cv_t< T > >::value
> {};

template< typename T >
constexpr auto SYS_IsFloatingPoint_v = SYS_IsFloatingPoint< T >::value;

/// SYS_IsPod is true if std::is_pod,
/// but is also true for additional types,
/// which may be declared using SYS_DECLARE_IS_POD
template< typename T >
struct SYS_IsPod : SYS_BoolConstant<
    std::is_pod< T >::value ||
    AddPodNoCV< std::remove_cv_t< T > >::value
> {};

template< typename T >
constexpr auto SYS_IsPod_v = SYS_IsPod< T >::value;

/// Check whether a given type is plain-old-data (POD)
template <typename T>
static constexpr SYS_FORCE_INLINE bool SYSisPOD()
{
    return SYS_IsPod_v< T >;
}

/// If SYS_IsTriviallyRelocatable is true, then it should be safe
/// to bitwise copy an object of type T to a different memory location.
/// This can be declared using the macro SYS_DECLARE_IS_TR
template< typename T >
struct SYS_IsTriviallyRelocatable : SYS_BoolConstant<
    std::is_fundamental< T >::value ||
    std::is_enum< T >::value ||
    std::is_pointer< T >::value ||
    SafeTrivialRelocationNoCV< std::remove_cv_t< T > >::value
> {};

template< typename T >
constexpr auto SYS_IsTriviallyRelocatable_v = SYS_IsTriviallyRelocatable< T >::value;

/// Check whether a type is arithmetic (integer or floating-point type),
/// which means SYS_IsIntegral or SYS_IsFloatingPoint
/// This struct should not be specialized; instead use
/// SYS_DECLARE_IS_INTEGRAL and SYS_DECLARE_IS_FLOATING_POINT
template <typename T>
struct SYS_IsArithmetic : SYS_BoolConstant<
    ( SYS_IsIntegral< T >::value || SYS_IsFloatingPoint< T >::value )
> {};

template< typename T >
constexpr auto SYS_IsArithmetic_v = SYS_IsArithmetic< T >::value;

/// Check whether an arithmetic type is signed.
template <typename T>
struct SYS_IsSigned : public std::is_signed<T> {};

template <typename T>
constexpr auto SYS_IsSigned_v = SYS_IsSigned< T >::value;

/// Check whether two types are the same
/// @{

// Primary: assume not the same by default
template< typename T, typename U >
struct SYS_IsSame : SYS_FalseType {};

// Partial specialization for two the same types
template< typename T >
struct SYS_IsSame< T, T > : SYS_TrueType {};

template< typename T, typename U >
constexpr auto SYS_IsSame_v = SYS_IsSame< T, U >::value;

template <typename T1, typename T2>
static constexpr SYS_FORCE_INLINE bool SYSisSame()
{
    return SYS_IsSame_v< T1, T2 >;
}

/// @}

/// Check whether a given type is a pointer
/// @{

template <typename T>
struct SYS_IsPointer : SYS_BoolConstant< false > {};

template <typename U>
struct SYS_IsPointer< U* > : SYS_BoolConstant< true > {};

template <typename T>
constexpr auto SYS_IsPointer_v = SYS_IsPointer< T >::value;

/// @}

/// Map a type to itself.
/// Useful for specifying the result of a type metafunction;
/// simply inherit from SYS_TypeIdentity<ResultType>
/// @{

template< typename T >
struct SYS_TypeIdentity { using type = T; };

template< typename T >
using SYS_TypeIdentity_t = typename SYS_TypeIdentity< T >::type;

/// @}

/// Remove reference, if T is a reference type.
/// After that, remove the topmost cv-qualifiers.
/// @{

template< typename T >
struct SYS_RemoveCVRef : SYS_TypeIdentity<
    SYS_RemoveCV_t< std::remove_reference_t< T > >
> {};

template< typename T >
using SYS_RemoveCVRef_t = typename SYS_RemoveCVRef< T >::type;

/// @}

/// Evaluates to true if
/// T is not a reference and 
/// T has no const/volatile qualifiers.
/// Otherwise evaluates to false.
/// @{

template< typename T >
struct SYS_HasNoCVRef : SYS_BoolConstant<
    std::is_same< T, SYS_RemoveCVRef_t< T > >::value
> {};

template< typename T >
constexpr auto SYS_HasNoCVRef_v = SYS_HasNoCVRef< T >::value;

/// @}

/// Choose whether to make a type const or not with a template bool.
/// This allows a set of types to be made const or not with a single
/// bool template, instead of having a separate template parameter for
/// each type.
/// @{

template<typename T,bool MAKE_CONST>
struct SYS_ConstType : SYS_TypeIdentity< T > {};

template<typename T>
struct SYS_ConstType< T, true > : SYS_TypeIdentity< const T > {};

template<typename T,bool MAKE_CONST>
using SYS_ConstType_t = typename SYS_ConstType< T, MAKE_CONST >::type;

/// @}

/// Choose a type from two alternatives based on a bool.
/// It choses the first type if false, and the second type if true.
/// @{

template<typename T0,typename T1,bool IST1>
struct SYS_SelectType : SYS_TypeIdentity< T0 > {};

template<typename T0,typename T1>
struct SYS_SelectType< T0, T1, true > : SYS_TypeIdentity< T1 > {};

template<typename T0,typename T1,bool IST1>
using SYS_SelectType_t = typename SYS_SelectType< T0, T1, IST1 >::type;

/// @}

/// Hides a function overload or template specialization based on a
/// compile-time boolean.
/// {@
template <bool B, typename T = void>
struct SYS_EnableIf : public std::enable_if<B, T> {};

template <bool B, typename T = void>
using SYS_EnableIf_t = typename SYS_EnableIf<B, T>::type;

template <bool B, typename T = void>
struct SYS_DisableIf : public SYS_EnableIf<!B, T> {};

template <bool B, typename T = void>
using SYS_DisableIf_t = typename SYS_DisableIf<B, T>::type;
/// @}

/// Return the number of elements of a static array
template <typename T, std::size_t N>
static SYS_FORCE_INLINE constexpr auto
SYSarraySize(const T (&)[N]) noexcept
{
    return N; // same as std::extent<T>::value
}

/// 
/// Determine whether a type is designated as a fixed-array-like type;
/// its must have a compile-time size and support square-bracket indexing.
/// 
/// Examples of such types include a built-in bounded array and std::array< T, N >.
/// 
/// Specialize SYS_IsFixedArrayNoCVRef to add support to additional types.
/// {@

template< typename T >
struct SYS_IsFixedArray : SYS_IsFixedArrayNoCVRef< SYS_RemoveCVRef_t< T > > {};

template< typename T >
constexpr bool SYS_IsFixedArray_v = SYS_IsFixedArray< T >::value;

/// @}

/// Extracts the element type of a fixed-array-like type.
/// Specialize SYS_FixedArrayElementNoCVRef to add support to additional types.
/// {@

template< typename T >
struct SYS_FixedArrayElement : SYS_FixedArrayElementNoCVRef< SYS_RemoveCVRef_t< T > > {};

template< typename T >
using SYS_FixedArrayElement_t = typename SYS_FixedArrayElement< T >::type;

/// @}

///
/// Obtain the size of a fixed-array-like type.
/// Specialize SYS_FixedArraySizeNoCVRef to add support to additional types.
/// {@

template< typename T >
struct SYS_FixedArraySize : SYS_FixedArraySizeNoCVRef< SYS_RemoveCVRef_t< T > > {};

template< typename T >
constexpr std::size_t SYS_FixedArraySize_v = SYS_FixedArraySize< T >::value;
 
/// @}

///
/// Determine whether T, with const and volatile qualifiers removed,
/// is a fixed-array-like type that has element type E and size N.
/// The CV qualifiers of the element type E are not discarded and do matter.
/// {@
///

template< typename T, typename E, std::size_t N >
struct SYS_IsFixedArrayOf : SYS_BoolConstant<
    SYS_IsFixedArray_v< T > &&
    ( std::is_same< SYS_FixedArrayElement_t< std::remove_cv_t< T > >, E >::value ) &&
    ( SYS_FixedArraySize_v< T > == N )
 > {};
 
template< typename T, typename E, std::size_t N >
constexpr bool SYS_IsFixedArrayOf_v = SYS_IsFixedArrayOf< T, E, N >::value;

/// @}


///
/// Same as SYS_IsFixedArrayOf, except that it is checked that
/// the element type of the array *with CV qualifiers removed* is the same as E.
/// E must not have any CV qualifiers.
/// {@
///

template< typename T, typename E, std::size_t N >
struct SYS_IsFixedArrayOfNoCV : SYS_BoolConstant<
    SYS_IsFixedArray_v< T > &&
    ( std::is_same<  std::remove_cv_t< SYS_FixedArrayElement_t< std::remove_cv_t< T > > >, E >::value ) &&
    ( SYS_FixedArraySize_v< T > == N )
>
{
    static_assert( SYS_HasNoCVRef_v< E > );
};
 
template< typename T, typename E, std::size_t N >
constexpr bool SYS_IsFixedArrayOfNoCV_v = SYS_IsFixedArrayOfNoCV< T, E, N >::value;

/// @}

///
/// Determine whether the element type of T is equal to E.
/// T must be a fixed array-like type.

/// {@
///

template< typename T, typename E >
struct SYS_FixedArrayHasElement : 
    SYS_IsSame< SYS_FixedArrayElement_t< T >, E >
{
    static_assert( SYS_IsFixedArray_v< T > );
};

template< typename T, typename E >
constexpr bool SYS_FixedArrayHasElement_v = SYS_FixedArrayHasElement< T, E >::value;

/// @}

///
/// Determine whether the element type of T * with CV qualifiers removed *
/// is equal to E.
/// T must be a fixed array-like type and E must not have any CV qualifiers.

/// {@
///

template< typename T, typename E >
struct SYS_FixedArrayHasElementNoCV : 
    SYS_IsSame< SYS_RemoveCV_t< SYS_FixedArrayElement_t< T > >, E >
{
    static_assert( SYS_IsFixedArray_v< T > );
    static_assert( SYS_HasNoCVRef_v< E > );
};

template< typename T, typename E >
constexpr bool SYS_FixedArrayHasElementNoCV_v = SYS_FixedArrayHasElementNoCV< T, E >::value;

/// @}

// Specialize FixedArray traits for built-in bounded arrays

template< typename T, std::size_t N >
struct SYS_IsFixedArrayNoCVRef< T[N] > : SYS_BoolConstant< true > {};

template< typename T, std::size_t N >
struct SYS_FixedArrayElementNoCVRef< T[N] > : SYS_TypeIdentity< T > {};

template< typename T, std::size_t N >
struct SYS_FixedArraySizeNoCVRef< T[N] > : std::integral_constant< std::size_t, N > {};

#endif // __SYS_TYPETRAITS_H_INCLUDED__