src/corelib/kernel/qvariant.cpp File Reference

#include "qvariant.h"
#include "qbitarray.h"
#include "qbytearray.h"
#include "qdatastream.h"
#include "qdebug.h"
#include "qmap.h"
#include "qdatetime.h"
#include "qlist.h"
#include "qstring.h"
#include "qstringlist.h"
#include "qurl.h"
#include "qlocale.h"
#include "private/qvariant_p.h"
#include "qsize.h"
#include "qpoint.h"
#include "qrect.h"
#include "qline.h"
#include <float.h>

Include dependency graph for qvariant.cpp:

Go to the source code of this file.

Defines

#define DBL_DIG   10
#define FLT_DIG   6

Enumerations

enum  

Functions

static const void * constData (const QVariant::Private &d)
static void construct (QVariant::Private *x, const void *copy)
static void clear (QVariant::Private *d)
static bool isNull (const QVariant::Private *d)
static bool compare (const QVariant::Private *a, const QVariant::Private *b)
static qlonglong qMetaTypeNumber (const QVariant::Private *d)
static qulonglong qMetaTypeUNumber (const QVariant::Private *d)
static qlonglong qConvertToNumber (const QVariant::Private *d, bool *ok)
static qulonglong qConvertToUnsignedNumber (const QVariant::Private *d, bool *ok)
static bool convert (const QVariant::Private *d, QVariant::Type t, void *result, bool *ok)
static void streamDebug (QDebug dbg, const QVariant &v)
Q_CORE_EXPORT const QVariant::Handler * qcoreVariantHandler ()
QDataStream & operator>> (QDataStream &s, QVariant &p)
QDataStream & operator<< (QDataStream &s, const QVariant &p)
QDataStream & operator>> (QDataStream &s, QVariant::Type &p)
QDataStream & operator<< (QDataStream &s, const QVariant::Type p)
template<typename T>
T qVariantToHelper (const QVariant::Private &d, QVariant::Type t, const QVariant::Handler *handler, T *=0)
template<typename T>
T qNumVariantToHelper (const QVariant::Private &d, QVariant::Type t, const QVariant::Handler *handler, bool *ok, const T &val)
static bool qIsNumericType (uint tp)
static bool qIsFloatingPoint (uint tp)
QDebug operator<< (QDebug dbg, const QVariant &v)
QDebug operator<< (QDebug dbg, const QVariant::Type p)

Variables

const QVariant::Handler qt_kernel_variant_handler
static const uint map_from_three [MapFromThreeCount]
static const quint32 qCanConvertMatrix [QVariant::LastCoreType+1]

Define Documentation

#define DBL_DIG   10

Definition at line 48 of file qvariant.cpp.

Referenced by convert(), and qstrtod().

#define FLT_DIG   6

Definition at line 51 of file qvariant.cpp.

Referenced by convert().

Enumeration Type Documentation

anonymous enum

Definition at line 1687 of file qvariant.cpp.

01687 { MapFromThreeCount = 35 };

Function Documentation

static void clear ( QVariant::Private *  d  )  [static]

Definition at line 176 of file qvariant.cpp.

References QVariant::BitArray, QVariant::Bool, QVariant::ByteArray, QVariant::Char, d, QVariant::Date, QVariant::DateTime, QMetaType::destroy(), QVariant::Double, QVariant::Int, QVariant::Invalid, QVariant::Line, QVariant::LineF, QVariant::List, QVariant::Locale, QVariant::LongLong, QVariant::Map, QVariant::Point, QVariant::PointF, QVariant::Rect, QVariant::RectF, QVariant::RegExp, QVariant::Size, QVariant::SizeF, QVariant::String, QVariant::StringList, QVariant::Time, QVariant::UInt, QVariant::ULongLong, QVariant::Url, and QVariant::UserType.

Referenced by qdesigner_internal::ActionFilterWidget::ActionFilterWidget(), MainWindow::createActions(), DropSiteWindow::DropSiteWindow(), Q3TextString::operator=(), Q3ValueVector< T >::operator=(), QVarLengthArray< const char *, QDBusError::LastErrorType >::operator=(), QProcessPrivate::Channel::operator=(), QProcessPrivate::Channel::pipeFrom(), QProcessPrivate::Channel::pipeTo(), QResourcePrivate::QResourcePrivate(), QRingBuffer::QRingBuffer(), Q3AsciiCache< type >::~Q3AsciiCache(), Q3AsciiDict< QMetaObject >::~Q3AsciiDict(), Q3Cache< type >::~Q3Cache(), Q3Dict< Q3DnsDomain >::~Q3Dict(), Q3IntCache< type >::~Q3IntCache(), Q3IntDict< int >::~Q3IntDict(), Q3ObjectDictionary::~Q3ObjectDictionary(), Q3PtrDict< QSVChildRec >::~Q3PtrDict(), Q3PtrQueue< Q3NetworkOperation >::~Q3PtrQueue(), Q3PtrStack< type >::~Q3PtrStack(), Q3PtrVector< Q3DnsQuery >::~Q3PtrVector(), Q3SortedList< type >::~Q3SortedList(), Q3StrVec::~Q3StrVec(), QCache< int, QPixmap >::~QCache(), and QResourcePrivate::~QResourcePrivate().

00177 {
00178     switch (d->type) {
00179     case QVariant::String:
00180         v_clear<QString>(d);
00181         break;
00182     case QVariant::Char:
00183         v_clear<QChar>(d);
00184         break;
00185     case QVariant::StringList:
00186         v_clear<QStringList>(d);
00187         break;
00188     case QVariant::Map:
00189         v_clear<QVariantMap>(d);
00190         break;
00191     case QVariant::List:
00192         v_clear<QVariantList>(d);
00193         break;
00194     case QVariant::Date:
00195         v_clear<QDate>(d);
00196         break;
00197     case QVariant::Time:
00198         v_clear<QTime>(d);
00199         break;
00200     case QVariant::DateTime:
00201         v_clear<QDateTime>(d);
00202         break;
00203     case QVariant::ByteArray:
00204         v_clear<QByteArray>(d);
00205         break;
00206     case QVariant::BitArray:
00207         v_clear<QBitArray>(d);
00208         break;
00209 #ifndef QT_NO_GEOM_VARIANT
00210     case QVariant::Point:
00211         v_clear<QPoint>(d);
00212         break;
00213     case QVariant::PointF:
00214         v_clear<QPointF>(d);
00215         break;
00216     case QVariant::Size:
00217         v_clear<QSize>(d);
00218         break;
00219     case QVariant::SizeF:
00220         v_clear<QSizeF>(d);
00221         break;
00222     case QVariant::Rect:
00223         v_clear<QRect>(d);
00224         break;
00225     case QVariant::LineF:
00226         v_clear<QLineF>(d);
00227         break;
00228     case QVariant::Line:
00229         v_clear<QLine>(d);
00230         break;
00231     case QVariant::RectF:
00232         v_clear<QRectF>(d);
00233         break;
00234 #endif
00235     case QVariant::Url:
00236         v_clear<QUrl>(d);
00237         break;
00238     case QVariant::Locale:
00239         v_clear<QLocale>(d);
00240         break;
00241     case QVariant::RegExp:
00242         v_clear<QRegExp>(d);
00243         break;
00244     case QVariant::LongLong:
00245     case QVariant::ULongLong:
00246     case QVariant::Double:
00247         break;
00248     case QVariant::Invalid:
00249     case QVariant::UserType:
00250     case QVariant::Int:
00251     case QVariant::UInt:
00252     case QVariant::Bool:
00253         break;
00254     default:
00255         QMetaType::destroy(d->type, d->data.shared->ptr);
00256         delete d->data.shared;
00257         break;
00258     }
00259 
00260     d->type = QVariant::Invalid;
00261     d->is_null = true;
00262     d->is_shared = false;
00263 }

