From 64cd22b3a362c564137cb677fd0671f37f436ba5 Mon Sep 17 00:00:00 2001
From: Roland Winklmeier <Roland.M.Winklmeier@gmail.com>
Date: Fri, 10 Apr 2015 21:47:59 +0200
Subject: [PATCH] refs #403 reimplement maybe methods with type dependent
 templates

---
 build.pri                          |  2 +-
 src/blackmisc/valueobject.h        | 51 +++++++++++++++++++++++-------
 src/blackmisc/valueobject_policy.h | 11 +++----
 3 files changed, 46 insertions(+), 18 deletions(-)

diff --git a/build.pri b/build.pri
index 9337d84a3..d8256c3f0 100644
--- a/build.pri
+++ b/build.pri
@@ -74,7 +74,7 @@ contains(BLACK_CONFIG, ProfileRelease) {
 
 # Needed to workaround C1128 error
 # 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
diff --git a/src/blackmisc/valueobject.h b/src/blackmisc/valueobject.h
index 4eddd3aac..c2af80bdd 100644
--- a/src/blackmisc/valueobject.h
+++ b/src/blackmisc/valueobject.h
@@ -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
diff --git a/src/blackmisc/valueobject_policy.h b/src/blackmisc/valueobject_policy.h
index 3f2953990..793e84407 100644
--- a/src/blackmisc/valueobject_policy.h
+++ b/src/blackmisc/valueobject_policy.h
@@ -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