diff options
Diffstat (limited to 'src/corelib/global/qtypeinfo.h')
-rw-r--r-- | src/corelib/global/qtypeinfo.h | 79 |
1 files changed, 61 insertions, 18 deletions
diff --git a/src/corelib/global/qtypeinfo.h b/src/corelib/global/qtypeinfo.h index 73bf6140c7..255a2b33c6 100644 --- a/src/corelib/global/qtypeinfo.h +++ b/src/corelib/global/qtypeinfo.h @@ -2,14 +2,16 @@ // Copyright (C) 2016 Intel Corporation. // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only -#include <QtCore/qglobal.h> +#ifndef QTYPEINFO_H +#define QTYPEINFO_H + +#include <QtCore/qcompilerdetection.h> #include <QtCore/qcontainerfwd.h> + #include <variant> #include <optional> #include <tuple> - -#ifndef QTYPEINFO_H -#define QTYPEINFO_H +#include <type_traits> QT_BEGIN_NAMESPACE @@ -19,9 +21,30 @@ class QDebug; QTypeInfo - type trait functionality */ +namespace QtPrivate { + +// A trivially copyable class must also have a trivial, non-deleted +// destructor [class.prop/1.3], CWG1734. Some implementations don't +// check for a trivial destructor, because of backwards compatibility +// with C++98's definition of trivial copyability. +// Since trivial copiability has implications for the ABI, implementations +// can't "just fix" their traits. So, although formally redundant, we +// explicitly check for trivial destruction here. template <typename T> inline constexpr bool qIsRelocatable = std::is_trivially_copyable_v<T> && std::is_trivially_destructible_v<T>; +// Denotes types that are trivially default constructible, and for which +// value-initialization can be achieved by filling their storage with 0 bits. +// There is no type trait we can use for this, so we hardcode a list of +// possibilities that we know are OK on the architectures that we support. +// The most notable exception are pointers to data members, which for instance +// on the Itanium ABI are initialized to -1. +template <typename T> +inline constexpr bool qIsValueInitializationBitwiseZero = + std::is_scalar_v<T> && !std::is_member_object_pointer_v<T>; + +} + /* The catch-all template. */ @@ -31,10 +54,11 @@ class QTypeInfo { public: enum { - isPointer = std::is_pointer_v<T>, - isIntegral = std::is_integral_v<T>, + isPointer [[deprecated("Use std::is_pointer instead")]] = std::is_pointer_v<T>, + isIntegral [[deprecated("Use std::is_integral instead")]] = std::is_integral_v<T>, isComplex = !std::is_trivial_v<T>, - isRelocatable = qIsRelocatable<T>, + isRelocatable = QtPrivate::qIsRelocatable<T>, + isValueInitializationBitwiseZero = QtPrivate::qIsValueInitializationBitwiseZero<T>, }; }; @@ -43,10 +67,11 @@ class QTypeInfo<void> { public: enum { - isPointer = false, - isIntegral = false, + isPointer [[deprecated("Use std::is_pointer instead")]] = false, + isIntegral [[deprecated("Use std::is_integral instead")]] = false, isComplex = false, isRelocatable = false, + isValueInitializationBitwiseZero = false, }; }; @@ -77,20 +102,33 @@ class QTypeInfoMerger public: static constexpr bool isComplex = ((QTypeInfo<Ts>::isComplex) || ...); static constexpr bool isRelocatable = ((QTypeInfo<Ts>::isRelocatable) && ...); - static constexpr bool isPointer = false; - static constexpr bool isIntegral = false; + [[deprecated("Use std::is_pointer instead")]] static constexpr bool isPointer = false; + [[deprecated("Use std::is_integral instead")]] static constexpr bool isIntegral = false; + static constexpr bool isValueInitializationBitwiseZero = false; + static_assert(!isRelocatable || + std::is_copy_constructible_v<T> || + std::is_move_constructible_v<T>, + "All Ts... are Q_RELOCATABLE_TYPE, but T is neither copy- nor move-constructible, " + "so cannot be Q_RELOCATABLE_TYPE. Please mark T as Q_COMPLEX_TYPE manually."); }; +// QTypeInfo for std::pair: +// std::pair is spec'ed to be struct { T1 first; T2 second; }, so, unlike tuple<>, +// we _can_ specialize QTypeInfo for pair<>: +template <class T1, class T2> +class QTypeInfo<std::pair<T1, T2>> : public QTypeInfoMerger<std::pair<T1, T2>, T1, T2> {}; + #define Q_DECLARE_MOVABLE_CONTAINER(CONTAINER) \ template <typename ...T> \ class QTypeInfo<CONTAINER<T...>> \ { \ public: \ enum { \ - isPointer = false, \ - isIntegral = false, \ + isPointer [[deprecated("Use std::is_pointer instead")]] = false, \ + isIntegral [[deprecated("Use std::is_integral instead")]] = false, \ isComplex = true, \ isRelocatable = true, \ + isValueInitializationBitwiseZero = false, \ }; \ } @@ -128,10 +166,15 @@ class QTypeInfo<TYPE > \ public: \ enum { \ isComplex = (((FLAGS) & Q_PRIMITIVE_TYPE) == 0) && !std::is_trivial_v<TYPE>, \ - isRelocatable = !isComplex || ((FLAGS) & Q_RELOCATABLE_TYPE) || qIsRelocatable<TYPE>, \ - isPointer = false, \ - isIntegral = std::is_integral< TYPE >::value, \ + isRelocatable = !isComplex || ((FLAGS) & Q_RELOCATABLE_TYPE) || QtPrivate::qIsRelocatable<TYPE>, \ + isPointer [[deprecated("Use std::is_pointer instead")]] = std::is_pointer_v< TYPE >, \ + isIntegral [[deprecated("Use std::is_integral instead")]] = std::is_integral< TYPE >::value, \ + isValueInitializationBitwiseZero = QtPrivate::qIsValueInitializationBitwiseZero<TYPE>, \ }; \ + static_assert(!isRelocatable || \ + std::is_copy_constructible_v<TYPE > || \ + std::is_move_constructible_v<TYPE >, \ + #TYPE " is neither copy- nor move-constructible, so cannot be Q_RELOCATABLE_TYPE"); \ } #define Q_DECLARE_TYPEINFO(TYPE, FLAGS) \ @@ -211,7 +254,7 @@ using expand_operator_equal_recursive = std::conjunction<expand_operator_equal<T template<typename T> struct expand_operator_equal_tuple : has_operator_equal<T> {}; template<typename T> -struct expand_operator_equal_tuple<std::optional<T>> : has_operator_equal<T> {}; +struct expand_operator_equal_tuple<std::optional<T>> : expand_operator_equal_recursive<T> {}; template<typename T1, typename T2> struct expand_operator_equal_tuple<std::pair<T1, T2>> : expand_operator_equal_recursive<T1, T2> {}; template<typename ...T> @@ -251,7 +294,7 @@ using expand_operator_less_than_recursive = std::conjunction<expand_operator_les template<typename T> struct expand_operator_less_than_tuple : has_operator_less_than<T> {}; template<typename T> -struct expand_operator_less_than_tuple<std::optional<T>> : has_operator_less_than<T> {}; +struct expand_operator_less_than_tuple<std::optional<T>> : expand_operator_less_than_recursive<T> {}; template<typename T1, typename T2> struct expand_operator_less_than_tuple<std::pair<T1, T2>> : expand_operator_less_than_recursive<T1, T2> {}; template<typename ...T> |