flightsimulatorplatfrom/pilotclient
1
0
Fork 0
mirror of https://github.com/swift-project/pilotclient.git synced 2026-03-30 11:55:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

refs #628 Use expression SFINAE and the void_t trick to simplify some type traits.

Browse Source
This commit is contained in:
Mathew Sutcliffe
2016-03-25 19:01:07 +00:00
parent f159bdb5bf
commit 7ce1b268df
8 changed files with 117 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/blackmisc/compare.h
View File

@@ -56,6 +56,7 @@ namespace BlackMisc
}
template <typename T> static bool baseEquals(const T *a, const T *b) { return *a == *b; }
static bool baseEquals(const void *, const void *) { return true; }
static bool baseEquals(const CEmpty *, const CEmpty *) { return true; }
};
/*!
@@ -107,6 +108,7 @@ namespace BlackMisc
}
template <typename T> static bool baseLess(const T *a, const T *b) { return *a < *b; }
static bool baseLess(const void *, const void *) { return false; }
static bool baseLess(const CEmpty *, const CEmpty *) { return false; }
};
/*!
@@ -130,6 +132,7 @@ namespace BlackMisc
}
template <typename T> static int baseCompare(const T *a, const T *b) { return compare(*a, *b); }
static int baseCompare(const void *, const void *) { return 0; }
static int baseCompare(const CEmpty *, const CEmpty *) { return 0; }
};
} // Mixin

2
src/blackmisc/dbus.h
View File

@@ -84,6 +84,8 @@ namespace BlackMisc
template <typename T> static void baseUnmarshall(T *base, const QDBusArgument &arg) { base->unmarshallFromDbus(arg); }
static void baseMarshall(const void *, QDBusArgument &) {}
static void baseUnmarshall(void *, const QDBusArgument &) {}
static void baseMarshall(const CEmpty *, QDBusArgument &) {}
static void baseUnmarshall(CEmpty *, const QDBusArgument &) {}
};
/*!

27
src/blackmisc/dictionary.h
View File

@@ -18,6 +18,7 @@
#include "iterator.h"
#include "range.h"
#include "containerbase.h"
#include "typetraits.h"
#include <QHash>
#include <utility>
#include <initializer_list>
@@ -27,29 +28,6 @@ namespace BlackMisc
namespace Private
{
//! \cond PRIVATE
namespace ADL
{
struct NotFound {};
struct FromAny { template <class T> FromAny(const T &); };
NotFound operator <(const FromAny &, const FromAny &);
NotFound operator ==(const FromAny &, const FromAny &);
NotFound qHash(...);
using ::BlackMisc::qHash; // bring hidden name into scope
template <class Key>
constexpr static bool supportsQHash()
{
return ! std::is_same<decltype(std::declval<Key>() == std::declval<Key>()), NotFound>::value &&
! std::is_same<decltype(qHash(std::declval<Key>())), NotFound>::value;
};
template <class Key>
constexpr static bool supportsQMap()
{
return ! std::is_same<decltype(std::declval<Key>() < std::declval<Key>()), NotFound>::value;
};
}
template <bool KeySupportsQHash /* = true */, bool KeySupportsQMap>
struct AssociativityTraits
{
@@ -75,7 +53,7 @@ namespace BlackMisc
//! Trait to select the appropriate default associative container type depending on what the key type supports
template <typename K, typename V>
using DefaultAssociativeType = typename Private::AssociativityTraits<Private::ADL::supportsQHash<K>(), Private::ADL::supportsQMap<K>()>::template DefaultType<K, V>;
using DefaultAssociativeType = typename Private::AssociativityTraits<ModelsQHashKey<K>::value, ModelsQMapKey<K>::value>::template DefaultType<K, V>;
//! Associative container with value semantics, chooses a sensible default implementation container type
template<class Key, class Value, template <class...> class Impl = DefaultAssociativeType>
@@ -495,6 +473,7 @@ namespace BlackMisc
template <typename T> static uint baseHash(const T *base) { return qHash(*base); }
static uint baseHash(const void *) { return 0; }
static uint baseHash(const CEmpty *) { return 0; }
};
}

49
src/blackmisc/inheritancetraits.h
View File

