SYS_TypeDecorate.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_TypeDecorate.h (SYS Library, C++)
 *
 * COMMENTS:
 */

#ifndef __SYS_TYPEDECORATE_H_INCLUDED__
#define __SYS_TYPEDECORATE_H_INCLUDED__

#include "SYS_Compiler.h"

// NOTE: This header is intentionally kept free of any includes,
//       as it may itself get included in many places.

// Define SYS_RemoveCV here instead to avoid including
// SYS_TypeTraits.h or type_traits in too many places.

/// Remove topmost  const/volatile qualifiers.
/// @{

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

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

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

template< typename T >
struct SYS_RemoveCV< const volatile T > { using type = T; };

template< typename T >
using SYS_RemoveCV_t = typename SYS_RemoveCV< T >::type;

/// @}

// Primary templates for additional types that are considered,
// integral, floating-point, POD:

template <typename T> struct AddIntegralNoCV { static constexpr bool value = false; };
template <typename T> struct AddFloatingPointNoCV { static constexpr bool value = false; };
template <typename T> struct AddPodNoCV { static constexpr bool value = false; };

// Primary template:
// SafeTrivialRelocationNoCV indicates that trivial relocation is safe for T
template< typename T > struct SafeTrivialRelocationNoCV { static constexpr bool value = false; };

// Primary template:
// UnsafeTrivialRelocationNoCV indicates that trivial relocation is unsafe for T
template< typename T > struct UnsafeTrivialRelocationNoCV { static constexpr bool value = false; };

// Primary templates for fixed-array-like type traits

template< typename T > struct SYS_IsFixedArrayNoCVRef { static constexpr bool value = false; };
template< typename T > struct SYS_FixedArrayElementNoCVRef;
template< typename T > struct SYS_FixedArraySizeNoCVRef;

// SYS_HasCV: Return whether a type T has any const or volatile qualifiers

// Primary
template< typename T > struct SYS_HasCV { static constexpr bool value = false; };

template< typename T > constexpr auto SYS_HasCV_v = SYS_HasCV< T >::value;

template< typename T > struct SYS_HasCV< const T > { static constexpr bool value = true; };
template< typename T > struct SYS_HasCV< volatile T > { static constexpr bool value = true; };
template< typename T > struct SYS_HasCV< const volatile T > { static constexpr bool value = true; };

/// @file
/// Provides facilities to decorate types that can then be tested using type
/// traits.

/// Declare a type as integral
#define SYS_DECLARE_IS_INTEGRAL(T) \
            template<> struct AddIntegralNoCV< T > { \
                static_assert( ( ! SYS_HasCV_v< T > ), \
                "SYS_DECLARE_IS_INTEGRAL must be used on types without const/volatile qualifiers" ); \
                SYS_MAYBE_UNUSED static constexpr bool value = true; \
            };\
            /**/

/// Declare a type as floating point
#define SYS_DECLARE_IS_FLOATING_POINT(T) \
            template<> struct AddFloatingPointNoCV< T > { \
                static_assert( ( ! SYS_HasCV_v< T > ), \
                "SYS_DECLARE_IS_FLOATING_POINT must be used on types without const/volatile qualifiers" ); \
                SYS_MAYBE_UNUSED static constexpr bool value = true; \
            };\
            /**/

/// Declare a type as POD
#define SYS_DECLARE_IS_POD(T) \
            template<> struct AddPodNoCV< T > { \
                static_assert( ( ! SYS_HasCV_v< T > ), \
                "SYS_DECLARE_IS_POD must be used on types without const/volatile qualifiers" ); \
                SYS_MAYBE_UNUSED static constexpr bool value = true; \
            };\
            /**/

#define SYS_DECLARE_IS_TR_IMPL(...) \
            struct SafeTrivialRelocationNoCV< __VA_ARGS__ > { \
                static_assert( ( ! SYS_HasCV_v< __VA_ARGS__> ), \
                "SYS_DECLARE_IS_TR must be used on types without const/volatile qualifiers" ); \
                SYS_MAYBE_UNUSED static constexpr bool value = true; \
            };\
            /**/
            
#define SYS_DECLARE_IS_NOT_TR_IMPL(...) \
            struct UnsafeTrivialRelocationNoCV< __VA_ARGS__ > { \
                static_assert( ( ! SYS_HasCV_v< __VA_ARGS__ > ), \
                "SYS_DECLARE_IS_NOT_TR must be used on types without const/volatile qualifiers" ); \
                SYS_MAYBE_UNUSED static constexpr bool value = true; \
            };\
            /**/

/// Guarantee that it's safe to use trivial relocation with type T
#define SYS_DECLARE_IS_TR(T) template<> SYS_DECLARE_IS_TR_IMPL(T)

/// Version for class template
#define SYS_DECLARE_IS_TR_TEMPLATE(...) SYS_DECLARE_IS_TR_IMPL( __VA_ARGS__ )

/// Declare that that trivial relocation with type T is not guaranteed to be safe
#define SYS_DECLARE_IS_NOT_TR(T) template<> SYS_DECLARE_IS_NOT_TR_IMPL(T)

/// Version for class template
#define SYS_DECLARE_IS_NOT_TR_TEMPLATE(...) SYS_DECLARE_IS_NOT_TR_IMPL( __VA_ARGS__ )

// Built-in bool, char and arithmetic types should be trivially relocatable:

SYS_DECLARE_IS_TR(bool);
SYS_DECLARE_IS_TR(char);

SYS_DECLARE_IS_TR(unsigned char);
SYS_DECLARE_IS_TR(unsigned short int);
SYS_DECLARE_IS_TR(unsigned int);
SYS_DECLARE_IS_TR(unsigned long int);
SYS_DECLARE_IS_TR(unsigned long long int);

SYS_DECLARE_IS_TR(signed char);
SYS_DECLARE_IS_TR(signed short int);
SYS_DECLARE_IS_TR(signed int);
SYS_DECLARE_IS_TR(signed long int);
SYS_DECLARE_IS_TR(signed long long int);

SYS_DECLARE_IS_TR(float);
SYS_DECLARE_IS_TR(double);

// Partial specialization for pointer types

template< typename T >
struct SafeTrivialRelocationNoCV< T* >
{
    static constexpr bool value = true;
};

#endif // __SYS_TYPEDECORATE_H_INCLUDED__