qvariant.cpp

qt-x11-opensource-src-4.1.4.tar.gz源码

        s << QString();
        break;
    default:
        if (QMetaType::isRegistered(d->type)) {
            if (!QMetaType::save(s, d->type, d->data.shared->ptr))
                qFatal("QVariant::save: no streaming operators registered for type %d.", d->type);
            break;
        } else {
            qFatal("QVariant::save: type %d unknown to QVariant.", d->type);
        }
    }
}
#endif // QT_NO_DATASTREAM

static bool compare(const QVariant::Private *a, const QVariant::Private *b)
{
    switch(a->type) {
    case QVariant::List:
        return *v_cast<QVariantList>(a) == *v_cast<QVariantList>(b);
    case QVariant::Map: {
        const QVariantMap *m1 = v_cast<QVariantMap>(a);
        const QVariantMap *m2 = v_cast<QVariantMap>(b);
        if (m1->count() != m2->count())
            return false;
        QVariantMap::ConstIterator it = m1->constBegin();
        QVariantMap::ConstIterator it2 = m2->constBegin();
        while (it != m1->constEnd()) {
            if (*it != *it2)
                return false;
            ++it;
            ++it2;
        }
        return true;
    }
    case QVariant::String:
        return *v_cast<QString>(a) == *v_cast<QString>(b);
    case QVariant::Char:
        return *v_cast<QChar>(a) == *v_cast<QChar>(b);
    case QVariant::StringList:
        return *v_cast<QStringList>(a) == *v_cast<QStringList>(b);
#ifndef QT_NO_GEOM_VARIANT
    case QVariant::Size:
        return *v_cast<QSize>(a) == *v_cast<QSize>(b);
    case QVariant::SizeF:
        return *v_cast<QSizeF>(a) == *v_cast<QSizeF>(b);
    case QVariant::Rect:
        return *v_cast<QRect>(a) == *v_cast<QRect>(b);
    case QVariant::Line:
        return *v_cast<QLine>(a) == *v_cast<QLine>(b);
    case QVariant::LineF:
        return *v_cast<QLineF>(a) == *v_cast<QLineF>(b);
    case QVariant::RectF:
        return *v_cast<QRectF>(a) == *v_cast<QRectF>(b);
    case QVariant::Point:
        return *v_cast<QPoint>(a) == *v_cast<QPoint>(b);
    case QVariant::PointF:
        return *v_cast<QPointF>(a) == *v_cast<QPointF>(b);
#endif
    case QVariant::Url:
        return *v_cast<QUrl>(a) == *v_cast<QUrl>(b);
    case QVariant::Locale:
        return *v_cast<QLocale>(a) == *v_cast<QLocale>(b);
    case QVariant::RegExp:
        return *v_cast<QRegExp>(a) == *v_cast<QRegExp>(b);
    case QVariant::Int:
        return a->data.i == b->data.i;
    case QVariant::UInt:
        return a->data.u == b->data.u;
    case QVariant::LongLong:
        return a->data.ll == b->data.ll;
    case QVariant::ULongLong:
        return a->data.ull == b->data.ull;
    case QVariant::Bool:
        return a->data.b == b->data.b;
    case QVariant::Double:
        return a->data.d == b->data.d;
    case QVariant::Date:
        return *v_cast<QDate>(a) == *v_cast<QDate>(b);
    case QVariant::Time:
        return *v_cast<QTime>(a) == *v_cast<QTime>(b);
    case QVariant::DateTime:
        return *v_cast<QDateTime>(a) == *v_cast<QDateTime>(b);
    case QVariant::ByteArray:
        return *v_cast<QByteArray>(a) == *v_cast<QByteArray>(b);
    case QVariant::BitArray:
        return *v_cast<QBitArray>(a) == *v_cast<QBitArray>(b);
    case QVariant::Invalid:
        return true;
    default:
        break;
    }
    if (!QMetaType::isRegistered(a->type))
        qFatal("QVariant::compare: type %d unknown to QVariant.", a->type);
    return a->data.shared->ptr == b->data.shared->ptr;
}