@@ -12,35 +12,36 @@
#ifndef BLACKMISC_INHERITANCE_TRAITS_H
#define BLACKMISC_INHERITANCE_TRAITS_H
#include "typetraits.h"
#include <QMetaType>
#include <type_traits>
namespace BlackMisc
{
class CEmpty;
class CPropertyIndex;
/*!
* If T has a member typedef base_type, this trait will obtain it, otherwise void.
*/
template <class T>
class BaseOf
template <typename T, typename = void_t<>>
struct BaseOf
{
//template <typename U> static typename U::base_type *test(int);
template <typename U> static typename U::base_type *test(std::enable_if_t<! std::is_same<typename U::base_type, CEmpty>::value, int>);
template <typename U> static void *test(...);
public:
//! The declared base_type of T, or void if there is none.
using type = std::remove_pointer_t<decltype(test<T>(0))>;
using type = void; //!< void
};
//! \cond
template <typename T>
struct BaseOf<T, void_t<typename T::base_type>>
{
using type = typename T::base_type; //!< T::base_type
};
//! \endcond
/*!
* It T has a member typedef base_type which is a registered metatype, this trait will obtain it, otherwise void.
*/
template <class T>
class MetaBaseOf
struct MetaBaseOf
{
public:
//! Type of T::base_type, or void if not declared.
using type = std::conditional_t<QMetaTypeId<typename BaseOf<T>::type>::Defined, typename BaseOf<T>::type, void>;
};
@@ -48,22 +49,18 @@ namespace BlackMisc
/*!
* If T has a member typedef base_type which has a member propertyByIndex, this trait will obtain it, otherwise void.
*/
template <class T>
class IndexBaseOf
template <typename T, typename = void_t<>>
struct IndexBaseOf
{
// http://en.wikibooks.org/wiki/More_C++_Idioms/Member_Detector
struct Empty {};
struct Fallback { int propertyByIndex; };
template <int Fallback:: *> struct int_t { using type = int; };
template <typename U> struct Derived : public Fallback, public std::conditional_t<std::is_void<U>::value, Empty, U> {};
template <typename U> static void test(typename int_t<&Derived<U>::propertyByIndex>::type);
template <typename U> static U test(...);
public:
//! Type of T::base_type, or void if not declared.
using type = decltype(test<typename BaseOf<T>::type>(0));
using type = void; //!< void
};
//! \cond
template <typename T>
struct IndexBaseOf<T, void_t<decltype(std::declval<typename T::base_type>().propertyByIndex(std::declval<CPropertyIndex>()))>>
{
using type = typename T::base_type; //!< T::base_type
};
//! \endcond
/*!
* Alias for typename BaseOf<T>::type.

2
src/blackmisc/json.h
View File

@@ -282,6 +282,8 @@ namespace BlackMisc
template <typename T> static void baseConvertFromJson(T *base, const QJsonObject &json) { base->convertFromJson(json); }
static QJsonObject baseToJson(const void *) { return {}; }
static void baseConvertFromJson(void *, const QJsonObject &) {}
static QJsonObject baseToJson(const CEmpty *) { return {}; }
static void baseConvertFromJson(CEmpty *, const QJsonObject &) {}
};
/*!

18
src/blackmisc/logcategorylist.h
View File

@@ -16,6 +16,7 @@
#include "logcategory.h"
#include "sequence.h"
#include "collection.h"
#include "typetraits.h"
#include <QObject>
#include <QThreadStorage>
#include <type_traits>
@@ -23,21 +24,6 @@
namespace BlackMisc
{
namespace Private
{
//! \private Trait to detect whether a class T has a member function called getLogCategories
template <class T> class HasGetLogCategories
{
struct Base { int getLogCategories; };
struct Derived : T, Base {};
template <typename U, U> struct TypeCheck {};
template <typename U> static std::false_type test(TypeCheck<decltype(&Base::getLogCategories), &U::getLogCategories> *);
template <typename U> static std::true_type test(...);
public:
using type = decltype(test<Derived>(nullptr));
};
}
/*!
* A sequence of log categories.
*/
@@ -117,7 +103,7 @@ namespace BlackMisc
static QThreadStorage<CLogCategoryList> list;
if (! list.hasLocalData())
{
list.localData().appendCategoriesFromMemberFunction(tag<T>(), typename Private::HasGetLogCategories<T>::type());
list.localData().appendCategoriesFromMemberFunction(tag<T>(), HasGetLogCategories<T>());
list.localData().appendCategoriesFromMetaType(tag<T>(), std::integral_constant<bool, QMetaTypeId<T>::Defined>());
list.localData().appendCategoriesFromMetaObject(tag<T>(), std::is_base_of<QObject, T>());
if (list.localData().isEmpty()) { list.localData().push_back(CLogCategory::uncategorized()); }

20
src/blackmisc/statusmessage.h
View File

@@ -17,6 +17,7 @@
#include "propertyindex.h"
#include "logcategorylist.h"
#include "timestampbased.h"
#include "typetraits.h"
#include <QReadWriteLock>
namespace BlackMisc
@@ -29,25 +30,6 @@ namespace BlackMisc
BLACKMISC_EXPORT QString arg(const QString &format, const QStringList &args);
}
/*!
* Trait to detect whether T contains a member toQString.
*/
template <typename T>
class HasToQString
{
// http://en.wikibooks.org/wiki/More_C++_Idioms/Member_Detector
struct Fallback { int toQString; };
template <int Fallback:: *> struct int_t { using type = int; };
template <typename U, bool = std::is_class<U>::value> struct Derived : public U, public Fallback {};
template <typename U> struct Derived<U, false> : public Fallback {};
template <typename U> static char test(typename int_t<&Derived<U>::toQString>::type);
template <typename U> static int test(...);
public:
//! True if T contains a member toQString.
static const bool value = sizeof(test<T>(0)) > 1;
};
/*!
* Status severities
*/

81
src/blackmisc/typetraits.h Normal file
View File

@@ -0,0 +1,81 @@
/* Copyright (C) 2016
* swift Project Community / Contributors
*
* This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
* directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
* including this file, may be copied, modified, propagated, or distributed except according to the terms
* contained in the LICENSE file.
*/
//! \file
#ifndef BLACKMISC_TYPETRAITS_H
#define BLACKMISC_TYPETRAITS_H
#if defined(Q_CC_CLANG) || (defined(Q_CC_GNU) && __GNUC__ >= 5)
#define BLACK_HAS_FIXED_CWG1558
#endif
namespace BlackMisc
{
//! \cond PRIVATE
#ifdef BLACK_HAS_FIXED_CWG1558
// Own implementation of C++17 std::void_t, simple variadic alias
// template which is always void. Useful for expression SFINAE.
template <typename...>
using void_t = void;
#else // Work around defect in the C++ standard
namespace Private
{
template <typename...>
struct make_void { using type = void; };
}
template <typename... Ts>
using void_t = typename Private::make_void<Ts...>::type;
#endif
//! \endcond
/*!
* Trait to detect whether T contains a member function toQString.
*/
template <typename T, typename = void_t<>>
struct HasToQString : public std::false_type {};
//! \cond
template <typename T>
struct HasToQString<T, void_t<decltype(std::declval<T>().toQString())>> : public std::true_type {};
//! \endcond
/*!
* Trait to detect whether a class T has a static member function named getLogCategories.
*/
template <typename T, typename = void_t<>>
struct HasGetLogCategories : public std::false_type {};
//! \cond
template <typename T>
struct HasGetLogCategories<T, void_t<decltype(T::getLogCategories())>> : public std::true_type {};
//! \endcond
/*!
* Trait to detect whether a class T can be used as a key in a QHash.
*/
template <typename T, typename = void_t<>>
struct ModelsQHashKey : public std::false_type {};
//! \cond
template <typename T>
struct ModelsQHashKey<T, void_t<decltype(std::declval<T>() == std::declval<T>(), qHash(std::declval<T>()))>> : public std::true_type {};
//! \endcond
/*!
* Trait to detect whether a class T can be used as a key in a QMap.
*/
template <typename T, typename = void_t<>>
struct ModelsQMapKey : public std::false_type {};
//! \cond
template <typename T>
struct ModelsQMapKey<T, void_t<decltype(std::declval<T>() < std::declval<T>())>> : public std::true_type {};
//! \endcond
}
#endif