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_Inline.h"
#include <type_traits>

namespace SYS_TypeTraitsImpl
{

// Primary templates for additional types that are considered,
// integral, floating-point, POD:
template <typename T> struct AddIntegralNoCV : std::integral_constant< bool, false > {};
template <typename T> struct AddFloatingPointNoCV : std::integral_constant< bool, false > {};
template <typename T> struct AddPodNoCV : std::integral_constant< bool, false > {};

}

/// @file

/// 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 : std::integral_constant< bool,
    std::is_integral< T >::value ||
    SYS_TypeTraitsImpl::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 : std::integral_constant< bool,
    std::is_floating_point< T >::value ||
    SYS_TypeTraitsImpl::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 : std::integral_constant< bool,
    std::is_pod< T >::value ||
    SYS_TypeTraitsImpl::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 >;
}

/// 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 : std::integral_constant< bool,
    ( 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
/// @{
template <typename T1, typename T2>
struct SYS_IsSame : public std::is_same<T1, T2> {};

template <typename T1, typename T2>
constexpr auto SYS_IsSame_v = SYS_IsSame<T1, T2>::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 : std::integral_constant< bool, false > {};

template <typename U>
struct SYS_IsPointer< U* > : std::integral_constant< bool, 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<
    std::remove_cv_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 : std::integral_constant< bool,
    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>
struct SYS_DisableIf : public SYS_EnableIf<!B, T> {};
/// @}

/// 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
}

#endif // __SYS_TYPETRAITS_H_INCLUDED__