static bool convert(const QVariant::Private *d, QVariant::Type t, void *result, bool *ok)
{
    Q_ASSERT(d->type != uint(t));
    switch (t) {
    case QVariant::String: {
        QString *str = static_cast<QString *>(result);
        switch (d->type) {
        case QVariant::Char:
            *str = QString(*v_cast<QChar>(d));
            break;
        case QVariant::Int:
            *str = QString::number(d->data.i);
            break;
        case QVariant::UInt:
            *str = QString::number(d->data.u);
            break;
        case QVariant::LongLong:
            *str = QString::number(d->data.ll);
            break;
        case QVariant::ULongLong:
            *str = QString::number(d->data.ull);
            break;
        case QVariant::Double:
            *str = QString::number(d->data.d, 'g', DBL_DIG);
            break;
#if !defined(QT_NO_DATESTRING)
        case QVariant::Date:
            *str = v_cast<QDate>(d)->toString(Qt::ISODate);
            break;
        case QVariant::Time:
            *str = v_cast<QTime>(d)->toString(Qt::ISODate);
            break;
        case QVariant::DateTime:
            *str = v_cast<QDateTime>(d)->toString(Qt::ISODate);
            break;
#endif
        case QVariant::Bool:
            *str = QLatin1String(d->data.b ? "true" : "false");
            break;
        case QVariant::ByteArray:
            *str = QString::fromAscii(v_cast<QByteArray>(d)->constData());
            break;
        case QVariant::StringList:
            if (v_cast<QStringList>(d)->count() == 1)
                *str = v_cast<QStringList>(d)->at(0);
            break;
        default:
            return false;
        }
        break;
    }
    case QVariant::Char: {
        QChar *c = static_cast<QChar *>(result);
        switch (d->type) {
        case QVariant::Int:
            *c = QChar(d->data.i);
            break;
        case QVariant::UInt:
            *c = QChar(d->data.u);
            break;
        default:
            return false;
        }
        break;
    }

    case QVariant::StringList:
        if (d->type == QVariant::List) {
            QStringList *slst = static_cast<QStringList *>(result);
            const QVariantList *list = v_cast<QVariantList >(d);
            for (int i = 0; i < list->size(); ++i)
                slst->append(list->at(i).toString());
        } else if (d->type == QVariant::String) {
            QStringList *slst = static_cast<QStringList *>(result);
            *slst = QStringList(*v_cast<QString>(d));
        } else {
            return false;
        }
        break;
    case QVariant::Date: {
        QDate *dt = static_cast<QDate *>(result);
        if (d->type == QVariant::DateTime)
            *dt = v_cast<QDateTime>(d)->date();
#ifndef QT_NO_DATESTRING
        else if (d->type == QVariant::String)
            *dt = QDate::fromString(*v_cast<QString>(d), Qt::ISODate);
#endif
        else
            return false;
        break;
    }
    case QVariant::Time: {
        QTime *t = static_cast<QTime *>(result);
        switch (d->type) {
        case QVariant::DateTime:
            *t = v_cast<QDateTime>(d)->time();
            break;
#ifndef QT_NO_DATESTRING
        case QVariant::String:
            *t = QTime::fromString(*v_cast<QString>(d), Qt::ISODate);
            break;
#endif
        default:
            return false;
        }
        break;
    }
    case QVariant::DateTime: {
        QDateTime *dt = static_cast<QDateTime *>(result);
        switch (d->type) {
#ifndef QT_NO_DATESTRING
        case QVariant::String:
            *dt = QDateTime::fromString(*v_cast<QString>(d), Qt::ISODate);
            break;
#endif
        case QVariant::Date:
            *dt = QDateTime(*v_cast<QDate>(d));
            break;
        default:
            return false;
        }
        break;
    }
    case QVariant::ByteArray: {
        QByteArray *ba = static_cast<QByteArray *>(result);
        if (d->type == QVariant::String)
            *ba = v_cast<QString>(d)->toAscii();
        else
            return false;
    }
    break;
    case QVariant::Int: {
        int *i = static_cast<int *>(result);
        switch (d->type) {
        case QVariant::String:
            *i = v_cast<QString>(d)->toInt(ok);
            break;
        case QVariant::Char:
            *i = v_cast<QChar>(d)->unicode();
            break;
        case QVariant::ByteArray:
            *i = v_cast<QByteArray>(d)->toInt(ok);
            break;
        case QVariant::UInt:
            *i = int(d->data.u);
            break;
        case QVariant::LongLong:
            *i = int(d->data.ll);
            break;
        case QVariant::ULongLong:
            *i = int(d->data.ull);
            break;
        case QVariant::Double:
            *i = qRound(d->data.d);
            break;
        case QVariant::Bool:
            *i = (int)d->data.b;
            break;
        default:
            *i = 0;
            return false;
        }
        break;
    }
    case QVariant::UInt: {
        uint *u = static_cast<uint *>(result);
        switch (d->type) {
        case QVariant::String:
            *u = v_cast<QString>(d)->toUInt(ok);
            break;
        case QVariant::Char:
            *u = v_cast<QChar>(d)->unicode();
            break;
        case QVariant::ByteArray:
            *u = v_cast<QByteArray>(d)->toUInt(ok);
            break;
        case QVariant::Int:
            *u = uint(d->data.i);
            break;
        case QVariant::LongLong:
            *u = uint(d->data.ll);
            break;
        case QVariant::ULongLong:
            *u = uint(d->data.ull);
            break;
        case QVariant::Double:
            *u = qRound(d->data.d);
            break;
        case QVariant::Bool:
            *u = uint(d->data.b);
            break;
        default:
            *u = 0u;
            return false;
        }
        break;
    }
    case QVariant::LongLong: {
        qlonglong *l = static_cast<qlonglong *>(result);
        switch (d->type) {
        case QVariant::String:
            *l = v_cast<QString>(d)->toLongLong(ok);
            break;
        case QVariant::Char:
            *l = v_cast<QChar>(d)->unicode();
            break;
        case QVariant::ByteArray:
            *l = v_cast<QByteArray>(d)->toLongLong(ok);
            break;
        case QVariant::Int:
            *l = qlonglong(d->data.i);
            break;
        case QVariant::UInt:
            *l = qlonglong(d->data.u);
            break;
        case QVariant::ULongLong:
            *l = qlonglong(d->data.ull);
            break;
        case QVariant::Double:
            *l = qRound64(d->data.d);
            break;
        case QVariant::Bool:
            *l = qlonglong(d->data.b);
            break;
        default:
            *l = Q_INT64_C(0);
            return false;
        }
        break;
    }
    case QVariant::ULongLong: {
        qulonglong *l = static_cast<qulonglong *>(result);
        switch (d->type) {
        case QVariant::Int:
            *l = qulonglong(d->data.i);
            break;
        case QVariant::UInt:
            *l = qulonglong(d->data.u);
            break;
        case QVariant::LongLong:
            *l = qulonglong(d->data.ll);
            break;
        case QVariant::Double:
            *l = qRound64(d->data.d);
            break;
        case QVariant::Bool:
            *l = qulonglong(d->data.b);
            break;
        case QVariant::String:
            *l = v_cast<QString>(d)->toULongLong(ok);
            break;
        case QVariant::Char:
            *l = v_cast<QChar>(d)->unicode();
            break;
        case QVariant::ByteArray:
            *l = v_cast<QByteArray>(d)->toULongLong(ok);
            break;
        default:
            *l = Q_UINT64_C(0);
            return false;
        }
        break;
    }
    case QVariant::Bool: {
        bool *b = static_cast<bool *>(result);
        switch(d->type) {
        case QVariant::Double:
            *b = d->data.d != 0.0;
            break;
        case QVariant::Int:
            *b = d->data.i != 0;
            break;
        case QVariant::UInt:
            *b = d->data.u != 0;
            break;
        case QVariant::LongLong:
            *b = d->data.ll != Q_INT64_C(0);
            break;
        case QVariant::ULongLong:
            *b = d->data.ull != Q_UINT64_C(0);
            break;
        case QVariant::String:
        {
            QString str = v_cast<QString>(d)->toLower();
            *b = !(str == QLatin1String("0") || str == QLatin1String("false") || str.isEmpty());
            break;
        }
        case QVariant::Char:
            *b = !v_cast<QChar>(d)->isNull();
            break;
        default:
            *b = false;
            return false;
        }
        break;
    }
    case QVariant::Double: {
        double *f = static_cast<double *>(result);
        switch (d->type) {
        case QVariant::String:
            *f = v_cast<QString>(d)->toDouble(ok);
            break;
        case QVariant::ByteArray:
            *f = v_cast<QByteArray>(d)->toDouble(ok);
            break;
        case QVariant::Int:
            *f = double(d->data.i);
            break;
        case QVariant::Bool:
            *f = double(d->data.b);
            break;
        case QVariant::UInt:
            *f = double(d->data.u);
            break;
        case QVariant::LongLong:
            *f = double(d->data.ll);
            break;
        case QVariant::ULongLong:
#if defined(Q_CC_MSVC) && !defined(Q_CC_MSVC_NET)
            *f = (double)(qlonglong)d->data.ull;
#else
            *f = double(d->data.ull);
#endif
            break;
        default:
            *f = 0.0;
            return false;
        }
        break;
    }
    case QVariant::List:
        if (d->type == QVariant::StringList) {
            QVariantList *lst = static_cast<QVariantList *>(result);
            const QStringList *slist = v_cast<QStringList>(d);
            for (int i = 0; i < slist->size(); ++i)
                lst->append(QVariant(slist->at(i)));
        } else if (qstrcmp(QMetaType::typeName(d->type), "QList<QVariant>") == 0) {
            *static_cast<QVariantList *>(result) =
                *static_cast<QList<QVariant> *>(d->data.shared->ptr);
        } else {
            return false;
        }
        break;
    case QVariant::Map:
        if (qstrcmp(QMetaType::typeName(d->type), "QMap<QString, QVariant>") == 0) {
            *static_cast<QVariantMap *>(result) =
                *static_cast<QMap<QString, QVariant> *>(d->data.shared->ptr);
        } else {
            return false;
        }
#ifndef QT_NO_GEOM_VARIANT
    case QVariant::RectF:
        if (d->type == QVariant::Rect)
            *static_cast<QRectF *>(result) = *v_cast<QRect>(d);
        else
            return false;
    case QVariant::PointF:
        if (d->type == QVariant::Point)
            *static_cast<QPointF *>(result) = *v_cast<QPoint>(d);
        else
            return false;
#endif
    default:
        return false;
    }
    return true;
}

static bool canConvert(const QVariant::Private *d, QVariant::Type t)
{
    if (d->type == uint(t))
        return true;

    switch (t) {
    case QVariant::Bool:
        return d->type == QVariant::Double || d->type == QVariant::Int
            || d->type == QVariant::UInt || d->type == QVariant::LongLong
            || d->type == QVariant::ULongLong || d->type == QVariant::String
            || d->type == QVariant::Char;
    case QVariant::Int:
        return d->type == QVariant::String || d->type == QVariant::Double
            || d->type == QVariant::Bool || d->type == QVariant::UInt
            || d->type == QVariant::LongLong || d->type == QVariant::ULongLong
            || d->type == QVariant::Char;
    case QVariant::UInt:
        return d->type == QVariant::String || d->type == QVariant::Double
            || d->type == QVariant::Bool || d->type == QVariant::Int
            || d->type == QVariant::LongLong || d->type == QVariant::ULongLong
            || d->type == QVariant::Char;
    case QVariant::LongLong:
        return d->type == QVariant::String || d->type == QVariant::Double
            || d->type == QVariant::Bool || d->type == QVariant::Int