Here is the call graph for this function:

static bool compare ( const QVariant::Private *  a,
const QVariant::Private *  b 
) [static]

Definition at line 319 of file qvariant.cpp.

References a, b, QVariant::BitArray, QVariant::Bool, QVariant::ByteArray, QVariant::Char, QVariant::Date, QVariant::DateTime, QVariant::Double, QVariant::Int, QVariant::Invalid, QMetaType::isRegistered(), QVariant::Line, QVariant::LineF, QVariant::List, QVariant::Locale, QVariant::LongLong, QVariant::Map, QVariant::Point, QVariant::PointF, QVariant::QVariantMap(), QVariant::Rect, QVariant::RectF, QVariant::RegExp, QVariant::Size, QVariant::SizeF, QVariant::String, QVariant::StringList, QVariant::Time, QVariant::UInt, QVariant::ULongLong, and QVariant::Url.

Referenced by QListModel::ensureSorted(), QTreeModel::ensureSorted(), QTableModel::ensureSorted(), QWidget::isActiveWindow(), QSortFilterProxyModelPrivate::proxy_intervals_for_source_items_to_add(), QTableModel::sort(), QListModel::sort(), QTreeModel::sortItems(), and QCss::Parser::testPrio().

00320 {
00321     switch(a->type) {
00322     case QVariant::List:
00323         return *v_cast<QVariantList>(a) == *v_cast<QVariantList>(b);
00324     case QVariant::Map: {
00325         const QVariantMap *m1 = v_cast<QVariantMap>(a);
00326         const QVariantMap *m2 = v_cast<QVariantMap>(b);
00327         if (m1->count() != m2->count())
00328             return false;
00329         QVariantMap::ConstIterator it = m1->constBegin();
00330         QVariantMap::ConstIterator it2 = m2->constBegin();
00331         while (it != m1->constEnd()) {
00332             if (*it != *it2)
00333                 return false;
00334             ++it;
00335             ++it2;
00336         }
00337         return true;
00338     }
00339     case QVariant::String:
00340         return *v_cast<QString>(a) == *v_cast<QString>(b);
00341     case QVariant::Char:
00342         return *v_cast<QChar>(a) == *v_cast<QChar>(b);
00343     case QVariant::StringList:
00344         return *v_cast<QStringList>(a) == *v_cast<QStringList>(b);
00345 #ifndef QT_NO_GEOM_VARIANT
00346     case QVariant::Size:
00347         return *v_cast<QSize>(a) == *v_cast<QSize>(b);
00348     case QVariant::SizeF:
00349         return *v_cast<QSizeF>(a) == *v_cast<QSizeF>(b);
00350     case QVariant::Rect:
00351         return *v_cast<QRect>(a) == *v_cast<QRect>(b);
00352     case QVariant::Line:
00353         return *v_cast<QLine>(a) == *v_cast<QLine>(b);
00354     case QVariant::LineF:
00355         return *v_cast<QLineF>(a) == *v_cast<QLineF>(b);
00356     case QVariant::RectF:
00357         return *v_cast<QRectF>(a) == *v_cast<QRectF>(b);
00358     case QVariant::Point:
00359         return *v_cast<QPoint>(a) == *v_cast<QPoint>(b);
00360     case QVariant::PointF:
00361         return *v_cast<QPointF>(a) == *v_cast<QPointF>(b);
00362 #endif
00363     case QVariant::Url:
00364         return *v_cast<QUrl>(a) == *v_cast<QUrl>(b);
00365     case QVariant::Locale:
00366         return *v_cast<QLocale>(a) == *v_cast<QLocale>(b);
00367     case QVariant::RegExp:
00368         return *v_cast<QRegExp>(a) == *v_cast<QRegExp>(b);
00369     case QVariant::Int:
00370         return a->data.i == b->data.i;
00371     case QVariant::UInt:
00372         return a->data.u == b->data.u;
00373     case QVariant::LongLong:
00374         return a->data.ll == b->data.ll;
00375     case QVariant::ULongLong:
00376         return a->data.ull == b->data.ull;
00377     case QVariant::Bool:
00378         return a->data.b == b->data.b;
00379     case QVariant::Double:
00380         return a->data.d == b->data.d;
00381     case QVariant::Date:
00382         return *v_cast<QDate>(a) == *v_cast<QDate>(b);
00383     case QVariant::Time:
00384         return *v_cast<QTime>(a) == *v_cast<QTime>(b);
00385     case QVariant::DateTime:
00386         return *v_cast<QDateTime>(a) == *v_cast<QDateTime>(b);
00387     case QVariant::ByteArray:
00388         return *v_cast<QByteArray>(a) == *v_cast<QByteArray>(b);
00389     case QVariant::BitArray:
00390         return *v_cast<QBitArray>(a) == *v_cast<QBitArray>(b);
00391     case QVariant::Invalid:
00392         return true;
00393     default:
00394         break;
00395     }
00396     if (!QMetaType::isRegistered(a->type))
00397         qFatal("QVariant::compare: type %d unknown to QVariant.", a->type);
00398     return a->data.shared->ptr == b->data.shared->ptr;
00399 }

Here is the call graph for this function:

static const void* constData ( const QVariant::Private &  d  )  [static]

Definition at line 55 of file qvariant.cpp.

References QVariant::Bool, d, QVariant::Double, QVariant::Int, QVariant::LongLong, QVariant::UInt, and QVariant::ULongLong.

