type_traits.h revision 321369
1//===- llvm/Support/type_traits.h - Simplfied type traits -------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file provides useful additions to the standard type_traits library. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_SUPPORT_TYPE_TRAITS_H 15#define LLVM_SUPPORT_TYPE_TRAITS_H 16 17#include "llvm/Support/Compiler.h" 18#include <type_traits> 19#include <utility> 20 21#ifndef __has_feature 22#define LLVM_DEFINED_HAS_FEATURE 23#define __has_feature(x) 0 24#endif 25 26namespace llvm { 27 28/// isPodLike - This is a type trait that is used to determine whether a given 29/// type can be copied around with memcpy instead of running ctors etc. 30template <typename T> 31struct isPodLike { 32 // std::is_trivially_copyable is available in libc++ with clang, libstdc++ 33 // that comes with GCC 5. 34#if (__has_feature(is_trivially_copyable) && defined(_LIBCPP_VERSION)) || \ 35 (defined(__GNUC__) && __GNUC__ >= 5) 36 // If the compiler supports the is_trivially_copyable trait use it, as it 37 // matches the definition of isPodLike closely. 38 static const bool value = std::is_trivially_copyable<T>::value; 39#elif __has_feature(is_trivially_copyable) 40 // Use the internal name if the compiler supports is_trivially_copyable but we 41 // don't know if the standard library does. This is the case for clang in 42 // conjunction with libstdc++ from GCC 4.x. 43 static const bool value = __is_trivially_copyable(T); 44#else 45 // If we don't know anything else, we can (at least) assume that all non-class 46 // types are PODs. 47 static const bool value = !std::is_class<T>::value; 48#endif 49}; 50 51// std::pair's are pod-like if their elements are. 52template<typename T, typename U> 53struct isPodLike<std::pair<T, U>> { 54 static const bool value = isPodLike<T>::value && isPodLike<U>::value; 55}; 56 57/// \brief Metafunction that determines whether the given type is either an 58/// integral type or an enumeration type, including enum classes. 59/// 60/// Note that this accepts potentially more integral types than is_integral 61/// because it is based on being implicitly convertible to an integral type. 62/// Also note that enum classes aren't implicitly convertible to integral types, 63/// the value may therefore need to be explicitly converted before being used. 64template <typename T> class is_integral_or_enum { 65 using UnderlyingT = typename std::remove_reference<T>::type; 66 67public: 68 static const bool value = 69 !std::is_class<UnderlyingT>::value && // Filter conversion operators. 70 !std::is_pointer<UnderlyingT>::value && 71 !std::is_floating_point<UnderlyingT>::value && 72 (std::is_enum<UnderlyingT>::value || 73 std::is_convertible<UnderlyingT, unsigned long long>::value); 74}; 75 76/// \brief If T is a pointer, just return it. If it is not, return T&. 77template<typename T, typename Enable = void> 78struct add_lvalue_reference_if_not_pointer { using type = T &; }; 79 80template <typename T> 81struct add_lvalue_reference_if_not_pointer< 82 T, typename std::enable_if<std::is_pointer<T>::value>::type> { 83 using type = T; 84}; 85 86/// \brief If T is a pointer to X, return a pointer to const X. If it is not, 87/// return const T. 88template<typename T, typename Enable = void> 89struct add_const_past_pointer { using type = const T; }; 90 91template <typename T> 92struct add_const_past_pointer< 93 T, typename std::enable_if<std::is_pointer<T>::value>::type> { 94 using type = const typename std::remove_pointer<T>::type *; 95}; 96 97template <typename T, typename Enable = void> 98struct const_pointer_or_const_ref { 99 using type = const T &; 100}; 101template <typename T> 102struct const_pointer_or_const_ref< 103 T, typename std::enable_if<std::is_pointer<T>::value>::type> { 104 using type = typename add_const_past_pointer<T>::type; 105}; 106 107} // end namespace llvm 108 109// If the compiler supports detecting whether a class is final, define 110// an LLVM_IS_FINAL macro. If it cannot be defined properly, this 111// macro will be left undefined. 112#if __cplusplus >= 201402L 113#define LLVM_IS_FINAL(Ty) std::is_final<Ty>() 114#elif __has_feature(is_final) || LLVM_GNUC_PREREQ(4, 7, 0) 115#define LLVM_IS_FINAL(Ty) __is_final(Ty) 116#endif 117 118#ifdef LLVM_DEFINED_HAS_FEATURE 119#undef __has_feature 120#endif 121 122#endif // LLVM_SUPPORT_TYPE_TRAITS_H 123