Reduce QtCore lib binary size by around ~3KB, by removing template code

Reusing a template is much better then creating a new one, even if it
should inline the same code.

For some reason replacing T* by void* force gcc to remove a few bytes
per template instantiation too, it is not really significant, but it
alows us to simplify the code.

Benchmarks don't show any regressions.

Change-Id: I4fdf1e4dc311b23021eb5758605602937d05b183
Reviewed-by: Bradley T. Hughes <bradley.hughes@nokia.com>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

1 files changed, 27 insertions, 39 deletions

diff --git a/src/corelib/kernel/qmetatype.h b/src/corelib/kernel/qmetatype.h
index 4af77fcedc..4e75e1414b 100644
--- a/src/corelib/kernel/qmetatype.h
+++ b/src/corelib/kernel/qmetatype.h
@@ -318,46 +318,57 @@ private:
 Q_DECLARE_OPERATORS_FOR_FLAGS(QMetaType::TypeFlags)
 
 template <typename T>
-void qMetaTypeDeleteHelper(T *t)
+void qMetaTypeDeleteHelper(void *t)
 {
-    delete t;
+    delete static_cast<T*>(t);
 }
+template <> inline void qMetaTypeDeleteHelper<void>(void *) {}
 
 template <typename T>
-void *qMetaTypeCreateHelper(const T *t)
+void *qMetaTypeCreateHelper(const void *t)
 {
     if (t)
         return new T(*static_cast<const T*>(t));
     return new T();
 }
 
+template <> inline void *qMetaTypeCreateHelper<void>(const void *) { return 0; }
+
 template <typename T>
-void qMetaTypeDestructHelper(T *t)
+void qMetaTypeDestructHelper(void *t)
 {
     Q_UNUSED(t) // Silence MSVC that warns for POD types.
-    t->~T();
+    static_cast<T*>(t)->~T();
 }
 
+template <> inline void qMetaTypeDestructHelper<void>(void *) {}
+
 template <typename T>
-void *qMetaTypeConstructHelper(void *where, const T *t)
+void *qMetaTypeConstructHelper(void *where, const void *t)
 {
     if (t)
         return new (where) T(*static_cast<const T*>(t));
     return new (where) T;
 }
 
+template <> inline void *qMetaTypeConstructHelper<void>(void *, const void *) { return 0; }
+
 #ifndef QT_NO_DATASTREAM
 template <typename T>
-void qMetaTypeSaveHelper(QDataStream &stream, const T *t)
+void qMetaTypeSaveHelper(QDataStream &stream, const void *t)
 {
-    stream << *t;
+    stream << *static_cast<const T*>(t);
 }
 
+template <> inline void qMetaTypeSaveHelper<void>(QDataStream &, const void *) {}
+
 template <typename T>
-void qMetaTypeLoadHelper(QDataStream &stream, T *t)
+void qMetaTypeLoadHelper(QDataStream &stream, void *t)
 {
-    stream >> *t;
+    stream >> *static_cast<T*>(t);
 }
+
+template <> inline void qMetaTypeLoadHelper<void>(QDataStream &, void *) {}
 #endif // QT_NO_DATASTREAM
 
 template <typename T>
@@ -442,15 +453,6 @@ int qRegisterMetaType(const char *typeName
     if (typedefOf != -1)
         return QMetaType::registerTypedef(typeName, typedefOf);
 
-    typedef void*(*CreatePtr)(const T*);
-    CreatePtr cptr = qMetaTypeCreateHelper<T>;
-    typedef void(*DeletePtr)(T*);
-    DeletePtr dptr = qMetaTypeDeleteHelper<T>;
-    typedef void*(*ConstructPtr)(void *, const T*);
-    ConstructPtr ipcptr = qMetaTypeConstructHelper<T>;
-    typedef void(*DestructPtr)(T*);
-    DestructPtr ipdptr = qMetaTypeDestructHelper<T>;
-
     QMetaType::TypeFlags flags;
     if (!QTypeInfo<T>::isStatic)
         flags |= QMetaType::MovableType;
@@ -461,10 +463,10 @@ int qRegisterMetaType(const char *typeName
     if (QtPrivate::IsPointerToTypeDerivedFromQObject<T>::Value)
         flags |= QMetaType::PointerToQObject;
 
-    return QMetaType::registerType(typeName, reinterpret_cast<QMetaType::Deleter>(dptr),
-                                   reinterpret_cast<QMetaType::Creator>(cptr),
-                                   reinterpret_cast<QMetaType::Destructor>(ipdptr),
-                                   reinterpret_cast<QMetaType::Constructor>(ipcptr),
+    return QMetaType::registerType(typeName, qMetaTypeDeleteHelper<T>,
+                                   qMetaTypeCreateHelper<T>,
+                                   qMetaTypeDestructHelper<T>,
+                                   qMetaTypeConstructHelper<T>,
                                    sizeof(T),
                                    flags);
 }
@@ -477,14 +479,8 @@ void qRegisterMetaTypeStreamOperators(const char *typeName
 #endif
 )
 {
-    typedef void(*SavePtr)(QDataStream &, const T *);
-    typedef void(*LoadPtr)(QDataStream &, T *);
-    SavePtr sptr = qMetaTypeSaveHelper<T>;
-    LoadPtr lptr = qMetaTypeLoadHelper<T>;
-
     qRegisterMetaType<T>(typeName);
-    QMetaType::registerStreamOperators(typeName, reinterpret_cast<QMetaType::SaveOperator>(sptr),
-                                       reinterpret_cast<QMetaType::LoadOperator>(lptr));
+    QMetaType::registerStreamOperators(typeName, qMetaTypeSaveHelper<T>, qMetaTypeLoadHelper<T>);
 }
 #endif // QT_NO_DATASTREAM
 
@@ -516,16 +512,8 @@ inline int qRegisterMetaType(
 template <typename T>
 inline int qRegisterMetaTypeStreamOperators()
 {
-    typedef void(*SavePtr)(QDataStream &, const T *);
-    typedef void(*LoadPtr)(QDataStream &, T *);
-    SavePtr sptr = qMetaTypeSaveHelper<T>;
-    LoadPtr lptr = qMetaTypeLoadHelper<T>;
-
     register int id = qMetaTypeId<T>();
-    QMetaType::registerStreamOperators(id,
-                                       reinterpret_cast<QMetaType::SaveOperator>(sptr),
-                                       reinterpret_cast<QMetaType::LoadOperator>(lptr));
-
+    QMetaType::registerStreamOperators(id, qMetaTypeSaveHelper<T>, qMetaTypeLoadHelper<T>);
     return id;
 }
 #endif