Referenced by QPrintDialogPrivate::_q_printToFileChanged(), QDateTimeParser::absoluteMax(), QDateTimeParser::absoluteMin(), QVariant::constData(), convert(), QVariant::data(), QTest::defaultEventDelay(), QTest::defaultKeyDelay(), QTest::defaultKeyVerbose(), QTest::defaultMouseDelay(), QDBusConnectionPrivate::deliverCall(), QODBCResult::exec(), QProcessPrivate::execChild(), QTextStreamPrivate::fillReadBuffer(), QTextStreamPrivate::flushWriteBuffer(), QDateTimeParser::getDigit(), Index::getDocumentTitle(), getLprPrinters(), initializeDb(), Launcher::launchExample(), Config::loadConfig(), QLibraryInfo::location(), main(), QDateTimeParser::maxChange(), QFSFileEngine::open(), QUrlPrivate::parse(), Index::parseDocument(), ProjectPorter::portFiles(), ProjectPorter::portProject(), Preprocessor::preprocessed(), qErrnoWarning(), QProcess::readData(), QProcessPrivate::readFromStderr(), QProcessPrivate::readFromStdout(), registerFont(), Index::searchForPattern(), QDateTimeParser::sectionFormat(), QDateTimeParser::sectionMaxSize(), QDateTimeParser::setDigit(), QWidget::setFocusProxy(), QLCDNumber::setNumDigits(), setupLocaleMapper(), QAbstractSocket::waitForBytesWritten(), QAbstractSocket::waitForDisconnected(), QAbstractSocket::waitForReadyRead(), QProcess::writeData(), RCCFileInfo::writeDataInfo(), FileWriter::writeFile(), FileWriter::writeFileVerbously(), RCCResourceLibrary::writeHeader(), and QProcessPrivate::writeToStdin().

00056 {
00057     switch (d.type) {
00058     case QVariant::Int:
00059         return &d.data.i;
00060     case QVariant::UInt:
00061         return &d.data.u;
00062     case QVariant::Bool:
00063         return &d.data.b;
00064     case QVariant::LongLong:
00065         return &d.data.ll;
00066     case QVariant::ULongLong:
00067         return &d.data.ull;
00068     case QVariant::Double:
00069         return &d.data.d;
00070     default:
00071         return d.is_shared ? d.data.shared->ptr : reinterpret_cast<const void *>(&d.data.ptr);
00072     }
00073 }

static void construct ( QVariant::Private *  x,
const void *  copy 
) [static]

Definition at line 75 of file qvariant.cpp.

References QVariant::BitArray, QVariant::Bool, QVariant::ByteArray, QVariant::Char, QMetaType::construct(), QVariant::Date, QVariant::DateTime, QVariant::Double, QVariant::Int, QVariant::Invalid, QVariant::Line, QVariant::LineF, QVariant::List, QVariant::Locale, QVariant::LongLong, QVariant::Map, QVariant::Point, QVariant::PointF, Q_INT64_C, Q_UINT64_C, QVariant::Rect, QVariant::RectF, QVariant::RegExp, QVariant::Size, QVariant::SizeF, QVariant::String, QVariant::StringList, QVariant::Time, u, QVariant::UInt, QVariant::ULongLong, QVariant::Url, QVariant::UserType, and x.

00076 {
00077     x->is_shared = false;
00078 
00079     switch (x->type) {
00080     case QVariant::String:
00081         v_construct<QString>(x, copy);
00082         break;
00083     case QVariant::Char:
00084         v_construct<QChar>(x, copy);
00085         break;
00086     case QVariant::StringList:
00087         v_construct<QStringList>(x, copy);
00088         break;
00089     case QVariant::Map:
00090         v_construct<QVariantMap>(x, copy);
00091         break;
00092     case QVariant::List:
00093         v_construct<QVariantList>(x, copy);
00094         break;
00095     case QVariant::Date:
00096         v_construct<QDate>(x, copy);
00097         break;
00098     case QVariant::Time:
00099         v_construct<QTime>(x, copy);
00100         break;
00101     case QVariant::DateTime:
00102         v_construct<QDateTime>(x, copy);
00103         break;
00104     case QVariant::ByteArray:
00105         v_construct<QByteArray>(x, copy);
00106         break;
00107     case QVariant::BitArray:
00108         v_construct<QBitArray>(x, copy);
00109         break;
00110 #ifndef QT_NO_GEOM_VARIANT
00111     case QVariant::Size:
00112         v_construct<QSize>(x, copy);
00113         break;
00114     case QVariant::SizeF:
00115         v_construct<QSizeF>(x, copy);
00116         break;
00117     case QVariant::Rect:
00118         v_construct<QRect>(x, copy);
00119         break;
00120     case QVariant::LineF:
00121         v_construct<QLineF>(x, copy);
00122         break;
00123     case QVariant::Line:
00124         v_construct<QLine>(x, copy);
00125         break;
00126     case QVariant::RectF:
00127         v_construct<QRectF>(x, copy);
00128         break;
00129     case QVariant::Point:
00130         v_construct<QPoint>(x, copy);
00131         break;
00132     case QVariant::PointF:
00133         v_construct<QPointF>(x, copy);
00134         break;
00135 #endif
00136     case QVariant::Url:
00137         v_construct<QUrl>(x, copy);
00138         break;
00139     case QVariant::Locale:
00140         v_construct<QLocale>(x, copy);
00141         break;
00142     case QVariant::RegExp:
00143         v_construct<QRegExp>(x, copy);
00144         break;
00145     case QVariant::Int:
00146         x->data.i = copy ? *static_cast<const int *>(copy) : 0;
00147         break;
00148     case QVariant::UInt:
00149         x->data.u = copy ? *static_cast<const uint *>(copy) : 0u;
00150         break;
00151     case QVariant::Bool:
00152         x->data.b = copy ? *static_cast<const bool *>(copy) : false;
00153         break;
00154     case QVariant::Double:
00155         x->data.d = copy ? *static_cast<const double*>(copy) : 0.0;
00156         break;
00157     case QVariant::LongLong:
00158         x->data.ll = copy ? *static_cast<const qlonglong *>(copy) : Q_INT64_C(0);
00159         break;
00160     case QVariant::ULongLong:
00161         x->data.ull = copy ? *static_cast<const qulonglong *>(copy) : Q_UINT64_C(0);
00162         break;
00163     case QVariant::Invalid:
00164     case QVariant::UserType:
00165         break;
00166     default:
00167         x->is_shared = true;
00168         x->data.shared = new QVariant::PrivateShared(QMetaType::construct(x->type, copy));
00169         if (!x->data.shared->ptr)
00170              Q_ASSERT_X(x->type > 62, "QVariant::construct()", "Unknown datatype");
00171         break;
00172     }
00173     x->is_null = !copy;
00174 }

Here is the call graph for this function:

static bool convert ( const QVariant::Private *  d,
QVariant::Type  t,
void *  result,
bool *  ok 
) [static]

Definition at line 507 of file qvariant.cpp.

