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

refs #403 reimplement maybe methods with type dependent templates

Browse Source
This commit is contained in:
Roland Winklmeier
2015-04-10 21:47:59 +02:00
parent b8ae30f40c
commit 64cd22b3a3
3 changed files with 46 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
build.pri
View File

@@ -74,7 +74,7 @@ contains(BLACK_CONFIG, ProfileRelease) {
# Needed to workaround C1128 error # Needed to workaround C1128 error
# TODO check whether this is still needed after CValueObject refactoring # TODO check whether this is still needed after CValueObject refactoring
win32-msvc*: equals(WORD_SIZE,64): QMAKE_CXXFLAGS *= /bigobj win32-msvc*: QMAKE_CXXFLAGS *= /bigobj
########################### ###########################
# No incremental build # No incremental build

51
src/blackmisc/valueobject.h
View File

@@ -361,13 +361,13 @@ namespace BlackMisc
//! Virtual method to return QVariant, used with DBus QVariant lists //! Virtual method to return QVariant, used with DBus QVariant lists
virtual QVariant toQVariant() const virtual QVariant toQVariant() const
{ {
return maybeToQVariant(IsRegisteredQMetaType<Derived>()); return maybeToQVariant<Derived>();
} }
//! Set from QVariant //! Set from QVariant
virtual void convertFromQVariant(const QVariant &variant) virtual void convertFromQVariant(const QVariant &variant)
{ {
return maybeConvertFromQVariant(variant, IsRegisteredQMetaType<Derived>()); return maybeConvertFromQVariant<Derived>(variant);
} }
//! Set property by index //! Set property by index
@@ -412,7 +412,7 @@ namespace BlackMisc
//! Returns the Qt meta type ID of this object. //! Returns the Qt meta type ID of this object.
virtual int getMetaTypeId() const virtual int getMetaTypeId() const
{ {
return maybeGetMetaTypeId(IsRegisteredQMetaType<Derived>()); return maybeGetMetaTypeId<Derived>();
} }
/*! /*!
@@ -422,7 +422,7 @@ namespace BlackMisc
virtual bool isA(int metaTypeId) const virtual bool isA(int metaTypeId) const
{ {
if (metaTypeId == QMetaType::UnknownType) { return false; } if (metaTypeId == QMetaType::UnknownType) { return false; }
if (metaTypeId == maybeGetMetaTypeId(IsRegisteredQMetaType<Derived>())) { return true; } if (metaTypeId == maybeGetMetaTypeId<Derived>()) { return true; }
return BaseOrDummy::isA(metaTypeId); return BaseOrDummy::isA(metaTypeId);
} }
@@ -445,13 +445,42 @@ namespace BlackMisc
Derived *derived() { return static_cast<Derived *>(this); } Derived *derived() { return static_cast<Derived *>(this); }
// fallbacks in case Derived is not a registered meta type // fallbacks in case Derived is not a registered meta type
template <class T> using IsRegisteredQMetaType = std::integral_constant<bool, QMetaTypeId<T>::Defined>;
static int maybeGetMetaTypeId(std::true_type) { return qMetaTypeId<Derived>(); } template <typename T, typename std::enable_if<!QMetaTypeId2<T>::Defined>::type* = nullptr>
static int maybeGetMetaTypeId(std::false_type) { return QMetaType::UnknownType; } static int maybeGetMetaTypeId()
QVariant maybeToQVariant(std::true_type) const { return QVariant::fromValue(*derived()); } {
QVariant maybeToQVariant(std::false_type) const { return {}; } return QMetaType::UnknownType;
void maybeConvertFromQVariant(const QVariant &variant, std::true_type) { BlackMisc::setFromQVariant(derived(), variant); } }
void maybeConvertFromQVariant(const QVariant &variant, std::false_type) { Q_UNUSED(variant); }
template <class T, typename std::enable_if<QMetaTypeId2<T>::Defined>::type* = nullptr>
static int maybeGetMetaTypeId()
{
return qMetaTypeId<T>();
}
template <class T, typename std::enable_if<!QMetaTypeId2<T>::Defined>::type* = nullptr>
QVariant maybeToQVariant() const
{
return {};
}
template <class T, typename std::enable_if<QMetaTypeId2<T>::Defined>::type* = nullptr>
QVariant maybeToQVariant() const
{
return QVariant::fromValue(*derived());
}
template <class T, typename std::enable_if<!QMetaTypeId2<T>::Defined>::type* = nullptr>
void maybeConvertFromQVariant(const QVariant &variant)
{
Q_UNUSED(variant);
}
template <class T, typename std::enable_if<QMetaTypeId2<T>::Defined>::type* = nullptr>
void maybeConvertFromQVariant(const QVariant &variant)
{
BlackMisc::setFromQVariant(derived(), variant);
}
}; };
} // namespace } // namespace

11
src/blackmisc/valueobject_policy.h
View File

@@ -58,12 +58,11 @@ namespace BlackMisc
static void registerImpl() { QMetaTypeAndDBusOnly::registerImpl<T>(); maybeRegisterMetaValueType<T>(); } static void registerImpl() { QMetaTypeAndDBusOnly::registerImpl<T>(); maybeRegisterMetaValueType<T>(); }
private: private:
template <class T> // FIXME use TemplateIsBaseOf
static void maybeRegisterMetaValueType() { maybeRegisterMetaValueType<T>(std::is_base_of<CEmpty, T>()); } // FIXME use TemplateIsBaseOf template <class T, typename std::enable_if<std::is_base_of<CEmpty, T>::value>::type* = nullptr>
template <class T> static void maybeRegisterMetaValueType() { BlackMisc::registerMetaValueType<T>(); }
static void maybeRegisterMetaValueType(std::true_type) { BlackMisc::registerMetaValueType<T>(); } template <class T, typename std::enable_if<!std::is_base_of<CEmpty, T>::value>::type* = nullptr>
template <class T> static void maybeRegisterMetaValueType() {}
static void maybeRegisterMetaValueType(std::false_type) {}
}; };
//! CValueObject registerMetadata policy which inherits the policy of the base class //! CValueObject registerMetadata policy which inherits the policy of the base class