src/corelib/kernel/qmetatype.cpp

Go to the documentation of this file.
00001 /****************************************************************************
00002 **
00003 ** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
00004 **
00005 ** This file is part of the QtCore module of the Qt Toolkit.
00006 **
00007 ** This file may be used under the terms of the GNU General Public
00008 ** License version 2.0 as published by the Free Software Foundation
00009 ** and appearing in the file LICENSE.GPL included in the packaging of
00010 ** this file.  Please review the following information to ensure GNU
00011 ** General Public Licensing requirements will be met:
00012 ** http://www.trolltech.com/products/qt/opensource.html
00013 **
00014 ** If you are unsure which license is appropriate for your use, please
00015 ** review the following information:
00016 ** http://www.trolltech.com/products/qt/licensing.html or contact the
00017 ** sales department at sales@trolltech.com.
00018 **
00019 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
00020 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
00021 **
00022 ****************************************************************************/
00023 
00024 #include "qmetatype.h"
00025 #include "qobjectdefs.h"
00026 #include "qdatetime.h"
00027 #include "qbytearray.h"
00028 #include "qreadwritelock.h"
00029 #include "qstring.h"
00030 #include "qstringlist.h"
00031 #include "qvector.h"
00032 #include "qlocale.h"
00033 
00034 #ifdef QT_BOOTSTRAPPED
00035 #  define QT_NO_GEOM_VARIANT
00036 #else
00037 #  include "qbitarray.h"
00038 #  include "qurl.h"
00039 #  include "qvariant.h"
00040 #endif
00041 
00042 #ifndef QT_NO_GEOM_VARIANT
00043 #include "qsize.h"
00044 #include "qpoint.h"
00045 #include "qrect.h"
00046 #include "qline.h"
00047 #endif
00048 
00224 /* Note: these MUST be in the order of the enums */
00225 static const struct { const char * typeName; int type; } types[] = {
00226 
00227     /* All Core types */
00228     {"void", QMetaType::Void},
00229     {"bool", QMetaType::Bool},
00230     {"int", QMetaType::Int},
00231     {"uint", QMetaType::UInt},
00232     {"qlonglong", QMetaType::LongLong},
00233     {"qulonglong", QMetaType::ULongLong},
00234     {"double", QMetaType::Double},
00235     {"QChar", QMetaType::QChar},
00236     {"QVariantMap", QMetaType::QVariantMap},
00237     {"QVariantList", QMetaType::QVariantList},
00238     {"QString", QMetaType::QString},
00239     {"QStringList", QMetaType::QStringList},
00240     {"QByteArray", QMetaType::QByteArray},
00241     {"QBitArray", QMetaType::QBitArray},
00242     {"QDate", QMetaType::QDate},
00243     {"QTime", QMetaType::QTime},
00244     {"QDateTime", QMetaType::QDateTime},
00245     {"QUrl", QMetaType::QUrl},
00246     {"QLocale", QMetaType::QLocale},
00247     {"QRect", QMetaType::QRect},
00248     {"QRectF", QMetaType::QRectF},
00249     {"QSize", QMetaType::QSize},
00250     {"QSizeF", QMetaType::QSizeF},
00251     {"QLine", QMetaType::QLine},
00252     {"QLineF", QMetaType::QLineF},
00253     {"QPoint", QMetaType::QPoint},
00254     {"QPointF", QMetaType::QPointF},
00255     {"QRegExp", QMetaType::QRegExp},
00256 
00257     /* All GUI types */
00258     {"QColorGroup", 63},
00259     {"QFont", QMetaType::QFont},
00260     {"QPixmap", QMetaType::QPixmap},
00261     {"QBrush", QMetaType::QBrush},
00262     {"QColor", QMetaType::QColor},
00263     {"QPalette", QMetaType::QPalette},
00264     {"QIcon", QMetaType::QIcon},
00265     {"QImage", QMetaType::QImage},
00266     {"QPolygon", QMetaType::QPolygon},
00267     {"QRegion", QMetaType::QRegion},
00268     {"QBitmap", QMetaType::QBitmap},
00269     {"QCursor", QMetaType::QCursor},
00270     {"QSizePolicy", QMetaType::QSizePolicy},
00271     {"QKeySequence", QMetaType::QKeySequence},
00272     {"QPen", QMetaType::QPen},
00273     {"QTextLength", QMetaType::QTextLength},
00274     {"QTextFormat", QMetaType::QTextFormat},
00275     {"QMatrix", QMetaType::QMatrix},
00276 
00277     /* All Metatype builtins */
00278     {"void*", QMetaType::VoidStar},
00279     {"long", QMetaType::Long},
00280     {"short", QMetaType::Short},
00281     {"char", QMetaType::Char},
00282     {"ulong", QMetaType::ULong},
00283     {"ushort", QMetaType::UShort},
00284     {"uchar", QMetaType::UChar},
00285     {"float", QMetaType::Float},
00286     {"QObject*", QMetaType::QObjectStar},
00287     {"QWidget*", QMetaType::QWidgetStar},
00288 
00289     /* Type aliases - order doesn't matter */
00290     {"unsigned long", QMetaType::ULong},
00291     {"unsigned int", QMetaType::UInt},
00292     {"unsigned short", QMetaType::UShort},
00293     {"unsigned char", QMetaType::UChar},
00294     {"qint8", QMetaType::Char},
00295     {"quint8", QMetaType::UChar},
00296     {"qint16", QMetaType::Short},
00297     {"quint16", QMetaType::UShort},
00298     {"qint32", QMetaType::Int},
00299     {"quint32", QMetaType::UInt},
00300     {"qint64", QMetaType::LongLong},
00301     {"quint64", QMetaType::ULongLong},
00302     {"QList<QVariant>", QMetaType::QVariantList},
00303     {"QMap<QString,QVariant>", QMetaType::QVariantMap},
00304     // let QMetaTypeId2 figure out the type at compile time
00305     {"qreal", QMetaTypeId2<qreal>::MetaType},
00306 
00307     {0, QMetaType::Void}
00308 };
00309 
00310 struct QMetaTypeGuiHelper
00311 {
00312     QMetaType::Constructor constr;
00313     QMetaType::Destructor destr;
00314 #ifndef QT_NO_DATASTREAM
00315     QMetaType::SaveOperator saveOp;
00316     QMetaType::LoadOperator loadOp;
00317 #endif
00318 };
00319 Q_CORE_EXPORT const QMetaTypeGuiHelper *qMetaTypeGuiHelper = 0;
00320 
00321 class QCustomTypeInfo
00322 {
00323 public:
00324     QCustomTypeInfo() : typeName(), constr(0), destr(0)
00325 #ifndef QT_NO_DATASTREAM
00326     , saveOp(0), loadOp(0)
00327 #endif
00328     {}
00329 
00330     QByteArray typeName;
00331     QMetaType::Constructor constr;
00332     QMetaType::Destructor destr;
00333 #ifndef QT_NO_DATASTREAM
00334     QMetaType::SaveOperator saveOp;
00335     QMetaType::LoadOperator loadOp;
00336 #endif
00337 };
00338 
00339 Q_DECLARE_TYPEINFO(QCustomTypeInfo, Q_MOVABLE_TYPE);
00340 Q_GLOBAL_STATIC(QVector<QCustomTypeInfo>, customTypes)
00341 Q_GLOBAL_STATIC(QReadWriteLock, customTypesLock)
00342 
00343 #ifndef QT_NO_DATASTREAM
00344 
00346 void QMetaType::registerStreamOperators(const char *typeName, SaveOperator saveOp,
00347                                         LoadOperator loadOp)
00348 {
00349     int idx = type(typeName);
00350     if (!idx)
00351         return;
00352 
00353     QVector<QCustomTypeInfo> *ct = customTypes();
00354     if (!ct)
00355         return;
00356     QWriteLocker locker(customTypesLock());
00357     QCustomTypeInfo &inf = (*ct)[idx - User];
00358     inf.saveOp = saveOp;
00359     inf.loadOp = loadOp;
00360 }
00361 #endif
00362 
00369 const char *QMetaType::typeName(int type)
00370 {
00371     enum { GuiTypeCount = LastGuiType - FirstGuiType };
00372 
00373     if (type >= 0 && type <= LastCoreType) {
00374         return types[type].typeName;
00375     } else if (type >= FirstGuiType && type <= LastGuiType) {
00376         return types[type - FirstGuiType + LastCoreType + 1].typeName;
00377     } else if (type >= FirstCoreExtType && type <= LastCoreExtType) {
00378         return types[type - FirstCoreExtType + GuiTypeCount + LastCoreType + 2].typeName;
00379     } else if (type >= User) {
00380         const QVector<QCustomTypeInfo> * const ct = customTypes();
00381         QReadLocker locker(customTypesLock());
00382         return ct && ct->count() > type - User
00383                 ? ct->at(type - User).typeName.constData()
00384                 : static_cast<const char *>(0);
00385     }
00386 
00387     return 0;
00388 }
00389 
00393 static int qMetaTypeType_unlocked(const QByteArray &typeName)
00394 {
00395     int i = 0;
00396     while (types[i].typeName && strcmp(typeName.constData(), types[i].typeName))
00397         ++i;
00398     if (!types[i].type) {
00399         const QVector<QCustomTypeInfo> * const ct = customTypes();
00400         if (!ct)
00401             return 0;
00402 
00403         for (int v = 0; v < ct->count(); ++v) {
00404             if (ct->at(v).typeName == typeName)
00405                 return v + QMetaType::User;
00406         }
00407     }
00408     return types[i].type;
00409 }
00410 
00417 int QMetaType::registerType(const char *typeName, Destructor destructor,
00418                             Constructor constructor)
00419 {
00420     QVector<QCustomTypeInfo> *ct = customTypes();
00421     if (!ct || !typeName || !destructor || !constructor)
00422         return -1;
00423 
00424 #ifdef QT_NO_QOBJECT
00425     ::QByteArray normalizedTypeName = typeName;
00426 #else
00427     ::QByteArray normalizedTypeName = QMetaObject::normalizedType(typeName);
00428 #endif
00429 
00430     QWriteLocker locker(customTypesLock());
00431     static int currentIdx = User;
00432     int idx = qMetaTypeType_unlocked(normalizedTypeName);
00433 
00434     if (!idx) {
00435         idx = currentIdx++;
00436         ct->resize(ct->count() + 1);
00437         QCustomTypeInfo &inf = (*ct)[idx - User];
00438         inf.typeName = normalizedTypeName;
00439         inf.constr = constructor;
00440         inf.destr = destructor;
00441     }
00442     return idx;
00443 }
00444 
00451 bool QMetaType::isRegistered(int type)
00452 {
00453     QReadLocker locker(customTypesLock());
00454 
00455     const QVector<QCustomTypeInfo> * const ct = customTypes();
00456     return (type < User) || ((type >= User) && (ct && ct->count() > type - User));
00457 }
00458 
00465 int QMetaType::type(const char *typeName)
00466 {
00467 #ifdef QT_NO_QOBJECT
00468     const ::QByteArray normalizedTypeName = typeName;
00469 #else
00470     const ::QByteArray normalizedTypeName = QMetaObject::normalizedType(typeName);
00471 #endif
00472 
00473     QReadLocker locker(customTypesLock());
00474     return qMetaTypeType_unlocked(normalizedTypeName);
00475 }
00476 
00477 #ifndef QT_NO_DATASTREAM
00478 
00492 bool QMetaType::save(QDataStream &stream, int type, const void *data)
00493 {
00494     if (!data || !isRegistered(type))
00495         return false;
00496 
00497     switch(type) {
00498     case QMetaType::Void:
00499     case QMetaType::VoidStar:
00500     case QMetaType::QObjectStar:
00501     case QMetaType::QWidgetStar:
00502         return false;
00503     case QMetaType::Long:
00504         stream << qlonglong(*static_cast<const long *>(data));
00505         break;
00506     case QMetaType::Int:
00507         stream << *static_cast<const int *>(data);
00508         break;
00509     case QMetaType::Short:
00510         stream << *static_cast<const short *>(data);
00511         break;
00512     case QMetaType::Char:
00513         // force a char to be signed
00514         stream << *static_cast<const signed char *>(data);
00515         break;
00516     case QMetaType::ULong:
00517         stream << qulonglong(*static_cast<const ulong *>(data));
00518         break;
00519     case QMetaType::UInt:
00520         stream << *static_cast<const uint *>(data);
00521         break;
00522     case QMetaType::LongLong:
00523         stream << *static_cast<const qlonglong *>(data);
00524         break;
00525     case QMetaType::ULongLong:
00526         stream << *static_cast<const qulonglong *>(data);
00527         break;
00528     case QMetaType::UShort:
00529         stream << *static_cast<const ushort *>(data);
00530         break;
00531     case QMetaType::UChar:
00532         stream << *static_cast<const uchar *>(data);
00533         break;
00534     case QMetaType::Bool:
00535         stream << qint8(*static_cast<const bool *>(data));
00536         break;
00537     case QMetaType::Float:
00538         stream << *static_cast<const float *>(data);
00539         break;
00540     case QMetaType::Double:
00541         stream << *static_cast<const double *>(data);
00542         break;
00543     case QMetaType::QChar:
00544         stream << *static_cast<const ::QChar *>(data);
00545         break;
00546 #ifndef QT_BOOTSTRAPPED
00547     case QMetaType::QVariantMap:
00548         stream << *static_cast<const ::QVariantMap *>(data);
00549         break;
00550     case QMetaType::QVariantList:
00551         stream << *static_cast<const ::QVariantList *>(data);
00552         break;
00553 #endif
00554     case QMetaType::QByteArray:
00555         stream << *static_cast<const ::QByteArray *>(data);
00556         break;
00557     case QMetaType::QString:
00558         stream << *static_cast<const ::QString *>(data);
00559         break;
00560     case QMetaType::QStringList:
00561         stream << *static_cast<const ::QStringList *>(data);
00562         break;
00563 #ifndef QT_BOOTSTRAPPED
00564     case QMetaType::QBitArray:
00565         stream << *static_cast<const ::QBitArray *>(data);
00566         break;
00567 #endif
00568     case QMetaType::QDate:
00569         stream << *static_cast<const ::QDate *>(data);
00570         break;
00571     case QMetaType::QTime:
00572         stream << *static_cast<const ::QTime *>(data);
00573         break;
00574     case QMetaType::QDateTime:
00575         stream << *static_cast<const ::QDateTime *>(data);
00576         break;
00577 #ifndef QT_BOOTSTRAPPED
00578     case QMetaType::QUrl:
00579         stream << *static_cast<const ::QUrl *>(data);
00580         break;
00581 #endif
00582     case QMetaType::QLocale:
00583         stream << *static_cast<const ::QLocale *>(data);
00584         break;
00585 #ifndef QT_NO_GEOM_VARIANT
00586     case QMetaType::QRect:
00587         stream << *static_cast<const ::QRect *>(data);
00588         break;
00589     case QMetaType::QRectF:
00590         stream << *static_cast<const ::QRectF *>(data);
00591         break;
00592     case QMetaType::QSize:
00593         stream << *static_cast<const ::QSize *>(data);
00594         break;
00595     case QMetaType::QSizeF:
00596         stream << *static_cast<const ::QSizeF *>(data);
00597         break;
00598     case QMetaType::QLine:
00599         stream << *static_cast<const ::QLine *>(data);
00600         break;
00601     case QMetaType::QLineF:
00602         stream << *static_cast<const ::QLineF *>(data);
00603         break;
00604     case QMetaType::QPoint:
00605         stream << *static_cast<const ::QPoint *>(data);
00606         break;
00607     case QMetaType::QPointF:
00608         stream << *static_cast<const ::QPointF *>(data);
00609         break;
00610 #endif
00611 #ifndef QT_NO_REGEXP
00612     case QMetaType::QRegExp:
00613         stream << *static_cast<const ::QRegExp *>(data);
00614         break;
00615 #endif
00616 #ifdef QT3_SUPPORT
00617     case QMetaType::QColorGroup:
00618 #endif
00619     case QMetaType::QFont:
00620     case QMetaType::QPixmap:
00621     case QMetaType::QBrush:
00622     case QMetaType::QColor:
00623     case QMetaType::QPalette:
00624     case QMetaType::QIcon:
00625     case QMetaType::QImage:
00626     case QMetaType::QPolygon:
00627     case QMetaType::QRegion:
00628     case QMetaType::QBitmap:
00629     case QMetaType::QCursor:
00630     case QMetaType::QSizePolicy:
00631     case QMetaType::QKeySequence:
00632     case QMetaType::QPen:
00633     case QMetaType::QTextLength:
00634     case QMetaType::QTextFormat:
00635     case QMetaType::QMatrix:
00636         if (!qMetaTypeGuiHelper)
00637             return false;
00638         qMetaTypeGuiHelper[type - FirstGuiType].saveOp(stream, data);
00639         break;
00640     default: {
00641         const QVector<QCustomTypeInfo> * const ct = customTypes();
00642         if (!ct)
00643             return false;
00644 
00645         SaveOperator saveOp = 0;
00646         {
00647             QReadLocker locker(customTypesLock());
00648             saveOp = ct->at(type - User).saveOp;
00649         }
00650 
00651         if (!saveOp)
00652             return false;
00653         saveOp(stream, data);
00654         break; }
00655     }
00656 
00657     return true;
00658 }
00659 
00674 bool QMetaType::load(QDataStream &stream, int type, void *data)
00675 {
00676     if (!data || !isRegistered(type))
00677         return false;
00678 
00679     switch(type) {
00680     case QMetaType::Void:
00681     case QMetaType::VoidStar:
00682     case QMetaType::QObjectStar:
00683     case QMetaType::QWidgetStar:
00684         return false;
00685     case QMetaType::Long: {
00686         qlonglong l;
00687         stream >> l;
00688         *static_cast<long *>(data) = long(l);
00689         break; }
00690     case QMetaType::Int:
00691         stream >> *static_cast<int *>(data);
00692         break;
00693     case QMetaType::Short:
00694         stream >> *static_cast<short *>(data);
00695         break;
00696     case QMetaType::Char:
00697         // force a char to be signed
00698         stream >> *static_cast<signed char *>(data);
00699         break;
00700     case QMetaType::ULong: {
00701         qulonglong ul;
00702         stream >> ul;
00703         *static_cast<ulong *>(data) = ulong(ul);
00704         break; }
00705     case QMetaType::UInt:
00706         stream >> *static_cast<uint *>(data);
00707         break;
00708     case QMetaType::LongLong:
00709         stream >> *static_cast<qlonglong *>(data);
00710         break;
00711     case QMetaType::ULongLong:
00712         stream >> *static_cast<qulonglong *>(data);
00713         break;
00714     case QMetaType::UShort:
00715         stream >> *static_cast<ushort *>(data);
00716         break;
00717     case QMetaType::UChar:
00718         stream >> *static_cast<uchar *>(data);
00719         break;
00720     case QMetaType::Bool: {
00721         qint8 b;
00722         stream >> b;
00723         *static_cast<bool *>(data) = b;
00724         break; }
00725     case QMetaType::Float:
00726         stream >> *static_cast<float *>(data);
00727         break;
00728     case QMetaType::Double:
00729         stream >> *static_cast<double *>(data);
00730         break;
00731     case QMetaType::QChar:
00732         stream >> *static_cast< ::QChar *>(data);
00733         break;
00734 #ifndef QT_BOOTSTRAPPED
00735     case QMetaType::QVariantMap:
00736         stream >> *static_cast< ::QVariantMap *>(data);
00737         break;
00738     case QMetaType::QVariantList:
00739         stream >> *static_cast< ::QVariantList *>(data);
00740         break;
00741 #endif
00742     case QMetaType::QByteArray:
00743         stream >> *static_cast< ::QByteArray *>(data);
00744         break;
00745     case QMetaType::QString:
00746         stream >> *static_cast< ::QString *>(data);
00747         break;
00748     case QMetaType::QStringList:
00749         stream >> *static_cast< ::QStringList *>(data);
00750         break;
00751 #ifndef QT_BOOTSTRAPPED
00752     case QMetaType::QBitArray:
00753         stream >> *static_cast< ::QBitArray *>(data);
00754         break;
00755 #endif
00756     case QMetaType::QDate:
00757         stream >> *static_cast< ::QDate *>(data);
00758         break;
00759     case QMetaType::QTime:
00760         stream >> *static_cast< ::QTime *>(data);
00761         break;
00762     case QMetaType::QDateTime:
00763         stream >> *static_cast< ::QDateTime *>(data);
00764         break;
00765 #ifndef QT_BOOTSTRAPPED
00766     case QMetaType::QUrl:
00767         stream >> *static_cast< ::QUrl *>(data);
00768         break;
00769 #endif
00770     case QMetaType::QLocale:
00771         stream >> *static_cast< ::QLocale *>(data);
00772         break;
00773 #ifndef QT_NO_GEOM_VARIANT
00774     case QMetaType::QRect:
00775         stream >> *static_cast< ::QRect *>(data);
00776         break;
00777     case QMetaType::QRectF:
00778         stream >> *static_cast< ::QRectF *>(data);
00779         break;
00780     case QMetaType::QSize:
00781         stream >> *static_cast< ::QSize *>(data);
00782         break;
00783     case QMetaType::QSizeF:
00784         stream >> *static_cast< ::QSizeF *>(data);
00785         break;
00786     case QMetaType::QLine:
00787         stream >> *static_cast< ::QLine *>(data);
00788         break;
00789     case QMetaType::QLineF:
00790         stream >> *static_cast< ::QLineF *>(data);
00791         break;
00792     case QMetaType::QPoint:
00793         stream >> *static_cast< ::QPoint *>(data);
00794         break;
00795     case QMetaType::QPointF:
00796         stream >> *static_cast< ::QPointF *>(data);
00797         break;
00798 #endif
00799 #ifndef QT_NO_REGEXP
00800     case QMetaType::QRegExp:
00801         stream >> *static_cast< ::QRegExp *>(data);
00802         break;
00803 #endif
00804 #ifdef QT3_SUPPORT
00805     case QMetaType::QColorGroup:
00806 #endif
00807     case QMetaType::QFont:
00808     case QMetaType::QPixmap:
00809     case QMetaType::QBrush:
00810     case QMetaType::QColor:
00811     case QMetaType::QPalette:
00812     case QMetaType::QIcon:
00813     case QMetaType::QImage:
00814     case QMetaType::QPolygon:
00815     case QMetaType::QRegion:
00816     case QMetaType::QBitmap:
00817     case QMetaType::QCursor:
00818     case QMetaType::QSizePolicy:
00819     case QMetaType::QKeySequence:
00820     case QMetaType::QPen:
00821     case QMetaType::QTextLength:
00822     case QMetaType::QTextFormat:
00823     case QMetaType::QMatrix:
00824         if (!qMetaTypeGuiHelper)
00825             return false;
00826         qMetaTypeGuiHelper[type - FirstGuiType].loadOp(stream, data);
00827         break;
00828     default: {
00829         const QVector<QCustomTypeInfo> * const ct = customTypes();
00830         if (!ct)
00831             return false;
00832 
00833         LoadOperator loadOp = 0;
00834         {
00835             QReadLocker locker(customTypesLock());
00836             loadOp = ct->at(type - User).loadOp;
00837         }
00838 
00839         if (!loadOp)
00840             return false;
00841         loadOp(stream, data);
00842         break; }
00843     }
00844     return true;
00845 }
00846 #endif
00847 
00854 void *QMetaType::construct(int type, const void *copy)
00855 {
00856     if (copy) {
00857         switch(type) {
00858         case QMetaType::VoidStar:
00859         case QMetaType::QObjectStar:
00860         case QMetaType::QWidgetStar:
00861             return new void *(*static_cast<void* const *>(copy));
00862         case QMetaType::Long:
00863             return new long(*static_cast<const long*>(copy));
00864         case QMetaType::Int:
00865             return new int(*static_cast<const int*>(copy));
00866         case QMetaType::Short:
00867             return new short(*static_cast<const short*>(copy));
00868         case QMetaType::Char:
00869             return new char(*static_cast<const char*>(copy));
00870         case QMetaType::ULong:
00871             return new ulong(*static_cast<const ulong*>(copy));
00872         case QMetaType::UInt:
00873             return new uint(*static_cast<const uint*>(copy));
00874         case QMetaType::LongLong:
00875             return new qlonglong(*static_cast<const qlonglong*>(copy));
00876         case QMetaType::ULongLong:
00877             return new qulonglong(*static_cast<const qulonglong*>(copy));
00878         case QMetaType::UShort:
00879             return new ushort(*static_cast<const ushort*>(copy));
00880         case QMetaType::UChar:
00881             return new uchar(*static_cast<const uchar*>(copy));
00882         case QMetaType::Bool:
00883             return new bool(*static_cast<const bool*>(copy));
00884         case QMetaType::Float:
00885             return new float(*static_cast<const float*>(copy));
00886         case QMetaType::Double:
00887             return new double(*static_cast<const double*>(copy));
00888         case QMetaType::QChar:
00889             return new ::QChar(*static_cast<const ::QChar*>(copy));
00890 #ifndef QT_BOOTSTRAPPED
00891         case QMetaType::QVariantMap:
00892             return new ::QVariantMap(*static_cast<const ::QVariantMap*>(copy));
00893         case QMetaType::QVariantList:
00894             return new ::QVariantList(*static_cast<const ::QVariantList*>(copy));
00895 #endif
00896         case QMetaType::QByteArray:
00897             return new ::QByteArray(*static_cast<const ::QByteArray*>(copy));
00898         case QMetaType::QString:
00899             return new ::QString(*static_cast<const ::QString*>(copy));
00900         case QMetaType::QStringList:
00901             return new ::QStringList(*static_cast<const ::QStringList *>(copy));
00902 #ifndef QT_BOOTSTRAPPED
00903         case QMetaType::QBitArray:
00904             return new ::QBitArray(*static_cast<const ::QBitArray *>(copy));
00905 #endif
00906         case QMetaType::QDate:
00907             return new ::QDate(*static_cast<const ::QDate *>(copy));
00908         case QMetaType::QTime:
00909             return new ::QTime(*static_cast<const ::QTime *>(copy));
00910         case QMetaType::QDateTime:
00911             return new ::QDateTime(*static_cast<const ::QDateTime *>(copy));
00912 #ifndef QT_BOOTSTRAPPED
00913         case QMetaType::QUrl:
00914             return new ::QUrl(*static_cast<const ::QUrl *>(copy));
00915 #endif
00916         case QMetaType::QLocale:
00917             return new ::QLocale(*static_cast<const ::QLocale *>(copy));
00918 #ifndef QT_NO_GEOM_VARIANT
00919         case QMetaType::QRect:
00920             return new ::QRect(*static_cast<const ::QRect *>(copy));
00921         case QMetaType::QRectF:
00922             return new ::QRectF(*static_cast<const ::QRectF *>(copy));
00923         case QMetaType::QSize:
00924             return new ::QSize(*static_cast<const ::QSize *>(copy));
00925         case QMetaType::QSizeF:
00926             return new ::QSizeF(*static_cast<const ::QSizeF *>(copy));
00927         case QMetaType::QLine:
00928             return new ::QLine(*static_cast<const ::QLine *>(copy));
00929         case QMetaType::QLineF:
00930             return new ::QLineF(*static_cast<const ::QLineF *>(copy));
00931         case QMetaType::QPoint:
00932             return new ::QPoint(*static_cast<const ::QPoint *>(copy));
00933         case QMetaType::QPointF:
00934             return new ::QPointF(*static_cast<const ::QPointF *>(copy));
00935 #endif
00936 #ifndef QT_NO_REGEXP
00937         case QMetaType::QRegExp:
00938             return new ::QRegExp(*static_cast<const ::QRegExp *>(copy));
00939 #endif
00940         case QMetaType::Void:
00941             return 0;
00942         default:
00943             ;
00944         }
00945     } else {
00946         switch(type) {
00947         case QMetaType::VoidStar:
00948         case QMetaType::QObjectStar:
00949         case QMetaType::QWidgetStar:
00950             return new void *;
00951         case QMetaType::Long:
00952             return new long;
00953         case QMetaType::Int:
00954             return new int;
00955         case QMetaType::Short:
00956             return new short;
00957         case QMetaType::Char:
00958             return new char;
00959         case QMetaType::ULong:
00960             return new ulong;
00961         case QMetaType::UInt:
00962             return new uint;
00963         case QMetaType::LongLong:
00964             return new qlonglong;
00965         case QMetaType::ULongLong:
00966             return new qulonglong;
00967         case QMetaType::UShort:
00968             return new ushort;
00969         case QMetaType::UChar:
00970             return new uchar;
00971         case QMetaType::Bool:
00972             return new bool;
00973         case QMetaType::Float:
00974             return new float;
00975         case QMetaType::Double:
00976             return new double;
00977         case QMetaType::QChar:
00978             return new ::QChar;
00979 #ifndef QT_BOOTSTRAPPED
00980         case QMetaType::QVariantMap:
00981             return new ::QVariantMap;
00982         case QMetaType::QVariantList:
00983             return new ::QVariantList;
00984 #endif
00985         case QMetaType::QByteArray:
00986             return new ::QByteArray;
00987         case QMetaType::QString:
00988             return new ::QString;
00989         case QMetaType::QStringList:
00990             return new ::QStringList;
00991 #ifndef QT_BOOTSTRAPPED
00992         case QMetaType::QBitArray:
00993             return new ::QBitArray;
00994 #endif
00995         case QMetaType::QDate:
00996             return new ::QDate;
00997         case QMetaType::QTime:
00998             return new ::QTime;
00999         case QMetaType::QDateTime:
01000             return new ::QDateTime;
01001 #ifndef QT_BOOTSTRAPPED
01002         case QMetaType::QUrl:
01003             return new ::QUrl;
01004 #endif
01005         case QMetaType::QLocale:
01006             return new ::QLocale;
01007 #ifndef QT_NO_GEOM_VARIANT
01008         case QMetaType::QRect:
01009             return new ::QRect;
01010         case QMetaType::QRectF:
01011             return new ::QRectF;
01012         case QMetaType::QSize:
01013             return new ::QSize;
01014         case QMetaType::QSizeF:
01015             return new ::QSizeF;
01016         case QMetaType::QLine:
01017             return new ::QLine;
01018         case QMetaType::QLineF:
01019             return new ::QLineF;
01020         case QMetaType::QPoint:
01021             return new ::QPoint;
01022         case QMetaType::QPointF:
01023             return new ::QPointF;
01024 #endif
01025 #ifndef QT_NO_REGEXP
01026         case QMetaType::QRegExp:
01027             return new ::QRegExp;
01028 #endif
01029         case QMetaType::Void:
01030             return 0;
01031         default:
01032             ;
01033         }
01034     }
01035 
01036     Constructor constr = 0;
01037     if (type >= FirstGuiType && type <= LastGuiType) {
01038         if (!qMetaTypeGuiHelper)
01039             return 0;
01040         constr = qMetaTypeGuiHelper[type - FirstGuiType].constr;
01041     } else {
01042         const QVector<QCustomTypeInfo> * const ct = customTypes();
01043         QReadLocker locker(customTypesLock());
01044         if (type < User || !ct || ct->count() <= type - User)
01045             return 0;
01046 
01047         constr = ct->at(type - User).constr;
01048     }
01049 
01050     return constr(copy);
01051 }
01052 
01058 void QMetaType::destroy(int type, void *data)
01059 {
01060     if (!data)
01061         return;
01062     switch(type) {
01063     case QMetaType::VoidStar:
01064     case QMetaType::QObjectStar:
01065     case QMetaType::QWidgetStar:
01066         delete static_cast<void**>(data);
01067         break;
01068     case QMetaType::Long:
01069         delete static_cast<long*>(data);
01070         break;
01071     case QMetaType::Int:
01072         delete static_cast<int*>(data);
01073         break;
01074     case QMetaType::Short:
01075         delete static_cast<short*>(data);
01076         break;
01077     case QMetaType::Char:
01078         delete static_cast<char*>(data);
01079         break;
01080     case QMetaType::ULong:
01081         delete static_cast<ulong*>(data);
01082         break;
01083     case QMetaType::LongLong:
01084         delete static_cast<qlonglong*>(data);
01085         break;
01086     case QMetaType::ULongLong:
01087         delete static_cast<qulonglong*>(data);
01088         break;
01089     case QMetaType::UInt:
01090         delete static_cast<uint*>(data);
01091         break;
01092     case QMetaType::UShort:
01093         delete static_cast<ushort*>(data);
01094         break;
01095     case QMetaType::UChar:
01096         delete static_cast<uchar*>(data);
01097         break;
01098     case QMetaType::Bool:
01099         delete static_cast<bool*>(data);
01100         break;
01101     case QMetaType::Float:
01102         delete static_cast<float*>(data);
01103         break;
01104     case QMetaType::Double:
01105         delete static_cast<double*>(data);
01106         break;
01107     case QMetaType::QChar:
01108         delete static_cast< ::QChar*>(data);
01109         break;
01110 #ifndef QT_BOOTSTRAPPED
01111     case QMetaType::QVariantMap:
01112         delete static_cast< ::QVariantMap*>(data);
01113         break;
01114     case QMetaType::QVariantList:
01115         delete static_cast< ::QVariantList*>(data);
01116         break;
01117 #endif
01118     case QMetaType::QByteArray:
01119         delete static_cast< ::QByteArray*>(data);
01120         break;
01121     case QMetaType::QString:
01122         delete static_cast< ::QString*>(data);
01123         break;
01124     case QMetaType::QStringList:
01125         delete static_cast< ::QStringList*>(data);
01126         break;
01127 #ifndef QT_BOOTSTRAPPED
01128     case QMetaType::QBitArray:
01129         delete static_cast< ::QBitArray*>(data);
01130         break;
01131 #endif
01132     case QMetaType::QDate:
01133         delete static_cast< ::QDate*>(data);
01134         break;
01135     case QMetaType::QTime:
01136         delete static_cast< ::QTime*>(data);
01137         break;
01138     case QMetaType::QDateTime:
01139         delete static_cast< ::QDateTime*>(data);
01140         break;
01141 #ifndef QT_BOOTSTRAPPED
01142     case QMetaType::QUrl:
01143         delete static_cast< ::QUrl*>(data);
01144 #endif
01145         break;
01146     case QMetaType::QLocale:
01147         delete static_cast< ::QLocale*>(data);
01148         break;
01149 #ifndef QT_NO_GEOM_VARIANT
01150     case QMetaType::QRect:
01151         delete static_cast< ::QRect*>(data);
01152         break;
01153     case QMetaType::QRectF:
01154         delete static_cast< ::QRectF*>(data);
01155         break;
01156     case QMetaType::QSize:
01157         delete static_cast< ::QSize*>(data);
01158         break;
01159     case QMetaType::QSizeF:
01160         delete static_cast< ::QSizeF*>(data);
01161         break;
01162     case QMetaType::QLine:
01163         delete static_cast< ::QLine*>(data);
01164         break;
01165     case QMetaType::QLineF:
01166         delete static_cast< ::QLineF*>(data);
01167         break;
01168     case QMetaType::QPoint:
01169         delete static_cast< ::QPoint*>(data);
01170         break;
01171     case QMetaType::QPointF:
01172         delete static_cast< ::QPointF*>(data);
01173         break;
01174 #endif
01175 #ifndef QT_NO_REGEXP
01176     case QMetaType::QRegExp:
01177         delete static_cast< ::QRegExp*>(data);
01178         break;
01179 #endif
01180     case QMetaType::Void:
01181         break;
01182     default: {
01183         const QVector<QCustomTypeInfo> * const ct = customTypes();
01184         Destructor destr = 0;
01185         if (type >= FirstGuiType && type <= LastGuiType) {
01186             Q_ASSERT(qMetaTypeGuiHelper);
01187 
01188             if (!qMetaTypeGuiHelper)
01189                 return;
01190             destr = qMetaTypeGuiHelper[type - FirstGuiType].destr;
01191         } else {
01192             QReadLocker locker(customTypesLock());
01193             if (type < User || !ct || ct->count() <= type - User)
01194                 break;
01195             destr = ct->at(type - User).destr;
01196         }
01197         destr(data);
01198         break; }
01199     }
01200 }
01201
Generated on Thu Mar 15 11:53:30 2007 for Qt 4.2 User's Guide by  doxygen 1.5.1