References QList< T >::append(), b, QVariant::Bool, QVariant::ByteArray, c, QMetaType::Char, QVariant::Char, constData(), d, QVariant::Date, QVariant::DateTime, DBL_DIG, QVariant::Double, QMetaType::Float, FLT_DIG, QChar::fromAscii(), QString::fromAscii(), QDate::fromString(), QDateTime::fromString(), QTime::fromString(), i, QVariant::Int, QString::isEmpty(), isNull(), Qt::ISODate, QVariant::Line, QVariant::LineF, QVariant::List, QMetaType::Long, QVariant::LongLong, QVariant::Map, QString::number(), QByteArray::number(), QVariant::Point, QVariant::PointF, Q_INT64_C, Q_UINT64_C, qConvertToNumber(), qConvertToUnsignedNumber(), qMetaTypeNumber(), qMetaTypeUNumber(), QByteArray::qstrcmp(), QVariant::QVariantList(), QVariant::Rect, QVariant::RectF, s, QMetaType::Short, QVariant::Size, QVariant::SizeF, QVariant::String, QVariant::StringList, t, QVariant::Time, toDouble(), toString(), QMetaType::typeName(), QMetaType::UChar, QVariant::UInt, QMetaType::ULong, QVariant::ULongLong, and QMetaType::UShort.

Referenced by main().

