1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove compiler-specific implementations of Q_IS_ENUM

Browse Source 
Since the macro is now just a wrapper for std::is_enum,
its use is also deprecated.

[ChangeLog][QtCore][Global] Q_IS_ENUM is deprecated.
Use std::is_enum<>::value instead.

Change-Id: I09b9f4559c02c81f338cace927873318f2acafde
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
This commit is contained in:
Kai Koehne 2016-08-08 09:05:53 +02:00
parent b64fc69d1c
commit 5c3b16706f
6 changed files with 7 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/corelib/global/qisenum.h
View File

@ -42,21 +42,8 @@
#ifndef QISENUM_H
#define QISENUM_H
#ifndef Q_IS_ENUM
# if defined(Q_CC_GNU) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
# define Q_IS_ENUM(x) __is_enum(x)
# elif defined(Q_CC_MSVC) && defined(_MSC_FULL_VER) && (_MSC_FULL_VER >=140050215)
# define Q_IS_ENUM(x) __is_enum(x)
# elif defined(Q_CC_CLANG)
# if __has_extension(is_enum)
# define Q_IS_ENUM(x) __is_enum(x)
# endif
# endif
#endif
#ifndef Q_IS_ENUM
# define Q_IS_ENUM(x) std::is_enum<x>::value
#endif
// Use of Q_IS_ENUM is deprecated since 5.8
#define Q_IS_ENUM(x) std::is_enum<x>::value
// shut up syncqt
QT_BEGIN_NAMESPACE

6
src/corelib/global/qtypeinfo.h
View File

