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__

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

// Specialization of SafeTrivialRelocationNoCV adds a type to the list
// of types that are known to be safe for trivial relocation.
// For each such type SYS_IsTriviallyRelocatable (see SYS_TypeTraits.h)
// would return true. However, SYS_IsTriviallyRelocatable may be true
// for additional types that have no SafeTrivialRelocationNoCV specialization,
// for example, enum types.
// Primary template:
template< typename T > struct SafeTrivialRelocationNoCV { static constexpr bool value = false; };

// Specialization of UnsafeTrivialRelocationNoCV adds a type to the list
// of types that are known to be unsafe for trivial relocation.
// Primary template:
template< typename T > struct UnsafeTrivialRelocationNoCV { static constexpr bool value = false; };

// Primary template:
// LegacyTrivialRelocationNoCV indicates that trivial relocation must
// be used for T not because it's safe but only because T is legacy code:
// T may have missing or broken move constructors or destructors,
// in which case we're forced to keep treating T as TR until T is fixed.
template< typename T > struct LegacyTrivialRelocationNoCV { static constexpr bool value = false; };

// Primary template:
// RegisterRelocationNoCV indicates that trivial relocation is
// currently being used for a type T.
// This trait does not say whether this is safe or not,
// it merely documents a previously existing use of trivial relocation.
template< typename T > struct RegisterTrivialRelocationNoCV { 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" ); \
                [[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" ); \
                [[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" ); \
                [[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" ); \
                [[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" ); \
                [[maybe_unused]] static constexpr bool value = true; \
            };\
            /**/
            
#define SYS_DECLARE_LEGACY_TR_IMPL(...) \
            struct LegacyTrivialRelocationNoCV< __VA_ARGS__ > { \
                static_assert( ( ! SYS_HasCV_v< __VA_ARGS__ > ), \
                "SYS_DECLARE_LEGACY_TR must be used on types without const/volatile qualifiers" ); \
                [[maybe_unused]] static constexpr bool value = true; \
            };\
            /**/
            
#define SYS_REGISTER_TR_IMPL(...) \
            struct RegisterTrivialRelocationNoCV< __VA_ARGS__ > { \
                static_assert( ( ! SYS_HasCV_v< __VA_ARGS__ > ), \
                "SYS_REGISTER_TR must be used on types without const/volatile qualifiers" ); \
                [[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__ )

/// Declare that trivial relocation must be used with T,
/// but only because T is legacy code
/// Ideally, the type T would be modified to allow safe relocation,
/// by providing a move constructor.
#define SYS_DECLARE_LEGACY_TR(T) template<> SYS_DECLARE_LEGACY_TR_IMPL(T)

/// Version for class template
#define SYS_DECLARE_LEGACY_TR_TEMPLATE(...) SYS_DECLARE_LEGACY_TR_IMPL( __VA_ARGS__ )

/// Register that trivial relocation is currently being used with T
/// This does not declare that this is safe at all;
/// it just documents each type that is currently being trivially relocated.
/// the information is merely used to help compile a list of all types that
/// are currently being trivially relocated by UT_Array
/// (all types were being trivially relocated before H20).
/// An actual decision on whether TR should be remain enabled for the type T
/// can be made later.
#define SYS_REGISTER_TR(T) template<> SYS_REGISTER_TR_IMPL(T)

/// Version for class template
#define SYS_REGISTER_TR_TEMPLATE(...) SYS_REGISTER_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__