00508 {
00509     Q_ASSERT(d->type != uint(t));
00510 
00511     bool dummy;
00512     if (!ok)
00513         ok = &dummy;
00514 
00515     switch (uint(t)) {
00516     case QVariant::String: {
00517         QString *str = static_cast<QString *>(result);
00518         switch (d->type) {
00519         case QVariant::Char:
00520             *str = QString(*v_cast<QChar>(d));
00521             break;
00522         case QMetaType::Char:
00523         case QMetaType::UChar:
00524             *str = QChar::fromAscii(*static_cast<char *>(d->data.shared->ptr));
00525             break;
00526         case QMetaType::Short:
00527         case QMetaType::Long:
00528         case QVariant::Int:
00529         case QVariant::LongLong:
00530             *str = QString::number(qMetaTypeNumber(d));
00531             break;
00532         case QVariant::UInt:
00533         case QVariant::ULongLong:
00534         case QMetaType::UShort:
00535         case QMetaType::ULong:
00536             *str = QString::number(qMetaTypeUNumber(d));
00537             break;
00538         case QMetaType::Float:
00539             *str = QString::number(*static_cast<float *>(d->data.shared->ptr), 'g', FLT_DIG);
00540             break;
00541         case QVariant::Double:
00542             *str = QString::number(d->data.d, 'g', DBL_DIG);
00543             break;
00544 #if !defined(QT_NO_DATESTRING)
00545         case QVariant::Date:
00546             *str = v_cast<QDate>(d)->toString(Qt::ISODate);
00547             break;
00548         case QVariant::Time:
00549             *str = v_cast<QTime>(d)->toString(Qt::ISODate);
00550             break;
00551         case QVariant::DateTime:
00552             *str = v_cast<QDateTime>(d)->toString(Qt::ISODate);
00553             break;
00554 #endif
00555         case QVariant::Bool:
00556             *str = QLatin1String(d->data.b ? "true" : "false");
00557             break;
00558         case QVariant::ByteArray:
00559             *str = QString::fromAscii(v_cast<QByteArray>(d)->constData());
00560             break;
00561         case QVariant::StringList:
00562             if (v_cast<QStringList>(d)->count() == 1)
00563                 *str = v_cast<QStringList>(d)->at(0);
00564             break;
00565         default:
00566             return false;
00567         }
00568         break;
00569     }
00570     case QVariant::Char: {
00571         QChar *c = static_cast<QChar *>(result);
00572         switch (d->type) {
00573         case QVariant::Int:
00574         case QVariant::LongLong:
00575         case QMetaType::Char:
00576         case QMetaType::Short:
00577         case QMetaType::Long:
00578         case QMetaType::Float:
00579             *c = QChar(ushort(qMetaTypeNumber(d)));
00580             break;
00581         case QVariant::UInt:
00582         case QVariant::ULongLong:
00583         case QMetaType::UChar:
00584         case QMetaType::UShort:
00585         case QMetaType::ULong:
00586             *c = QChar(ushort(qMetaTypeUNumber(d)));
00587             break;
00588         default:
00589             return false;
00590         }
00591         break;
00592     }
00593 #ifndef QT_NO_GEOM_VARIANT
00594     case QVariant::Size: {
00595         QSize *s = static_cast<QSize *>(result);
00596         switch (d->type) {
00597         case QVariant::SizeF:
00598             *s = v_cast<QSizeF>(d)->toSize();
00599             break;
00600         default:
00601             return false;
00602         }
00603         break;
00604     }
00605 
00606     case QVariant::SizeF: {
00607         QSizeF *s = static_cast<QSizeF *>(result);
00608         switch (d->type) {
00609         case QVariant::Size:
00610             *s = QSizeF(*(v_cast<QSize>(d)));
00611             break;
00612         default:
00613             return false;
00614         }
00615         break;
00616     }
00617 
00618     case QVariant::Line: {
00619         QLine *s = static_cast<QLine *>(result);
00620         switch (d->type) {
00621         case QVariant::LineF:
00622             *s = v_cast<QLineF>(d)->toLine();
00623             break;
00624         default:
00625             return false;
00626         }
00627         break;
00628     }
00629 
00630     case QVariant::LineF: {
00631         QLineF *s = static_cast<QLineF *>(result);
00632         switch (d->type) {
00633         case QVariant::Line:
00634             *s = QLineF(*(v_cast<QLine>(d)));
00635             break;
00636         default:
00637             return false;
00638         }
00639         break;
00640     }
00641 #endif
00642     case QVariant::StringList:
00643         if (d->type == QVariant::List) {
00644             QStringList *slst = static_cast<QStringList *>(result);
00645             const QVariantList *list = v_cast<QVariantList >(d);
00646             for (int i = 0; i < list->size(); ++i)
00647                 slst->append(list->at(i).toString());
00648         } else if (d->type == QVariant::String) {
00649             QStringList *slst = static_cast<QStringList *>(result);
00650             *slst = QStringList(*v_cast<QString>(d));
00651         } else {
00652             return false;
00653         }
00654         break;
00655     case QVariant::Date: {
00656         QDate *dt = static_cast<QDate *>(result);
00657         if (d->type == QVariant::DateTime)
00658             *dt = v_cast<QDateTime>(d)->date();
00659 #ifndef QT_NO_DATESTRING
00660         else if (d->type == QVariant::String)
00661             *dt = QDate::fromString(*v_cast<QString>(d), Qt::ISODate);
00662 #endif
00663         else
00664             return false;
00665         break;
00666     }
00667     case QVariant::Time: {
00668         QTime *t = static_cast<QTime *>(result);
00669         switch (d->type) {
00670         case QVariant::DateTime:
00671             *t = v_cast<QDateTime>(d)->time();
00672             break;
00673 #ifndef QT_NO_DATESTRING
00674         case QVariant::String:
00675             *t = QTime::fromString(*v_cast<QString>(d), Qt::ISODate);
00676             break;
00677 #endif
00678         default:
00679             return false;
00680         }
00681         break;
00682     }
00683     case QVariant::DateTime: {
00684         QDateTime *dt = static_cast<QDateTime *>(result);
00685         switch (d->type) {
00686 #ifndef QT_NO_DATESTRING
00687         case QVariant::String:
00688             *dt = QDateTime::fromString(*v_cast<QString>(d), Qt::ISODate);
00689             break;
00690 #endif
00691         case QVariant::Date:
00692             *dt = QDateTime(*v_cast<QDate>(d));
00693             break;
00694         default:
00695             return false;
00696         }
00697         break;
00698     }
00699     case QVariant::ByteArray: {
00700         QByteArray *ba = static_cast<QByteArray *>(result);
00701         switch (d->type) {
00702         case QVariant::String:
00703             *ba = v_cast<QString>(d)->toAscii();
00704             break;
00705         case QVariant::Double:
00706             *ba = QByteArray::number(d->data.d, 'g', DBL_DIG);
00707             break;
00708         case QMetaType::Float:
00709             *ba = QByteArray::number(*static_cast<float *>(d->data.shared->ptr), 'g', FLT_DIG);
00710             break;
00711         case QMetaType::Char:
00712         case QMetaType::UChar:
00713             *ba = QByteArray(1, *static_cast<char *>(d->data.shared->ptr));
00714             break;
00715         case QVariant::Int:
00716         case QVariant::LongLong:
00717         case QMetaType::Short:
00718         case QMetaType::Long:
00719             *ba = QByteArray::number(qMetaTypeNumber(d));
00720             break;
00721         case QVariant::UInt:
00722         case QVariant::ULongLong:
00723         case QMetaType::UShort:
00724         case QMetaType::ULong:
00725             *ba = QByteArray::number(qMetaTypeUNumber(d));
00726             break;
00727         default:
00728             return false;
00729         }
00730     }
00731     break;
00732     case QMetaType::Short:
00733         *static_cast<short *>(result) = short(qConvertToNumber(d, ok));
00734         return *ok;
00735     case QMetaType::Long:
00736         *static_cast<long *>(result) = long(qConvertToNumber(d, ok));
00737         return *ok;
00738     case QMetaType::UShort:
00739         *static_cast<ushort *>(result) = ushort(qConvertToUnsignedNumber(d, ok));
00740         return *ok;
00741     case QMetaType::ULong:
00742         *static_cast<ulong *>(result) = ulong(qConvertToUnsignedNumber(d, ok));
00743         return *ok;
00744     case QVariant::Int:
00745         *static_cast<int *>(result) = int(qConvertToNumber(d, ok));
00746         return *ok;
00747     case QVariant::UInt:
00748         *static_cast<uint *>(result) = uint(qConvertToUnsignedNumber(d, ok));
00749         return *ok;
00750     case QVariant::LongLong:
00751         *static_cast<qlonglong *>(result) = qConvertToNumber(d, ok);
00752         return *ok;
00753     case QVariant::ULongLong: {
00754         *static_cast<qulonglong *>(result) = qConvertToUnsignedNumber(d, ok);
00755         return *ok;
00756     }
00757     case QVariant::Bool: {
00758         bool *b = static_cast<bool *>(result);
00759         switch(d->type) {
00760         case QVariant::String:
00761         {
00762             QString str = v_cast<QString>(d)->toLower();
00763             *b = !(str == QLatin1String("0") || str == QLatin1String("false") || str.isEmpty());
00764             break;
00765         }
00766         case QVariant::Char:
00767             *b = !v_cast<QChar>(d)->isNull();
00768             break;
00769         case QVariant::Double:
00770         case QVariant::Int:
00771         case QVariant::LongLong:
00772         case QMetaType::Char:
00773         case QMetaType::Short:
00774         case QMetaType::Long:
00775         case QMetaType::Float:
00776             *b = qMetaTypeNumber(d) != Q_INT64_C(0);
00777             break;
00778         case QVariant::UInt:
00779         case QVariant::ULongLong:
00780         case QMetaType::UChar:
00781         case QMetaType::UShort:
00782         case QMetaType::ULong:
00783             *b = qMetaTypeUNumber(d) != Q_UINT64_C(0);
00784             break;
00785         default:
00786             *b = false;
00787             return false;
00788         }
00789         break;
00790     }
00791     case QVariant::Double: {
00792         double *f = static_cast<double *>(result);
00793         switch (d->type) {
00794         case QVariant::String:
00795             *f = v_cast<QString>(d)->toDouble(ok);
00796             break;
00797         case QVariant::ByteArray:
00798             *f = v_cast<QByteArray>(d)->toDouble(ok);
00799             break;
00800         case QVariant::Bool:
00801             *f = double(d->data.b);
00802             break;
00803         case QMetaType::Float:
00804             *f = *static_cast<float *>(d->data.shared->ptr);
00805             break;
00806         case QVariant::LongLong:
00807         case QVariant::Int:
00808         case QMetaType::Char:
00809         case QMetaType::Short:
00810         case QMetaType::Long:
00811             *f = double(qMetaTypeNumber(d));
00812             break;
00813         case QVariant::UInt:
00814         case QVariant::ULongLong:
00815         case QMetaType::UChar:
00816         case QMetaType::UShort:
00817         case QMetaType::ULong:
00818 #if defined(Q_CC_MSVC) && !defined(Q_CC_MSVC_NET)
00819             *f = (double)(qlonglong)qMetaTypeUNumber(d);
00820 #else
00821             *f = double(qMetaTypeUNumber(d));
00822 #endif
00823             break;
00824         default:
00825             *f = 0.0;
00826             return false;
00827         }
00828         break;
00829     }
00830     case QMetaType::Float: {
00831         float *f = static_cast<float *>(result);
00832         switch (d->type) {
00833         case QVariant::String:
00834             *f = float(v_cast<QString>(d)->toDouble(ok));
00835             break;
00836         case QVariant::ByteArray:
00837             *f = float(v_cast<QByteArray>(d)->toDouble(ok));
00838             break;
00839         case QVariant::Bool:
00840             *f = float(d->data.b);
00841             break;
00842         case QVariant::Double:
00843             *f = float(d->data.d);
00844             break;
00845         case QVariant::LongLong:
00846         case QVariant::Int:
00847         case QMetaType::Char:
00848         case QMetaType::Short:
00849         case QMetaType::Long:
00850             *f = float(qMetaTypeNumber(d));
00851             break;
00852         case QVariant::UInt:
00853         case QVariant::ULongLong:
00854         case QMetaType::UChar:
00855         case QMetaType::UShort:
00856         case QMetaType::ULong:
00857 #if defined(Q_CC_MSVC) && !defined(Q_CC_MSVC_NET)
00858             *f = (float)(qlonglong)qMetaTypeUNumber(d);
00859 #else
00860             *f = float(qMetaTypeUNumber(d));
00861 #endif
00862             break;
00863         default:
00864             *f = 0.0f;
00865             return false;
00866         }
00867         break;
00868     }
00869     case QVariant::List:
00870         if (d->type == QVariant::StringList) {
00871             QVariantList *lst = static_cast<QVariantList *>(result);
00872             const QStringList *slist = v_cast<QStringList>(d);
00873             for (int i = 0; i < slist->size(); ++i)
00874                 lst->append(QVariant(slist->at(i)));
00875         } else if (qstrcmp(QMetaType::typeName(d->type), "QList<QVariant>") == 0) {
00876             *static_cast<QVariantList *>(result) =
00877                 *static_cast<QList<QVariant> *>(d->data.shared->ptr);
00878         } else {
00879             return false;
00880         }
00881         break;
00882     case QVariant::Map:
00883         if (qstrcmp(QMetaType::typeName(d->type), "QMap<QString, QVariant>") == 0) {
00884             *static_cast<QVariantMap *>(result) =
00885                 *static_cast<QMap<QString, QVariant> *>(d->data.shared->ptr);
00886         } else {
00887             return false;
00888         }
00889         break;
00890 #ifndef QT_NO_GEOM_VARIANT
00891     case QVariant::Rect:
00892         if (d->type == QVariant::RectF)
00893             *static_cast<QRect *>(result) = (v_cast<QRectF>(d))->toRect();
00894         else
00895             return false;
00896         break;
00897     case QVariant::RectF:
00898         if (d->type == QVariant::Rect)
00899             *static_cast<QRectF *>(result) = *v_cast<QRect>(d);
00900         else
00901             return false;
00902         break;
00903     case QVariant::PointF:
00904         if (d->type == QVariant::Point)
00905             *static_cast<QPointF *>(result) = *v_cast<QPoint>(d);
00906         else
00907             return false;
00908         break;
00909     case QVariant::Point:
00910         if (d->type == QVariant::PointF)
00911             *static_cast<QPoint *>(result) = (v_cast<QPointF>(d))->toPoint();
00912         else
00913             return false;
00914         break;
00915 #endif
00916     default:
00917         return false;
00918     }
00919     return true;
00920 }

