flightsimulatorplatfrom/pilotclient
1
0
Fork 0
mirror of https://github.com/swift-project/pilotclient.git synced 2026-03-31 21:15:33 +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

51
src/blackmisc/valueobject.h
View File

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

11
src/blackmisc/valueobject_policy.h
View File

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