@ -38,13 +38,11 @@
**
****************************************************************************/
#include <QtCore/qisenum.h>
#include <QtCore/qglobal.h>
#ifndef QTYPEINFO_H
#define QTYPEINFO_H
#include <QtCore/qglobal.h>
QT_BEGIN_NAMESPACE
/*
@ -64,7 +62,7 @@ public:
isIntegral = std::is_integral<T>::value,
isComplex = true,
isStatic = true,
isRelocatable = Q_IS_ENUM(T),
isRelocatable = std::is_enum<T>::value,
isLarge = (sizeof(T)>sizeof(void*)),
isDummy = false, //### Qt6: remove
sizeOf = sizeof(T)

3
src/corelib/kernel/qmetatype.h
View File

@ -45,7 +45,6 @@
#include <QtCore/qatomic.h>
#include <QtCore/qbytearray.h>
#include <QtCore/qvarlengtharray.h>
#include <QtCore/qisenum.h>
#ifndef QT_NO_QOBJECT
#include <QtCore/qobjectdefs.h>
#endif
@ -1635,7 +1634,7 @@ namespace QtPrivate {
| (IsSharedPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::SharedPointerToQObject : 0)
| (IsWeakPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::WeakPointerToQObject : 0)
| (IsTrackingPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::TrackingPointerToQObject : 0)
| (Q_IS_ENUM(T) ? QMetaType::IsEnumeration : 0)
| (std::is_enum<T>::value ? QMetaType::IsEnumeration : 0)
| (IsGadgetHelper<T>::Value ? QMetaType::IsGadget : 0)
};
};

2
src/corelib/kernel/qvariant_p.h
View File

@ -65,7 +65,7 @@ template<typename T>
struct QVariantIntegrator
{
static const bool CanUseInternalSpace = sizeof(T) <= sizeof(QVariant::Private::Data)
&& ((QTypeInfoQuery<T>::isRelocatable) || Q_IS_ENUM(T));
&& ((QTypeInfoQuery<T>::isRelocatable) || std::is_enum<T>::value);
typedef std::integral_constant<bool, CanUseInternalSpace> CanUseInternalSpace_t;
};
Q_STATIC_ASSERT(QVariantIntegrator<double>::CanUseInternalSpace);

95
tests/auto/corelib/global/qglobal/tst_qglobal.cpp
View File

@ -48,7 +48,6 @@ private slots:
void qConstructorFunction();
void qCoreAppStartupFunction();
void qCoreAppStartupFunctionRestart();
void isEnum();
void qAlignOf();
void integerForSize();
void qprintable();
@ -365,100 +364,6 @@ public:
enum AnEnum {};
};
#if defined (Q_COMPILER_CLASS_ENUM)
enum class isEnum_G : qint64 {};
#endif
void tst_QGlobal::isEnum()
{
#if defined (Q_CC_MSVC)
#define IS_ENUM_TRUE(x) (Q_IS_ENUM(x) == true)
#define IS_ENUM_FALSE(x) (Q_IS_ENUM(x) == false)
#else
#define IS_ENUM_TRUE(x) (Q_IS_ENUM(x) == true && std::is_enum<x>::value == true)
#define IS_ENUM_FALSE(x) (Q_IS_ENUM(x) == false && std::is_enum<x>::value == false)
#endif
QVERIFY(IS_ENUM_TRUE(isEnum_B_Byte));
QVERIFY(IS_ENUM_TRUE(const isEnum_B_Byte));
QVERIFY(IS_ENUM_TRUE(volatile isEnum_B_Byte));
QVERIFY(IS_ENUM_TRUE(const volatile isEnum_B_Byte));
QVERIFY(IS_ENUM_TRUE(isEnum_B_Short));
QVERIFY(IS_ENUM_TRUE(const isEnum_B_Short));
QVERIFY(IS_ENUM_TRUE(volatile isEnum_B_Short));
QVERIFY(IS_ENUM_TRUE(const volatile isEnum_B_Short));
QVERIFY(IS_ENUM_TRUE(isEnum_B_Int));
QVERIFY(IS_ENUM_TRUE(const isEnum_B_Int));
QVERIFY(IS_ENUM_TRUE(volatile isEnum_B_Int));
QVERIFY(IS_ENUM_TRUE(const volatile isEnum_B_Int));
QVERIFY(IS_ENUM_TRUE(isEnum_F::AnEnum));
QVERIFY(IS_ENUM_TRUE(const isEnum_F::AnEnum));
QVERIFY(IS_ENUM_TRUE(volatile isEnum_F::AnEnum));
QVERIFY(IS_ENUM_TRUE(const volatile isEnum_F::AnEnum));
QVERIFY(IS_ENUM_FALSE(void));
QVERIFY(IS_ENUM_FALSE(isEnum_B_Byte &));
QVERIFY(IS_ENUM_FALSE(isEnum_B_Byte[1]));
QVERIFY(IS_ENUM_FALSE(const isEnum_B_Byte[1]));
QVERIFY(IS_ENUM_FALSE(isEnum_B_Byte[]));
QVERIFY(IS_ENUM_FALSE(int));
QVERIFY(IS_ENUM_FALSE(float));
QVERIFY(IS_ENUM_FALSE(isEnum_A));
QVERIFY(IS_ENUM_FALSE(isEnum_A *));
QVERIFY(IS_ENUM_FALSE(const isEnum_A));
QVERIFY(IS_ENUM_FALSE(isEnum_C));
QVERIFY(IS_ENUM_FALSE(isEnum_D));
QVERIFY(IS_ENUM_FALSE(isEnum_E));
QVERIFY(IS_ENUM_FALSE(void()));
QVERIFY(IS_ENUM_FALSE(void(*)()));
QVERIFY(IS_ENUM_FALSE(int isEnum_A::*));
QVERIFY(IS_ENUM_FALSE(void (isEnum_A::*)()));
QVERIFY(IS_ENUM_FALSE(size_t));
QVERIFY(IS_ENUM_FALSE(bool));
QVERIFY(IS_ENUM_FALSE(wchar_t));
QVERIFY(IS_ENUM_FALSE(char));
QVERIFY(IS_ENUM_FALSE(unsigned char));
QVERIFY(IS_ENUM_FALSE(short));
QVERIFY(IS_ENUM_FALSE(unsigned short));
QVERIFY(IS_ENUM_FALSE(int));
QVERIFY(IS_ENUM_FALSE(unsigned int));
QVERIFY(IS_ENUM_FALSE(long));
QVERIFY(IS_ENUM_FALSE(unsigned long));
QVERIFY(IS_ENUM_FALSE(qint8));
QVERIFY(IS_ENUM_FALSE(quint8));
QVERIFY(IS_ENUM_FALSE(qint16));
QVERIFY(IS_ENUM_FALSE(quint16));
QVERIFY(IS_ENUM_FALSE(qint32));
QVERIFY(IS_ENUM_FALSE(quint32));
QVERIFY(IS_ENUM_FALSE(qint64));
QVERIFY(IS_ENUM_FALSE(quint64));
QVERIFY(IS_ENUM_FALSE(void *));
QVERIFY(IS_ENUM_FALSE(int *));
#if defined (Q_COMPILER_UNICODE_STRINGS)
QVERIFY(IS_ENUM_FALSE(char16_t));
QVERIFY(IS_ENUM_FALSE(char32_t));
#endif
#if defined (Q_COMPILER_CLASS_ENUM)
// Strongly type class enums are not handled by the
// fallback type traits implementation. Any compiler
// supported by Qt that supports C++0x class enums
// should also support the __is_enum intrinsic.
QVERIFY(Q_IS_ENUM(isEnum_G));
#endif
#undef IS_ENUM_TRUE
#undef IS_ENUM_FALSE
}
struct Empty {};
template <class T> struct AlignmentInStruct { T dummy; };

2
tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
View File

@ -712,7 +712,7 @@ void tst_QMetaType::flags_data()
<< bool(!QTypeInfo<RealType>::isStatic) \
<< bool(QTypeInfo<RealType>::isComplex) \
<< bool(QtPrivate::IsPointerToTypeDerivedFromQObject<RealType>::Value) \
<< bool(Q_IS_ENUM(RealType));
<< bool(std::is_enum<RealType>::value);
QT_FOR_EACH_STATIC_CORE_CLASS(ADD_METATYPE_TEST_ROW)
QT_FOR_EACH_STATIC_PRIMITIVE_POINTER(ADD_METATYPE_TEST_ROW)
QT_FOR_EACH_STATIC_CORE_POINTER(ADD_METATYPE_TEST_ROW)