Here is the call graph for this function:

static bool isNull ( const QVariant::Private *  d  )  [static]

Definition at line 265 of file qvariant.cpp.

References QVariant::BitArray, QVariant::Bool, QVariant::ByteArray, QVariant::Char, d, QVariant::Date, QVariant::DateTime, QVariant::Double, QVariant::Int, QVariant::Invalid, QVariant::Line, QVariant::LineF, QVariant::List, QVariant::Locale, QVariant::LongLong, QVariant::Map, QVariant::Point, QVariant::PointF, QVariant::Rect, QVariant::RectF, QVariant::RegExp, QVariant::Size, QVariant::SizeF, QVariant::String, QVariant::StringList, QVariant::Time, QVariant::UInt, QVariant::ULongLong, QVariant::Url, and QVariant::UserType.

Referenced by Q3ActionGroup::addTo(), convert(), isNull(), Q3ComboBox::keyPressEvent(), QToolBoxButton::minimumSizeHint(), qdesigner_internal::NewActionDialog::on_iconButton_clicked(), QPixmap::operator!(), Q3TextEdit::pickSpecial(), QPlastiqueStylePrivate::QPlastiqueStylePrivate(), qt_message_output(), Q3MainWindow::setUpLayout(), QDockWidgetTitleButton::sizeHint(), QPushButton::sizeHint(), QToolBoxButton::sizeHint(), and QComboBoxPrivate::updateLineEditGeometry().

00266 {
00267     switch(d->type) {
00268     case QVariant::String:
00269         return v_cast<QString>(d)->isNull();
00270     case QVariant::Char:
00271         return v_cast<QChar>(d)->isNull();
00272     case QVariant::Date:
00273         return v_cast<QDate>(d)->isNull();
00274     case QVariant::Time:
00275         return v_cast<QTime>(d)->isNull();
00276     case QVariant::DateTime:
00277         return v_cast<QDateTime>(d)->isNull();
00278     case QVariant::ByteArray:
00279         return v_cast<QByteArray>(d)->isNull();
00280     case QVariant::BitArray:
00281         return v_cast<QBitArray>(d)->isNull();
00282 #ifndef QT_NO_GEOM_VARIANT
00283     case QVariant::Size:
00284         return v_cast<QSize>(d)->isNull();
00285     case QVariant::SizeF:
00286         return v_cast<QSizeF>(d)->isNull();
00287     case QVariant::Rect:
00288         return v_cast<QRect>(d)->isNull();
00289     case QVariant::Line:
00290         return v_cast<QLine>(d)->isNull();
00291     case QVariant::LineF:
00292         return v_cast<QLineF>(d)->isNull();
00293     case QVariant::RectF:
00294         return v_cast<QRectF>(d)->isNull();
00295     case QVariant::Point:
00296         return v_cast<QPoint>(d)->isNull();
00297     case QVariant::PointF:
00298         return v_cast<QPointF>(d)->isNull();
00299 #endif
00300     case QVariant::Url:
00301     case QVariant::Locale:
00302     case QVariant::RegExp:
00303     case QVariant::StringList:
00304     case QVariant::Map:
00305     case QVariant::List:
00306     case QVariant::Invalid:
00307     case QVariant::UserType:
00308     case QVariant::Int:
00309     case QVariant::UInt:
00310     case QVariant::LongLong:
00311     case QVariant::ULongLong:
00312     case QVariant::Bool:
00313     case QVariant::Double:
00314         break;
00315     }
00316     return d->is_null;
00317 }

QDebug operator<< ( QDebug  dbg,
const QVariant::Type  p 
)

Definition at line 2602 of file qvariant.cpp.

02603 {
02604 #ifndef Q_BROKEN_DEBUG_STREAM
02605     dbg.nospace() << "QVariant::" << QVariant::typeToName(p);
02606     return dbg.space();
02607 #else
02608     qWarning("This compiler doesn't support streaming QVariant::Type to QDebug");
02609     return dbg;
02610     Q_UNUSED(p);
02611 #endif
02612 }

QDebug operator<< ( QDebug  dbg,
const QVariant &  v 
)

Definition at line 2588 of file qvariant.cpp.

02589 {
02590 #ifndef Q_BROKEN_DEBUG_STREAM
02591     dbg.nospace() << "QVariant(" << v.typeName() << ", ";
02592     QVariant::handler->debugStream(dbg, v);
02593     dbg.nospace() << ')';
02594     return dbg.space();
02595 #else
02596     qWarning("This compiler doesn't support streaming QVariant to QDebug");
02597     return dbg;
02598     Q_UNUSED(v);
02599 #endif
02600 }

QDataStream& operator<< ( QDataStream &  s,
const QVariant::Type  p 
)

Writes a variant type p to the stream s.

Definition at line 1851 of file qvariant.cpp.

01852 {
01853     s << static_cast<quint32>(p);
01854 
01855     return s;
01856 }

QDataStream& operator<< ( QDataStream &  s,
const QVariant &  p 
)

Writes a variant p to the stream s.

See also:
Format of the QDataStream operators

Definition at line 1830 of file qvariant.cpp.

01831 {
01832     p.save(s);
01833     return s;
01834 }

QDataStream& operator>> ( QDataStream &  s,
QVariant::Type &  p 
)

Reads a variant type p in enum representation from the stream s.

Definition at line 1839 of file qvariant.cpp.

01840 {
01841     quint32 u;
01842     s >> u;
01843     p = (QVariant::Type)u;
01844 
01845     return s;
01846 }

QDataStream& operator>> ( QDataStream &  s,
QVariant &  p 
)

Reads a variant p from the stream s.

See also:
Format of the QDataStream operators

Definition at line 1818 of file qvariant.cpp.

01819 {
01820     p.load(s);
01821     return s;
01822 }

static qlonglong qConvertToNumber ( const QVariant::Private *  d,
bool *  ok 
) [static]

Definition at line 441 of file qvariant.cpp.

References QVariant::Bool, QVariant::ByteArray, QMetaType::Char, QVariant::Char, d, QVariant::Double, QMetaType::Float, QVariant::Int, QMetaType::Long, QMetaType::LongLong, Q_INT64_C, qMetaTypeNumber(), qMetaTypeUNumber(), QMetaType::Short, QVariant::String, QMetaType::UChar, QVariant::UInt, QMetaType::ULong, QVariant::ULongLong, and QMetaType::UShort.

Referenced by convert().

00442 {
00443     *ok = true;
00444 
00445     switch (uint(d->type)) {
00446     case QVariant::String:
00447         return v_cast<QString>(d)->toLongLong(ok);
00448     case QVariant::Char:
00449         return v_cast<QChar>(d)->unicode();
00450     case QVariant::ByteArray:
00451         return v_cast<QByteArray>(d)->toLongLong(ok);
00452     case QVariant::Bool:
00453         return qlonglong(d->data.b);
00454     case QVariant::Double:
00455     case QVariant::Int:
00456     case QMetaType::Char:
00457     case QMetaType::Short:
00458     case QMetaType::Long:
00459     case QMetaType::Float:
00460     case QMetaType::LongLong:
00461         return qMetaTypeNumber(d);
00462     case QVariant::ULongLong:
00463     case QVariant::UInt:
00464     case QMetaType::UChar:
00465     case QMetaType::UShort:
00466     case QMetaType::ULong:
00467         return qlonglong(qMetaTypeUNumber(d));
00468     }
00469 
00470     *ok = false;
00471     return Q_INT64_C(0);
00472 }

Here is the call graph for this function:

static qulonglong qConvertToUnsignedNumber ( const QVariant::Private *  d,
bool *  ok 
) [static]

Definition at line 474 of file qvariant.cpp.

References QVariant::Bool, QVariant::ByteArray, QMetaType::Char, QVariant::Char, d, QVariant::Double, QMetaType::Float, QVariant::Int, QMetaType::Long, QMetaType::LongLong, Q_UINT64_C, qMetaTypeNumber(), qMetaTypeUNumber(), QMetaType::Short, QVariant::String, QMetaType::UChar, QVariant::UInt, QMetaType::ULong, QVariant::ULongLong, and QMetaType::UShort.

Referenced by convert().

00475 {
00476     *ok = true;
00477 
00478     switch (uint(d->type)) {
00479     case QVariant::String:
00480         return v_cast<QString>(d)->toULongLong(ok);
00481     case QVariant::Char:
00482         return v_cast<QChar>(d)->unicode();
00483     case QVariant::ByteArray:
00484         return v_cast<QByteArray>(d)->toULongLong(ok);
00485     case QVariant::Bool:
00486         return qulonglong(d->data.b);
00487     case QVariant::Double:
00488     case QVariant::Int:
00489     case QMetaType::Char:
00490     case QMetaType::Short:
00491     case QMetaType::Long:
00492     case QMetaType::Float:
00493     case QMetaType::LongLong:
00494         return qulonglong(qMetaTypeNumber(d));
00495     case QVariant::ULongLong:
00496     case QVariant::UInt:
00497     case QMetaType::UChar:
00498     case QMetaType::UShort:
00499     case QMetaType::ULong:
00500         return qMetaTypeUNumber(d);
00501     }
00502 
00503     *ok = false;
00504     return Q_UINT64_C(0);
00505 }

Here is the call graph for this function:

Q_CORE_EXPORT const QVariant::Handler* qcoreVariantHandler (  ) 

Definition at line 1027 of file qvariant.cpp.

References qt_kernel_variant_handler.

Referenced by clear(), compare(), construct(), convert(), isNull(), and streamDebug().

01028 {
01029     return &qt_kernel_variant_handler;
01030 }

static bool qIsFloatingPoint ( uint  tp  )  [static]

Definition at line 2519 of file qvariant.cpp.

References QVariant::Double, and QMetaType::Float.

Referenced by QVariant::cmp().

02520 {
02521     return tp == QVariant::Double || tp == QMetaType::Float;
02522 }

static bool qIsNumericType ( uint  tp  )  [static]

Definition at line 2513 of file qvariant.cpp.

References QVariant::Bool, QVariant::Double, QMetaType::Float, and QMetaType::Long.

Referenced by QVariant::cmp().

02514 {
02515     return (tp >= QVariant::Bool && tp <= QVariant::Double)
02516            || (tp >= QMetaType::Long && tp <= QMetaType::Float);
02517 }

static qlonglong qMetaTypeNumber ( const QVariant::Private *  d  )  [static]

Definition at line 401 of file qvariant.cpp.

References QMetaType::Char, d, QVariant::Double, QMetaType::Float, QMetaType::Int, QMetaType::Long, QMetaType::LongLong, and QMetaType::Short.

Referenced by convert(), qConvertToNumber(), and qConvertToUnsignedNumber().

00402 {
00403     switch (d->type) {
00404     case QMetaType::Int:
00405         return d->data.i;
00406     case QMetaType::LongLong:
00407         return d->data.ll;
00408     case QMetaType::Char:
00409         return qlonglong(*static_cast<signed char *>(d->data.shared->ptr));
00410     case QMetaType::Short:
00411         return qlonglong(*static_cast<short *>(d->data.shared->ptr));
00412     case QMetaType::Long:
00413         return qlonglong(*static_cast<long *>(d->data.shared->ptr));
00414     case QMetaType::Float:
00415         return qRound64(*static_cast<float *>(d->data.shared->ptr));
00416     case QVariant::Double:
00417         return qRound64(d->data.d);
00418     }
00419     Q_ASSERT(false);
00420     return 0;
00421 }

static qulonglong qMetaTypeUNumber ( const QVariant::Private *  d  )  [static]

Definition at line 423 of file qvariant.cpp.

References d, QMetaType::UChar, QVariant::UInt, QMetaType::ULong, QVariant::ULongLong, and QMetaType::UShort.

Referenced by convert(), qConvertToNumber(), and qConvertToUnsignedNumber().

00424 {
00425     switch (d->type) {
00426     case QVariant::UInt:
00427         return d->data.u;
00428     case QVariant::ULongLong:
00429         return d->data.ull;
00430     case QMetaType::UChar:
00431         return qulonglong(*static_cast<unsigned char *>(d->data.shared->ptr));
00432     case QMetaType::UShort:
00433         return qulonglong(*static_cast<ushort *>(d->data.shared->ptr));
00434     case QMetaType::ULong:
00435         return qulonglong(*static_cast<ulong *>(d->data.shared->ptr));
00436     }
00437     Q_ASSERT(false);
00438     return 0;
00439 }

template<typename T>
T qNumVariantToHelper ( const QVariant::Private &  d,
QVariant::Type  t,
const QVariant::Handler *  handler,
bool *  ok,
const T &  val 
) [inline]

Definition at line 2152 of file qvariant.cpp.

References d, handler, and T.

02154 {
02155     if (ok)
02156         *ok = true;
02157     if (d.type == t)
02158         return val;
02159 
02160     T ret;
02161     if (!handler->convert(&d, t, &ret, ok) && ok)
02162         *ok = false;
02163     return ret;
02164 }

template<typename T>
T qVariantToHelper ( const QVariant::Private &  d,
QVariant::Type  t,
const QVariant::Handler *  handler,
T *  = 0 
) [inline]

Definition at line 1868 of file qvariant.cpp.

References d, handler, and T.

01870 {
01871     if (d.type == t)
01872         return *v_cast<T>(&d);
01873 
01874     T ret;
01875     handler->convert(&d, t, &ret, 0);
01876     return ret;
01877 }

static void streamDebug ( QDebug  dbg,
const QVariant &  v 
) [static]

Definition at line 923 of file qvariant.cpp.

References QVariant::BitArray, QVariant::Bool, QVariant::ByteArray, QVariant::Char, QVariant::Date, QVariant::DateTime, QVariant::Double, QVariant::Int, QVariant::Line, QVariant::LineF, QVariant::List, QVariant::LongLong, QVariant::Map, QDebug::nospace(), QVariant::Point, QVariant::PointF, QVariant::Rect, QVariant::RectF, QVariant::Size, QVariant::SizeF, QVariant::String, QVariant::StringList, QVariant::Time, QVariant::toBool(), QVariant::toByteArray(), QVariant::toChar(), QVariant::toDate(), QVariant::toDateTime(), QVariant::toDouble(), QVariant::toInt(), QVariant::toLine(), QVariant::toLineF(), QVariant::toList(), QVariant::toLongLong(), QVariant::toMap(), QVariant::toPoint(), QVariant::toPointF(), QVariant::toRect(), QVariant::toRectF(), QVariant::toSize(), QVariant::toSizeF(), QVariant::toString(), QVariant::toStringList(), QVariant::toTime(), QVariant::toUInt(), QVariant::toULongLong(), QVariant::toUrl(), QVariant::type(), QVariant::UInt, QVariant::ULongLong, and QVariant::Url.

00924 {
00925     switch (v.type()) {
00926     case QVariant::Int:
00927         dbg.nospace() << v.toInt();
00928         break;
00929     case QVariant::UInt:
00930         dbg.nospace() << v.toUInt();
00931         break;
00932     case QVariant::LongLong:
00933         dbg.nospace() << v.toLongLong();
00934         break;
00935     case QVariant::ULongLong:
00936         dbg.nospace() << v.toULongLong();
00937         break;
00938     case QVariant::Double:
00939         dbg.nospace() << v.toDouble();
00940         break;
00941     case QVariant::Bool:
00942         dbg.nospace() << v.toBool();
00943         break;
00944     case QVariant::String:
00945         dbg.nospace() << v.toString();
00946         break;
00947     case QVariant::Char:
00948         dbg.nospace() << v.toChar();
00949         break;
00950     case QVariant::StringList:
00951         dbg.nospace() << v.toStringList();
00952         break;
00953     case QVariant::Map:
00954         dbg.nospace() << v.toMap();
00955         break;
00956     case QVariant::List:
00957         dbg.nospace() << v.toList();
00958         break;
00959     case QVariant::Date:
00960         dbg.nospace() << v.toDate();
00961         break;
00962     case QVariant::Time:
00963         dbg.nospace() << v.toTime();
00964         break;
00965     case QVariant::DateTime:
00966         dbg.nospace() << v.toDateTime();
00967         break;
00968     case QVariant::ByteArray:
00969         dbg.nospace() << v.toByteArray();
00970         break;
00971     case QVariant::Url:
00972         dbg.nospace() << v.toUrl();
00973         break;
00974 #ifndef QT_NO_GEOM_VARIANT
00975     case QVariant::Point:
00976         dbg.nospace() << v.toPoint();
00977         break;
00978     case QVariant::PointF:
00979         dbg.nospace() << v.toPointF();
00980         break;
00981     case QVariant::Rect:
00982         dbg.nospace() << v.toRect();
00983         break;
00984     case QVariant::Size:
00985         dbg.nospace() << v.toSize();
00986         break;
00987     case QVariant::SizeF:
00988         dbg.nospace() << v.toSizeF();
00989         break;
00990     case QVariant::Line:
00991         dbg.nospace() << v.toLine();
00992         break;
00993     case QVariant::LineF:
00994         dbg.nospace() << v.toLineF();
00995         break;
00996     case QVariant::RectF:
00997         dbg.nospace() << v.toRectF();
00998         break;
00999 #endif
01000     case QVariant::BitArray:
01001         //dbg.nospace() << v.toBitArray();
01002         break;
01003     default:
01004         break;
01005     }
01006 }

Here is the call graph for this function:

Variable Documentation

const uint map_from_three[MapFromThreeCount] [static]

Definition at line 1688 of file qvariant.cpp.

Referenced by QVariant::load(), and QVariant::save().

const quint32 qCanConvertMatrix[QVariant::LastCoreType+1] [static]

Definition at line 2283 of file qvariant.cpp.

Referenced by QVariant::canConvert().

const QVariant::Handler qt_kernel_variant_handler

Initial value:

 {
    construct,
    clear,
    isNull,

    0,
    0,

    compare,
    convert,
    0,

    streamDebug



}

Definition at line 1009 of file qvariant.cpp.

Referenced by qcoreVariantHandler().

Generated on Thu Mar 15 12:44:09 2007 for Qt 4.2 User's Guide by  doxygen 1.5.1