/* Format a variant value as a string representation of an unsigned integer. This method was written to convert a QVariant of type ULongLong, but should cope with a variant of any type. First convert the variant value to an unsigned long. It may or may not be a ulonglong type variant. If it is - good, there will be no conversion problems. Then format it as a string using the formatting information stored in this class. */ void QEStringFormatting::formatFromUnsignedInteger( const QVariant &value ) { // Extract the value as an unsigned long using whatever conversion the QVariant uses. // // Note, this will not pick up if the QVariant type is not one of the types used to represent CA data. // This is OK as it is not absolutely nessesary to do this sort of check at this point. Also the code is more robust as it will // work if the range of QVariant types used expands. // Note, this does not give us the freedom to specify what conversions should fail or succeed. For example, does QVariant::toULongLong() // work if the value it holds is the string 1.000 and should it? // If QVariant::toULongLong() does not do exactly what is required, a switch statement for each of the types used to hold CA data // will need to be added and the conversions done manually or using QVariant::toULongLong() as required. // Use QString conversions is variant is a string. // (QVariant toLongLong can't convert strings like "2.000"!) bool convertOk; unsigned long ulValue; if( value.type() == QVariant::String ) { QString str = value.toString(); double dd = str.toDouble( &convertOk ); ulValue = dd; } // Use QVariant conversions otherwise else { ulValue = value.toULongLong( &convertOk ); } if( !convertOk ) { formatFailure( QString( "Warning from QEStringFormatting::formatFromUnsignedInteger(). A variant could not be converted to an unsigned long." ) ); return; } // Generate the text stream << ulValue; // Add sperators if needs be outStr = insertSeparators( outStr ); }
bool QValueFilter::matches(const QVariant & value, int type) const { Qt::CaseSensitivity s; Qt::MatchFlag mf; int t = type; if (t == -1){ t = value.type(); } switch(t) { case QVariant::Char: return value.toChar() == property("value").toChar(); case QVariant::Date: return value.toDate() == property("value").toDate(); case QVariant::DateTime: return value.toDateTime() == property("value").toDateTime(); case QVariant::Double: return value.toDouble() == property("value").toDouble(); case QVariant::Int: return value.toInt() == property("value").toInt(); case QVariant::LongLong: return value.toLongLong() == property("value").toLongLong(); case QVariant::String: s = static_cast<Qt::CaseSensitivity>(property("caseSensitivity", Qt::CaseInsensitive).toInt()); mf = static_cast<Qt::MatchFlag>(property("matchFlag", Qt::MatchStartsWith).toInt()); if (mf == Qt::MatchContains){ return value.toString().contains(property("value").toString(), s); } else if (mf == Qt::MatchEndsWith){ return QString::compare(value.toString().right(property("value").toString().length()), property("value").toString(), s) == 0; } return QString::compare(value.toString().left(property("value").toString().length()), property("value").toString(), s) == 0; case QVariant::Time: return value.toTime() == property("value").toTime(); case QVariant::UInt: return value.toUInt() == property("value").toUInt(); case QVariant::ULongLong: return value.toULongLong() == property("value").toULongLong(); default: return value == property("value"); } return false; }
LUA_INLINE void Lua::pushVariant(lua_State* L, const QVariant& v) { switch (v.type()) { case QVariant::Invalid: lua_pushnil(L); break; case QVariant::Bool: lua_pushboolean(L, v.toBool()); break; case QVariant::Int: lua_pushinteger(L, v.toInt()); break; case QVariant::UInt: lua_pushunsigned(L, v.toUInt()); break; case QVariant::LongLong: push(L, v.toLongLong()); break; case QVariant::ULongLong: push(L, v.toULongLong()); break; case QVariant::Double: lua_pushnumber(L, v.toDouble()); break; case QVariant::Map: pushMap(L, v.toMap()); break; case QVariant::List: pushList(L, v.toList()); break; case QVariant::StringList: pushList(L, v.toStringList()); break; case QVariant::ByteArray: push(L, v.toByteArray()); break; default: push(L, v.toString()); break; } }
bool SqlDataQuery::getDatabaseRevision(QSqlDatabase &connection, DataRevision *revision) { bool revisionOK = false; quint64 numericRevision = 0L; if (!m_revisionQuery.isEmpty()) { QVariant resultRevision; if (SqlQueryUtils().getSingleQueryValue(connection, m_revisionQuery, m_bindValues, "", &resultRevision, &m_error)) { // this code only supports numeric revisions; empty DataRevision returned otherwise. numericRevision = resultRevision.toULongLong(&revisionOK); } else { qWarning() << "Failed to fetch the database revision."; return false; } } *revision = revisionOK ? DataRevision(new NumericRevision(numericRevision)) : DataRevision(); return true; }
static void _push(lua_State *L, const QVariant & v) { switch( v.type() ) { case QVariant::Invalid: lua_pushnil( L ); break; case QVariant::Bool: lua_pushboolean( L, v.toBool() ); break; case QVariant::Int: lua_pushnumber( L, v.toInt() ); break; case QVariant::Double: lua_pushnumber( L, v.toDouble() ); break; case QVariant::LongLong: lua_pushnumber( L, v.toLongLong() ); break; case QVariant::ULongLong: lua_pushnumber( L, (double)(quint32)v.toULongLong() ); break; case QVariant::UInt: lua_pushnumber( L, v.toUInt() ); break; case QVariant::Char: lua_pushnumber( L, v.toChar().unicode() ); break; case QVariant::ByteArray: lua_pushstring( L, v.toByteArray() ); break; case QVariant::String: lua_pushstring( L, v.toString().toLatin1() ); break; default: lua_pushnil( L ); break; } }
bool TransferModel::setData( const QModelIndex& index, const QVariant& value, int role ) { row=index.row(); column=index.column(); if(index.parent()!=QModelIndex() || row < 0 || row >= transfertItemList.count() || column < 0 || column >= COLUMN_COUNT) return false; transfertItem& item = transfertItemList[row]; if(role==Qt::UserRole) { item.id=value.toULongLong(); return true; } else if(role==Qt::DisplayRole) { switch(column) { case 0: item.source=value.toString(); emit dataChanged(index,index); return true; break; case 1: item.size=value.toString(); emit dataChanged(index,index); return true; break; case 2: item.destination=value.toString(); emit dataChanged(index,index); return true; break; default: return false; } } return false; }
QColor VisualAttribute::value2color(const QVariant &var) const { if ( !_domain.isValid()){ // the range case bool ok; double d = var.toDouble(&ok); if ( ok){ double f = (d - _actualRange.min())/_actualRange.distance(); int defColorSize = ColorRangeBase::defaultColorNames().size(); int index = std::max(0.0,std::min((double)defColorSize-1, f * (defColorSize))); return ColorRangeBase::defaultColor(index); } } double v; if ( hasType(_domain->valueType(), itCONTINUOUSCOLOR)){ return ColorRangeBase::toColor(var.toULongLong(), ColorRangeBase::cmRGBA); }else if ( hasType(_domain->ilwisType(), itNUMERICDOMAIN | itITEMDOMAIN)){ v = var.toDouble(); }else{ v = tovalue(var.toString()); } return _representation->colors()->value2color(v, _actualRange, _stretchRange) ; }
void IntegerWatchLineEdit::setModelData(const QVariant &v) { if (debug) qDebug(">IntegerLineEdit::setModelData(%s, '%s'): base=%d, signed=%d, bigint=%d", v.typeName(), qPrintable(v.toString()), base(), isSigned(), isBigInt()); switch (v.type()) { case QVariant::Int: case QVariant::LongLong: { const qint64 iv = v.toLongLong(); setSigned(true); setText(QString::number(iv, base())); } break; case QVariant::UInt: case QVariant::ULongLong: { const quint64 iv = v.toULongLong(); setSigned(false); setText(QString::number(iv, base())); } break; case QVariant::ByteArray: setNumberText(QString::fromLatin1(v.toByteArray())); break; case QVariant::String: setNumberText(v.toString()); break; default: qWarning("Invalid value (%s) passed to IntegerLineEdit::setModelData", v.typeName()); setText(QString(QLatin1Char('0'))); break; } if (debug) qDebug("<IntegerLineEdit::setModelData(): base=%d, signed=%d, bigint=%d", base(), isSigned(), isBigInt()); }
static void AddWmdmItem(IWMDMMetaData* metadata, const wchar_t* name, const QVariant& value) { switch (value.type()) { case QVariant::Int: case QVariant::UInt: { DWORD data = value.toUInt(); metadata->AddItem(WMDM_TYPE_DWORD, name, (BYTE*)&data, sizeof(data)); break; } case QVariant::String: { ScopedWCharArray data(value.toString()); metadata->AddItem(WMDM_TYPE_STRING, name, (BYTE*)data.get(), data.bytes()); break; } case QVariant::ByteArray: { QByteArray data = value.toByteArray(); metadata->AddItem(WMDM_TYPE_BINARY, name, (BYTE*)data.constData(), data.size()); break; } case QVariant::Bool: { int data = value.toBool(); metadata->AddItem(WMDM_TYPE_BOOL, name, (BYTE*)&data, sizeof(data)); break; } case QVariant::LongLong: case QVariant::ULongLong: { quint64 data = value.toULongLong(); metadata->AddItem(WMDM_TYPE_QWORD, name, (BYTE*)&data, sizeof(data)); break; } default: qLog(Warning) << "Type" << value.type() << "not handled"; Q_ASSERT(0); break; } }
WId MInputContextConnection::winId() { #ifdef Q_WS_WIN WId result = 0; return result; #else QVariant winIdVariant = widgetState[WinId]; // after transfer by dbus type can change switch (winIdVariant.type()) { case QVariant::UInt: if (sizeof(uint) >= sizeof(WId)) return winIdVariant.toUInt(); break; case QVariant::ULongLong: if (sizeof(qulonglong) >= sizeof(WId)) return winIdVariant.toULongLong(); break; default: if (winIdVariant.canConvert<WId>()) return winIdVariant.value<WId>(); } return 0; #endif }
QString JSON::stringify(QVariant v){ if (v.isNull()){ return QLatin1String("null"); } switch (v.type()) { case QVariant::Bool: return v.toBool()?QLatin1String("true"):QLatin1String("false"); break; case QVariant::ULongLong: case QVariant::UInt: return QString::number(v.toULongLong()); break; case QVariant::LongLong: case QVariant::Int: return QString::number(v.toLongLong()); break; case QVariant::Double: return QString::number(v.toDouble()); break; case QVariant::Map: { QString r=QLatin1String("{"); QMap<QString, QVariant> map = v.toMap(); QMapIterator<QString, QVariant> i(map); while (i.hasNext()){ i.next(); r+=QLatin1String("\"")+i.key()+ QLatin1String("\":") +stringify(i.value())+QLatin1String(","); } if(r.length()>1) r.chop(1); r+=QLatin1String("}"); return r; } break; #if QT_VERSION >= 0x040500 case QVariant::Hash: { QString r=QLatin1String("{"); QHash<QString, QVariant> map = v.toHash(); QHashIterator<QString, QVariant> i(map); while (i.hasNext()){ i.next(); r+=QLatin1String("\"")+i.key()+QLatin1String("\":")+stringify(i.value())+QLatin1String(","); } if(r.length()>1) r.chop(1); r+=QLatin1String("}"); return r; } break; #endif case QVariant::StringList: { QString r=QLatin1String("["); QStringList l = v.toStringList(); foreach(QString i, l){ r+=QLatin1String("\"")+i+QLatin1String("\","); } if(r.length()>1) r.chop(1); r+=QLatin1String("]"); return r; } case QVariant::List: { QString r=QLatin1String("["); QVariantList l = v.toList(); foreach(QVariant i, l){ r+=stringify(i)+QLatin1String(","); } if(r.length()>1) r.chop(1); r+=QLatin1String("]"); return r; }
QT_BEGIN_NAMESPACE static void copyArgument(void *to, int id, const QVariant &arg) { if (id == arg.userType()) { switch (id) { case QVariant::Bool: *reinterpret_cast<bool *>(to) = arg.toBool(); return; case QMetaType::UChar: *reinterpret_cast<uchar *>(to) = arg.value<uchar>(); return; case QMetaType::Short: *reinterpret_cast<short *>(to) = arg.value<short>(); return; case QMetaType::UShort: *reinterpret_cast<ushort *>(to) = arg.value<ushort>(); return; case QVariant::Int: *reinterpret_cast<int *>(to) = arg.toInt(); return; case QVariant::UInt: *reinterpret_cast<uint *>(to) = arg.toUInt(); return; case QVariant::LongLong: *reinterpret_cast<qlonglong *>(to) = arg.toLongLong(); return; case QVariant::ULongLong: *reinterpret_cast<qulonglong *>(to) = arg.toULongLong(); return; case QVariant::Double: *reinterpret_cast<double *>(to) = arg.toDouble(); return; case QVariant::String: *reinterpret_cast<QString *>(to) = arg.toString(); return; case QVariant::ByteArray: *reinterpret_cast<QByteArray *>(to) = arg.toByteArray(); return; case QVariant::StringList: *reinterpret_cast<QStringList *>(to) = arg.toStringList(); return; } if (id == QDBusMetaTypeId::variant) { *reinterpret_cast<QDBusVariant *>(to) = arg.value<QDBusVariant>(); return; } else if (id == QDBusMetaTypeId::objectpath) { *reinterpret_cast<QDBusObjectPath *>(to) = arg.value<QDBusObjectPath>(); return; } else if (id == QDBusMetaTypeId::signature) { *reinterpret_cast<QDBusSignature *>(to) = arg.value<QDBusSignature>(); return; } // those above are the only types possible // the demarshaller code doesn't demarshall anything else qFatal("Found a decoded basic type in a D-Bus reply that shouldn't be there"); } // if we got here, it's either an un-dermarshalled type or a mismatch if (arg.userType() != QDBusMetaTypeId::argument) { // it's a mismatch //qWarning? return; } // is this type registered? const char *userSignature = QDBusMetaType::typeToSignature(id); if (!userSignature || !*userSignature) { // type not registered //qWarning? return; } // is it the same signature? QDBusArgument dbarg = arg.value<QDBusArgument>(); if (dbarg.currentSignature() != QLatin1String(userSignature)) { // not the same signature, another mismatch //qWarning? return; } // we can demarshall QDBusMetaType::demarshall(dbarg, id, to); }
void print_ulonglong(QString const &name, QVariant const &value) { qDebug() << "Got " << name << "=" << value.toULongLong() << "\n"; }
void QtCUrl::setOptions(Options& opt) { Options defaults; //defaults[CURLOPT_FAILONERROR] = true; defaults[CURLOPT_ERRORBUFFER].setValue(_errorBuffer); if(FileName.isEmpty()) { defaults[CURLOPT_WRITEFUNCTION].setValue(&writer); defaults[CURLOPT_WRITEDATA].setValue(&_buffer); }else { File.setFileName(FileName); defaults[CURLOPT_WRITEFUNCTION].setValue(&writer_file); defaults[CURLOPT_WRITEDATA].setValue(&File); } defaults[CURLOPT_PROGRESSFUNCTION].setValue(&progress_callback); defaults[CURLOPT_PROGRESSDATA].setValue(&AutoDelete); defaults[CURLOPT_NOPROGRESS].setValue(0); defaults[CURLOPT_SSL_VERIFYPEER].setValue(false); defaults[CURLOPT_SSL_VERIFYHOST].setValue(false); if(!Filter.isEmpty()) { //defaults[CURLOPT_VERBOSE].setValue(1); defaults[CURLOPT_HEADERFUNCTION].setValue(&writer2); defaults[CURLOPT_WRITEHEADER].setValue(&_buffer_and_filter); } //defaults[CURLOPT_VERBOSE].setValue(1); #ifdef QTCURL_DEBUG curl_easy_setopt(_curl, CURLOPT_VERBOSE, 1); curl_easy_setopt(_curl, CURLOPT_DEBUGFUNCTION, trace); #endif OptionsIterator i(defaults); while (i.hasNext()) { i.next(); if (! opt.contains(i.key())) { opt[i.key()] = i.value(); } } if(opt.contains(CURLOPT_POSTFIELDSIZE)) { int val = opt[CURLOPT_POSTFIELDSIZE].toInt(); curl_easy_setopt(_curl, CURLOPT_POSTFIELDSIZE, (long)val); } i = opt; while (i.hasNext()) { i.next(); QVariant value = i.value(); if(i.key() == CURLOPT_POSTFIELDSIZE) { continue; } switch (value.type()) { case QVariant::Bool: case QVariant::Int: { int val = value.toInt(); curl_easy_setopt(_curl, i.key(), val); break; } case QVariant::ByteArray: { QByteArray ba = value.toByteArray(); curl_easy_setopt(_curl, i.key(), ba.constData()); break; } case QVariant::Url: { QByteArray ba = value.toUrl().toEncoded(); curl_easy_setopt(_curl, i.key(), ba.constData()); break; } case QVariant::String: { curl_easy_setopt(_curl, i.key(), value.toString().toUtf8().data()); break; } case QVariant::ULongLong: { qulonglong val = value.toULongLong(); curl_easy_setopt(_curl, i.key(), (void*) val); break; } case QVariant::StringList: { struct curl_slist *slist = NULL; foreach (const QString &tmp, value.toStringList()) { slist = curl_slist_append(slist, tmp.toUtf8().data()); } _slist.append(slist); curl_easy_setopt(_curl, i.key(), slist); break; } default: const QString typeName = value.typeName(); if (typeName == "QtCUrl::WriterPtr") { curl_easy_setopt(_curl, i.key(), value.value<WriterPtr>()); }else if (typeName == "QtCUrl::WriterFilePtr") { curl_easy_setopt(_curl, i.key(), value.value<WriterFilePtr>()); }else if (typeName == "QtCUrl::HeaderPtr") { curl_easy_setopt(_curl, i.key(), value.value<HeaderPtr>()); }else if (typeName == "QtCUrl::ProgressPtr") { curl_easy_setopt(_curl, i.key(), value.value<ProgressPtr>()); } else if (typeName == "std::string*") { curl_easy_setopt(_curl, i.key(), value.value<std::string*>()); } else if (typeName == "BufferAndFilter*") { curl_easy_setopt(_curl, i.key(), value.value<BufferAndFilter*>()); } else if (typeName == "char*") { curl_easy_setopt(_curl, i.key(), value.value<char*>()); } else if (typeName == "bool*") { curl_easy_setopt(_curl, i.key(), value.value<bool*>()); } else if (typeName == "QFile*") { curl_easy_setopt(_curl, i.key(), value.value<QFile*>()); } else { //qDebug() << "[QtCUrl] Unsupported option type: " << typeName; } } } }
int lqtL_qvariant_value(lua_State *L) { QVariant* self = static_cast<QVariant*>(lqtL_toudata(L, 1, "QVariant*")); lqtL_selfcheck(L, self, "QVariant"); QVariant::Type type; if (lua_isnoneornil(L, 2)) { type = self->type(); } else { type = (QVariant::Type)lqtL_toenum(L, 2, "QVariant.Type"); const char * currentType = self->typeName(); if (!self->canConvert(type) || !self->convert(type)) { lua_pushnil(L); lua_pushfstring(L, "cannot convert %s to %s", currentType, self->typeToName(type)); return 2; } } switch (self->type()) { case QVariant::Invalid: lua_pushnil(L); return 1; /* basic types */ case QVariant::Bool: lua_pushboolean(L, self->toBool()); return 1; case QVariant::Double: lua_pushnumber(L, self->toDouble()); return 1; case QVariant::Int: lua_pushinteger(L, self->toInt()); return 1; case QVariant::UInt: lua_pushinteger(L, self->toUInt()); return 1; case QVariant::LongLong: lua_pushnumber(L, self->toLongLong()); return 1; case QVariant::ULongLong: lua_pushnumber(L, self->toULongLong()); return 1; case QVariant::ByteArray: { const QByteArray &ba = self->toByteArray(); lua_pushlstring(L, ba.data(), ba.size()); return 1; }; /* QtCore types */ case QVariant::BitArray: lqtL_passudata(L, new QBitArray(self->value<QBitArray>()), "QBitArray*"); return 1; case QVariant::Char: lqtL_passudata(L, new QChar(self->value<QChar>()), "QChar*"); return 1; case QVariant::Date: lqtL_passudata(L, new QDate(self->value<QDate>()), "QDate*"); return 1; case QVariant::DateTime: lqtL_passudata(L, new QDateTime(self->value<QDateTime>()), "QDateTime*"); return 1; case QVariant::KeySequence: lqtL_passudata(L, new QKeySequence(self->value<QKeySequence>()), "QKeySequence*"); return 1; case QVariant::Line: lqtL_passudata(L, new QLine(self->value<QLine>()), "QLine*"); return 1; case QVariant::LineF: lqtL_passudata(L, new QLineF(self->value<QLineF>()), "QLineF*"); return 1; case QVariant::List: lqtL_passudata(L, new QList<QVariant>(self->toList()), "QList<QVariant>*"); return 1; case QVariant::Locale: lqtL_passudata(L, new QLocale(self->value<QLocale>()), "QLocale*"); return 1; case QVariant::Point: lqtL_passudata(L, new QPoint(self->value<QPoint>()), "QPoint*"); return 1; case QVariant::PointF: lqtL_passudata(L, new QPointF(self->value<QPointF>()), "QPointF*"); return 1; case QVariant::Rect: lqtL_passudata(L, new QRect(self->value<QRect>()), "QRect*"); return 1; case QVariant::RectF: lqtL_passudata(L, new QRectF(self->value<QRectF>()), "QRectF*"); return 1; case QVariant::RegExp: lqtL_passudata(L, new QRegExp(self->value<QRegExp>()), "QRegExp*"); return 1; case QVariant::Size: lqtL_passudata(L, new QSize(self->value<QSize>()), "QSize*"); return 1; case QVariant::SizeF: lqtL_passudata(L, new QSizeF(self->value<QSizeF>()), "QSizeF*"); return 1; case QVariant::String: lqtL_passudata(L, new QString(self->value<QString>()), "QString*"); return 1; case QVariant::StringList: lqtL_passudata(L, new QStringList(self->value<QStringList>()), "QStringList*"); return 1; case QVariant::Time: lqtL_passudata(L, new QTime(self->value<QTime>()), "QTime*"); return 1; case QVariant::Url: lqtL_passudata(L, new QUrl(self->value<QUrl>()), "QUrl*"); return 1; #ifdef MODULE_qtgui /* QtGui types */ case QVariant::Bitmap: lqtL_passudata(L, new QBitmap(self->value<QBitmap>()), "QBitmap*"); return 1; case QVariant::Brush: lqtL_passudata(L, new QBrush(self->value<QBrush>()), "QBrush*"); return 1; case QVariant::Color: lqtL_passudata(L, new QColor(self->value<QColor>()), "QColor*"); return 1; case QVariant::Cursor: lqtL_passudata(L, new QCursor(self->value<QCursor>()), "QCursor*"); return 1; case QVariant::Font: lqtL_passudata(L, new QFont(self->value<QFont>()), "QFont*"); return 1; case QVariant::Icon: lqtL_passudata(L, new QIcon(self->value<QIcon>()), "QIcon*"); return 1; case QVariant::Image: lqtL_passudata(L, new QImage(self->value<QImage>()), "QImage*"); return 1; case QVariant::Matrix: lqtL_passudata(L, new QMatrix(self->value<QMatrix>()), "QMatrix*"); return 1; case QVariant::Matrix4x4: lqtL_passudata(L, new QMatrix4x4(self->value<QMatrix4x4>()), "QMatrix4x4*"); return 1; case QVariant::Palette: lqtL_passudata(L, new QPalette(self->value<QPalette>()), "QPalette*"); return 1; case QVariant::Pen: lqtL_passudata(L, new QPen(self->value<QPen>()), "QPen*"); return 1; case QVariant::Pixmap: lqtL_passudata(L, new QPixmap(self->value<QPixmap>()), "QPixmap*"); return 1; case QVariant::Polygon: lqtL_passudata(L, new QPolygon(self->value<QPolygon>()), "QPolygon*"); return 1; case QVariant::Quaternion: lqtL_passudata(L, new QQuaternion(self->value<QQuaternion>()), "QQuaternion*"); return 1; case QVariant::Region: lqtL_passudata(L, new QRegion(self->value<QRegion>()), "QRegion*"); return 1; case QVariant::SizePolicy: lqtL_passudata(L, new QSizePolicy(self->value<QSizePolicy>()), "QSizePolicy*"); return 1; case QVariant::Transform: lqtL_passudata(L, new QTransform(self->value<QTransform>()), "QTransform*"); return 1; case QVariant::TextFormat: lqtL_passudata(L, new QTextFormat(self->value<QTextFormat>()), "QTextFormat*"); return 1; case QVariant::TextLength: lqtL_passudata(L, new QTextLength(self->value<QTextLength>()), "QTextLength*"); return 1; case QVariant::Vector2D: lqtL_passudata(L, new QVector2D(self->value<QVector2D>()), "QVector2D*"); return 1; case QVariant::Vector3D: lqtL_passudata(L, new QVector3D(self->value<QVector3D>()), "QVector3D*"); return 1; case QVariant::Vector4D: lqtL_passudata(L, new QVector4D(self->value<QVector4D>()), "QVector4D*"); return 1; #endif } return 0; }
QVariant QSystemLocale::query(QueryType type, QVariant in) const { QSystemLocaleData *d = qSystemLocaleData(); if (type == LocaleChanged) { d->readEnvironment(); return QVariant(); } QReadLocker locker(&d->lock); const QLocale &lc_numeric = d->lc_numeric; const QLocale &lc_time = d->lc_time; const QLocale &lc_monetary = d->lc_monetary; const QLocale &lc_messages = d->lc_messages; switch (type) { case DecimalPoint: return lc_numeric.decimalPoint(); case GroupSeparator: return lc_numeric.groupSeparator(); case ZeroDigit: return lc_numeric.zeroDigit(); case NegativeSign: return lc_numeric.negativeSign(); case DateFormatLong: return lc_time.dateFormat(QLocale::LongFormat); case DateFormatShort: return lc_time.dateFormat(QLocale::ShortFormat); case TimeFormatLong: return lc_time.timeFormat(QLocale::LongFormat); case TimeFormatShort: return lc_time.timeFormat(QLocale::ShortFormat); case DayNameLong: return lc_time.dayName(in.toInt(), QLocale::LongFormat); case DayNameShort: return lc_time.dayName(in.toInt(), QLocale::ShortFormat); case MonthNameLong: return lc_time.monthName(in.toInt(), QLocale::LongFormat); case MonthNameShort: return lc_time.monthName(in.toInt(), QLocale::ShortFormat); case StandaloneMonthNameLong: return lc_time.standaloneMonthName(in.toInt(), QLocale::LongFormat); case StandaloneMonthNameShort: return lc_time.standaloneMonthName(in.toInt(), QLocale::ShortFormat); case DateToStringLong: return lc_time.toString(in.toDate(), QLocale::LongFormat); case DateToStringShort: return lc_time.toString(in.toDate(), QLocale::ShortFormat); case TimeToStringLong: return lc_time.toString(in.toTime(), QLocale::LongFormat); case TimeToStringShort: return lc_time.toString(in.toTime(), QLocale::ShortFormat); case DateTimeFormatLong: return lc_time.dateTimeFormat(QLocale::LongFormat); case DateTimeFormatShort: return lc_time.dateTimeFormat(QLocale::ShortFormat); case DateTimeToStringLong: return lc_time.toString(in.toDateTime(), QLocale::LongFormat); case DateTimeToStringShort: return lc_time.toString(in.toDateTime(), QLocale::ShortFormat); case PositiveSign: return lc_numeric.positiveSign(); case AMText: return lc_time.amText(); case PMText: return lc_time.pmText(); case FirstDayOfWeek: return lc_time.firstDayOfWeek(); case CurrencySymbol: return lc_monetary.currencySymbol(QLocale::CurrencySymbolFormat(in.toUInt())); case CurrencyToString: { switch (in.type()) { case QVariant::Int: return lc_monetary.toCurrencyString(in.toInt()); case QVariant::UInt: return lc_monetary.toCurrencyString(in.toUInt()); case QVariant::Double: return lc_monetary.toCurrencyString(in.toDouble()); case QVariant::LongLong: return lc_monetary.toCurrencyString(in.toLongLong()); case QVariant::ULongLong: return lc_monetary.toCurrencyString(in.toULongLong()); default: break; } return QString(); } case MeasurementSystem: { const QString meas_locale = QString::fromLatin1(d->lc_measurement_var.constData(), d->lc_measurement_var.size()); if (meas_locale.compare(QLatin1String("Metric"), Qt::CaseInsensitive) == 0) return QLocale::MetricSystem; if (meas_locale.compare(QLatin1String("Other"), Qt::CaseInsensitive) == 0) return QLocale::MetricSystem; return QVariant((int)QLocale(meas_locale).measurementSystem()); } case UILanguages: { if (!d->uiLanguages.isEmpty()) return d->uiLanguages; QString languages = QString::fromLatin1(qgetenv("LANGUAGE")); QStringList lst; if (languages.isEmpty()) lst.append(QString::fromLatin1(d->lc_messages_var)); else lst = languages.split(QLatin1Char(':')); for (int i = 0; i < lst.size(); ++i) { const QString &name = lst.at(i); QString lang, script, cntry; if (qt_splitLocaleName(name, lang, script, cntry)) { if (!cntry.length()) d->uiLanguages.append(lang); else d->uiLanguages.append(lang % QLatin1Char('-') % cntry); } } return d->uiLanguages.isEmpty() ? QVariant() : QVariant(d->uiLanguages); } case StringToStandardQuotation: return lc_messages.quoteString(in.value<QStringRef>()); case StringToAlternateQuotation: return lc_messages.quoteString(in.value<QStringRef>(), QLocale::AlternateQuotation); case ListToSeparatedString: return lc_messages.createSeparatedList(in.toStringList()); case LocaleChanged: Q_ASSERT(false); default: break; } return QVariant(); }
Q_ULLONG fromQVariant<Q_ULLONG>(const QVariant & s) { return s.toULongLong(); };
bool ArpProtocol::setFieldData(int index, const QVariant &value, FieldAttrib attrib) { bool isOk = false; if (attrib != FieldValue) goto _exit; switch (index) { case arp_hwType: { uint hwType = value.toUInt(&isOk); if (isOk) data.set_hw_type(hwType); break; } case arp_protoType: { uint protoType = value.toUInt(&isOk); if (isOk) data.set_proto_type(protoType); break; } case arp_hwAddrLen: { uint hwAddrLen = value.toUInt(&isOk); if (isOk) data.set_hw_addr_len(hwAddrLen); break; } case arp_protoAddrLen: { uint protoAddrLen = value.toUInt(&isOk); if (isOk) data.set_proto_addr_len(protoAddrLen); break; } case arp_opCode: { uint opCode = value.toUInt(&isOk); if (isOk) data.set_op_code(opCode); break; } case arp_senderHwAddr: { quint64 hwAddr = value.toULongLong(&isOk); if (isOk) data.set_sender_hw_addr(hwAddr); break; } case arp_senderHwAddrMode: { uint mode = value.toUInt(&isOk); if (isOk && data.HwAddrMode_IsValid(mode)) data.set_sender_hw_addr_mode((OstProto::Arp::HwAddrMode) mode); else isOk = false; break; } case arp_senderHwAddrCount: { uint count = value.toUInt(&isOk); if (isOk) data.set_sender_hw_addr_count(count); break; } case arp_senderProtoAddr: { uint protoAddr = value.toUInt(&isOk); if (isOk) data.set_sender_proto_addr(protoAddr); break; } case arp_senderProtoAddrMode: { uint mode = value.toUInt(&isOk); if (isOk && data.ProtoAddrMode_IsValid(mode)) data.set_sender_proto_addr_mode( (OstProto::Arp::ProtoAddrMode)mode); else isOk = false; break; } case arp_senderProtoAddrCount: { uint count = value.toUInt(&isOk); if (isOk) data.set_sender_proto_addr_count(count); break; } case arp_senderProtoAddrMask: { uint mask = value.toUInt(&isOk); if (isOk) data.set_sender_proto_addr_mask(mask); break; } case arp_targetHwAddr: { quint64 hwAddr = value.toULongLong(&isOk); if (isOk) data.set_target_hw_addr(hwAddr); break; } case arp_targetHwAddrMode: { uint mode = value.toUInt(&isOk); if (isOk && data.HwAddrMode_IsValid(mode)) data.set_target_hw_addr_mode((OstProto::Arp::HwAddrMode)mode); else isOk = false; break; } case arp_targetHwAddrCount: { uint count = value.toUInt(&isOk); if (isOk) data.set_target_hw_addr_count(count); break; } case arp_targetProtoAddr: { uint protoAddr = value.toUInt(&isOk); if (isOk) data.set_target_proto_addr(protoAddr); break; } case arp_targetProtoAddrMode: { uint mode = value.toUInt(&isOk); if (isOk && data.ProtoAddrMode_IsValid(mode)) data.set_target_proto_addr_mode( (OstProto::Arp::ProtoAddrMode)mode); else isOk = false; break; } case arp_targetProtoAddrCount: { uint count = value.toUInt(&isOk); if (isOk) data.set_target_proto_addr_count(count); break; } case arp_targetProtoAddrMask: { uint mask = value.toUInt(&isOk); if (isOk) data.set_target_proto_addr_mask(mask); break; } default: qFatal("%s: unimplemented case %d in switch", __PRETTY_FUNCTION__, index); break; } _exit: return isOk; }
bool QDBusMarshaller::appendVariantInternal(const QVariant &arg) { int id = arg.userType(); if (id == QVariant::Invalid) { qWarning("QDBusMarshaller: cannot add an invalid QVariant"); error(QLatin1String("Variant containing QVariant::Invalid passed in arguments")); return false; } // intercept QDBusArgument parameters here if (id == QDBusMetaTypeId::argument()) { QDBusArgument dbusargument = qvariant_cast<QDBusArgument>(arg); QDBusArgumentPrivate *d = QDBusArgumentPrivate::d(dbusargument); if (!d->message) return false; // can't append this one... QDBusDemarshaller demarshaller(capabilities); demarshaller.message = q_dbus_message_ref(d->message); if (d->direction == Demarshalling) { // it's demarshalling; just copy demarshaller.iterator = static_cast<QDBusDemarshaller *>(d)->iterator; } else { // it's marshalling; start over if (!q_dbus_message_iter_init(demarshaller.message, &demarshaller.iterator)) return false; // error! } return appendCrossMarshalling(&demarshaller); } const char *signature = QDBusMetaType::typeToSignature( QVariant::Type(id) ); if (!signature) { qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. " "Use qDBusRegisterMetaType to register it", QMetaType::typeName(id), id); error(QString::fromLatin1("Unregistered type %1 passed in arguments") .arg(QLatin1String(QMetaType::typeName(id)))); return false; } switch (*signature) { #ifdef __OPTIMIZE__ case DBUS_TYPE_BYTE: case DBUS_TYPE_INT16: case DBUS_TYPE_UINT16: case DBUS_TYPE_INT32: case DBUS_TYPE_UINT32: case DBUS_TYPE_INT64: case DBUS_TYPE_UINT64: case DBUS_TYPE_DOUBLE: qIterAppend(&iterator, ba, *signature, arg.constData()); return true; case DBUS_TYPE_BOOLEAN: append( arg.toBool() ); return true; #else case DBUS_TYPE_BYTE: append( qvariant_cast<uchar>(arg) ); return true; case DBUS_TYPE_BOOLEAN: append( arg.toBool() ); return true; case DBUS_TYPE_INT16: append( qvariant_cast<short>(arg) ); return true; case DBUS_TYPE_UINT16: append( qvariant_cast<ushort>(arg) ); return true; case DBUS_TYPE_INT32: append( static_cast<dbus_int32_t>(arg.toInt()) ); return true; case DBUS_TYPE_UINT32: append( static_cast<dbus_uint32_t>(arg.toUInt()) ); return true; case DBUS_TYPE_INT64: append( arg.toLongLong() ); return true; case DBUS_TYPE_UINT64: append( arg.toULongLong() ); return true; case DBUS_TYPE_DOUBLE: append( arg.toDouble() ); return true; #endif case DBUS_TYPE_STRING: append( arg.toString() ); return true; case DBUS_TYPE_OBJECT_PATH: append( qvariant_cast<QDBusObjectPath>(arg) ); return true; case DBUS_TYPE_SIGNATURE: append( qvariant_cast<QDBusSignature>(arg) ); return true; // compound types: case DBUS_TYPE_VARIANT: // nested QVariant return append( qvariant_cast<QDBusVariant>(arg) ); case DBUS_TYPE_ARRAY: // could be many things // find out what kind of array it is switch (arg.type()) { case QVariant::StringList: append( arg.toStringList() ); return true; case QVariant::ByteArray: append( arg.toByteArray() ); return true; default: ; } Q_FALLTHROUGH(); case DBUS_TYPE_STRUCT: case DBUS_STRUCT_BEGIN_CHAR: return appendRegisteredType( arg ); case DBUS_TYPE_DICT_ENTRY: case DBUS_DICT_ENTRY_BEGIN_CHAR: qFatal("QDBusMarshaller::appendVariantInternal got a DICT_ENTRY!"); return false; case DBUS_TYPE_UNIX_FD: if (capabilities & QDBusConnection::UnixFileDescriptorPassing || ba) { append(qvariant_cast<QDBusUnixFileDescriptor>(arg)); return true; } Q_FALLTHROUGH(); default: qWarning("QDBusMarshaller::appendVariantInternal: Found unknown D-BUS type '%s'", signature); return false; } return true; }
bool StpProtocol::setFieldData(int index, const QVariant &value, FieldAttrib attrib) { bool isOk = false; if (attrib != FieldValue) return isOk; switch (index) { case stp_protocol_id: { quint16 protoId = value.toUInt(&isOk); if (isOk) data_.set_protocol_id(protoId); break; } case stp_version_id: { quint8 versionId = value.toUInt(&isOk); if (isOk) data_.set_protocol_version_id(versionId); break; } case stp_bpdu_type: { quint8 bpdu = value.toUInt(&isOk); if (isOk) data_.set_bpdu_type(bpdu); break; } case stp_flags: { quint8 flags = value.toUInt(&isOk); if (isOk) data_.set_flags(flags); break; } case stp_root_id: { quint64 rootId = value.toULongLong(&isOk); if (isOk) data_.set_root_id(rootId); break; } case stp_root_path_cost: { quint32 pathCost = value.toUInt(&isOk); if (isOk) data_.set_root_path_cost(pathCost); break; } case stp_bridge_id: { quint64 bridgeId = value.toULongLong(&isOk); if (isOk) data_.set_bridge_id(bridgeId); break; } case stp_port_id: { quint32 port_id = value.toUInt(&isOk); if (isOk) data_.set_port_id(port_id); break; } case stp_message_age: { quint32 messageAge = value.toUInt(&isOk); if (isOk) data_.set_message_age(messageAge); break; } case stp_max_age: { quint32 maxAge = value.toUInt(&isOk); if (isOk) data_.set_max_age(maxAge); break; } case stp_hello_time: { quint32 helloTime = value.toUInt(&isOk); if (isOk) data_.set_hello_time(helloTime); break; } case stp_forward_delay: { quint32 forwardDelay = value.toUInt(&isOk); if (isOk) data_.set_forward_delay(forwardDelay); break; } default: break; } return isOk; }
// Apply a simple variant type to a DOM property static bool applySimpleProperty(const QVariant &v, bool translateString, DomProperty *dom_prop) { switch (v.type()) { case QVariant::String: { DomString *str = new DomString(); str->setText(v.toString()); if (!translateString) str->setAttributeNotr(QStringLiteral("true")); dom_prop->setElementString(str); } return true; case QVariant::ByteArray: dom_prop->setElementCstring(QString::fromUtf8(v.toByteArray())); return true; case QVariant::Int: dom_prop->setElementNumber(v.toInt()); return true; case QVariant::UInt: dom_prop->setElementUInt(v.toUInt()); return true; case QVariant::LongLong: dom_prop->setElementLongLong(v.toLongLong()); return true; case QVariant::ULongLong: dom_prop->setElementULongLong(v.toULongLong()); return true; case QVariant::Double: dom_prop->setElementDouble(v.toDouble()); return true; case QVariant::Bool: dom_prop->setElementBool(v.toBool() ? QFormBuilderStrings::instance().trueValue : QFormBuilderStrings::instance().falseValue); return true; case QVariant::Char: { DomChar *ch = new DomChar(); const QChar character = v.toChar(); ch->setElementUnicode(character.unicode()); dom_prop->setElementChar(ch); } return true; case QVariant::Point: { DomPoint *pt = new DomPoint(); const QPoint point = v.toPoint(); pt->setElementX(point.x()); pt->setElementY(point.y()); dom_prop->setElementPoint(pt); } return true; case QVariant::PointF: { DomPointF *ptf = new DomPointF(); const QPointF pointf = v.toPointF(); ptf->setElementX(pointf.x()); ptf->setElementY(pointf.y()); dom_prop->setElementPointF(ptf); } return true; case QVariant::Color: { DomColor *clr = new DomColor(); const QColor color = qvariant_cast<QColor>(v); clr->setElementRed(color.red()); clr->setElementGreen(color.green()); clr->setElementBlue(color.blue()); const int alphaChannel = color.alpha(); if (alphaChannel != 255) clr->setAttributeAlpha(alphaChannel); dom_prop->setElementColor(clr); } return true; case QVariant::Size: { DomSize *sz = new DomSize(); const QSize size = v.toSize(); sz->setElementWidth(size.width()); sz->setElementHeight(size.height()); dom_prop->setElementSize(sz); } return true; case QVariant::SizeF: { DomSizeF *szf = new DomSizeF(); const QSizeF sizef = v.toSizeF(); szf->setElementWidth(sizef.width()); szf->setElementHeight(sizef.height()); dom_prop->setElementSizeF(szf); } return true; case QVariant::Rect: { DomRect *rc = new DomRect(); const QRect rect = v.toRect(); rc->setElementX(rect.x()); rc->setElementY(rect.y()); rc->setElementWidth(rect.width()); rc->setElementHeight(rect.height()); dom_prop->setElementRect(rc); } return true; case QVariant::RectF: { DomRectF *rcf = new DomRectF(); const QRectF rectf = v.toRectF(); rcf->setElementX(rectf.x()); rcf->setElementY(rectf.y()); rcf->setElementWidth(rectf.width()); rcf->setElementHeight(rectf.height()); dom_prop->setElementRectF(rcf); } return true; case QVariant::Font: { DomFont *fnt = new DomFont(); const QFont font = qvariant_cast<QFont>(v); const uint mask = font.resolve(); if (mask & QFont::WeightResolved) { fnt->setElementBold(font.bold()); fnt->setElementWeight(font.weight()); } if (mask & QFont::FamilyResolved) fnt->setElementFamily(font.family()); if (mask & QFont::StyleResolved) fnt->setElementItalic(font.italic()); if (mask & QFont::SizeResolved) fnt->setElementPointSize(font.pointSize()); if (mask & QFont::StrikeOutResolved) fnt->setElementStrikeOut(font.strikeOut()); if (mask & QFont::UnderlineResolved) fnt->setElementUnderline(font.underline()); if (mask & QFont::KerningResolved) fnt->setElementKerning(font.kerning()); if (mask & QFont::StyleStrategyResolved) { const QMetaEnum styleStrategy_enum = metaEnum<QAbstractFormBuilderGadget>("styleStrategy"); fnt->setElementStyleStrategy(QLatin1String(styleStrategy_enum.valueToKey(font.styleStrategy()))); } dom_prop->setElementFont(fnt); } return true; #ifndef QT_NO_CURSOR case QVariant::Cursor: { const QMetaEnum cursorShape_enum = metaEnum<QAbstractFormBuilderGadget>("cursorShape"); dom_prop->setElementCursorShape(QLatin1String(cursorShape_enum.valueToKey(qvariant_cast<QCursor>(v).shape()))); } return true; #endif case QVariant::KeySequence: { DomString *s = new DomString(); s->setText(qvariant_cast<QKeySequence>(v).toString(QKeySequence::PortableText)); dom_prop->setElementString(s); } return true; case QVariant::Locale: { DomLocale *dom = new DomLocale(); const QLocale locale = qvariant_cast<QLocale>(v); const QMetaEnum language_enum = metaEnum<QAbstractFormBuilderGadget>("language"); const QMetaEnum country_enum = metaEnum<QAbstractFormBuilderGadget>("country"); dom->setAttributeLanguage(QLatin1String(language_enum.valueToKey(locale.language()))); dom->setAttributeCountry(QLatin1String(country_enum.valueToKey(locale.country()))); dom_prop->setElementLocale(dom); } return true; case QVariant::SizePolicy: { DomSizePolicy *dom = new DomSizePolicy(); const QSizePolicy sizePolicy = qvariant_cast<QSizePolicy>(v); dom->setElementHorStretch(sizePolicy.horizontalStretch()); dom->setElementVerStretch(sizePolicy.verticalStretch()); const QMetaEnum sizeType_enum = metaEnum<QAbstractFormBuilderGadget>("sizeType"); dom->setAttributeHSizeType(QLatin1String(sizeType_enum.valueToKey(sizePolicy.horizontalPolicy()))); dom->setAttributeVSizeType(QLatin1String(sizeType_enum.valueToKey(sizePolicy.verticalPolicy()))); dom_prop->setElementSizePolicy(dom); } return true; case QVariant::Date: { DomDate *dom = new DomDate(); const QDate date = qvariant_cast<QDate>(v); dom->setElementYear(date.year()); dom->setElementMonth(date.month()); dom->setElementDay(date.day()); dom_prop->setElementDate(dom); } return true; case QVariant::Time: { DomTime *dom = new DomTime(); const QTime time = qvariant_cast<QTime>(v); dom->setElementHour(time.hour()); dom->setElementMinute(time.minute()); dom->setElementSecond(time.second()); dom_prop->setElementTime(dom); } return true; case QVariant::DateTime: { DomDateTime *dom = new DomDateTime(); const QDateTime dateTime = qvariant_cast<QDateTime>(v); dom->setElementHour(dateTime.time().hour()); dom->setElementMinute(dateTime.time().minute()); dom->setElementSecond(dateTime.time().second()); dom->setElementYear(dateTime.date().year()); dom->setElementMonth(dateTime.date().month()); dom->setElementDay(dateTime.date().day()); dom_prop->setElementDateTime(dom); } return true; case QVariant::Url: { DomUrl *dom = new DomUrl(); const QUrl url = v.toUrl(); DomString *str = new DomString(); str->setText(url.toString()); dom->setElementString(str); dom_prop->setElementUrl(dom); } return true; case QVariant::StringList: { DomStringList *sl = new DomStringList; sl->setElementString(qvariant_cast<QStringList>(v)); dom_prop->setElementStringList(sl); } return true; default: break; } return false; }
// Author & Date: Ehsan Azar 3 April 2012 // Purpose: Begin a new Xml group or navigate to it if it exists // Inputs: // nodeName - the node tag (it can be in the form of relative/path/to/node) // node index (0-based) is enclosed (relative/path/to/node<2>/subnode) // Note: nodeName tags are always created if they do not exist // attribs - attribute name, attribute value pairs // value - new node value, if non-empty // Outputs: // Returns true if nodeName is created bool XmlFile::beginGroup(QString nodeName, const QMap<QString, QVariant> attribs, const QVariant & value) { bool bRet = false; QDomElement set; if (nodeName.isEmpty()) nodeName = firstChildKey(); if (nodeName.isEmpty()) nodeName = "XmlItem"; // Get the node path QStringList nodepath = nodeName.split("/"); int level = nodepath.count(); m_levels.append(level); for (int i = 0; i < level; ++i) { QString strTagName = nodepath[i]; // Extract index int index = 0; { int idx = strTagName.indexOf("<"); if (idx >= 0) { index = strTagName.mid(idx + 1, strTagName.length() - idx - 2).toInt(); strTagName = strTagName.left(idx); nodepath[i] = strTagName; } } // Look if the element (with given index) exists then get it QDomNode parent; if (!m_nodes.isEmpty()) { // Get the current node parent = m_nodes.last(); } else { parent = m_doc; } int count = 0; for(QDomElement elem = parent.firstChildElement(strTagName); !elem.isNull(); elem = elem.nextSiblingElement(strTagName)) { count++; if (count == index + 1) { set = elem; break; } } // Create all new subnodes for (int j = 0; j < (index + 1 - count); ++j) { bRet = true; set = m_doc.createElement(strTagName); parent.appendChild(set); } // Add all the parent nodes without attribute or value if (i < level - 1) m_nodes.append(set); } // Now add the node to the end of the list m_nodes.append(set); // if there is some text/value to set if (value.isValid()) { bool bTextLeaf = false; QVariantList varlst; switch (value.type()) { case QVariant::StringList: case QVariant::List: varlst = value.toList(); if (AddList(varlst, nodepath.last())) set.setAttribute("Type", "Array"); break; default: QString text; if (value.type() == QVariant::UserType) { const XmlItem * item = static_cast<const XmlItem *>(value.data()); QVariant subval = item->XmlValue(); if (subval.type() == QVariant::UserType) { const XmlItem * subitem = static_cast<const XmlItem *>(subval.data()); QString strSubKey = subitem->XmlName(); QMap<QString, QVariant> attribs = subitem->XmlAttribs(); // Recursively add this item beginGroup(strSubKey, attribs, subval); endGroup(); } else if (subval.type() == QVariant::List || subval.type() == QVariant::StringList) { varlst = subval.toList(); if (AddList(varlst, nodepath.last())) set.setAttribute("Type", "Array"); } else { text = subval.toString(); bTextLeaf = true; } } else { text = value.toString(); bTextLeaf = true; } if (bTextLeaf) { // Remove all the children while (set.hasChildNodes()) set.removeChild(set.lastChild()); // See if this is Xml fragment string XmlFile xml; if (!xml.setContent(text)) { QDomNode frag = m_doc.importNode(xml.getFragment(), true); set.appendChild(frag); } else { QDomText domText = m_doc.createTextNode(text); set.appendChild(domText); } } } } // Add all the additional attributes QMap<QString, QVariant>::const_iterator iterator; for (iterator = attribs.begin(); iterator != attribs.end(); ++iterator) { QString attrName = iterator.key(); QVariant attrValue = iterator.value(); switch (attrValue.type()) { case QVariant::String: set.setAttribute(attrName, attrValue.toString()); break; case QVariant::Int: set.setAttribute(attrName, attrValue.toInt()); break; case QVariant::UInt: set.setAttribute(attrName, attrValue.toUInt()); break; case QVariant::LongLong: set.setAttribute(attrName, attrValue.toLongLong()); break; case QVariant::ULongLong: set.setAttribute(attrName, attrValue.toULongLong()); break; default: // everything else is treated as double floating point set.setAttribute(attrName, attrValue.toDouble()); break; } } return bRet; }
bool json_file_generate (QTextStream &res, const QVariant &val, int indent) { switch (val.type()) { case QVariant::Invalid: res << "null"; break; case QVariant::Bool: res << (val.toBool() ? "true" : "false"); break; case QVariant::Char: res << Json::quote(QString(val.toChar())).toUtf8(); break; case QVariant::Double: res << QString::number(val.toDouble()).toLatin1(); break; //CHECKME: is '.' always '.'? case QVariant::Int: res << QString::number(val.toInt()).toLatin1(); break; case QVariant::String: res << Json::quote(val.toString()).toUtf8(); break; case QVariant::UInt: res << QString::number(val.toUInt()).toLatin1(); break; case QVariant::ULongLong: res << QString::number(val.toULongLong()).toLatin1(); break; case QVariant::Map: { //for (int c = indent; c > 0; c--) res << ' '; res << "{"; indent++; bool comma = false; QVariantMap m(val.toMap()); QVariantMap::const_iterator i; for (i = m.constBegin(); i != m.constEnd(); ++i) { if (comma) res << ",\n"; else { res << '\n'; comma = true; } for (int c = indent; c > 0; c--) res << ' '; res << Json::quote(i.key()).toUtf8(); res << ": "; if (!json_file_generate(res, i.value(), indent)) return false; } indent--; if (comma) { res << '\n'; for (int c = indent; c > 0; c--) res << ' '; } res << '}'; indent--; } break; case QVariant::List: { //for (int c = indent; c > 0; c--) res << ' '; res << "["; indent++; bool comma = false; QVariantList m(val.toList()); foreach (const QVariant &v, m) { if (comma) res << ",\n"; else { res << '\n'; comma = true; } for (int c = indent; c > 0; c--) res << ' '; if (!json_file_generate(res, v, indent)) return false; } indent--; if (comma) { res << '\n'; for (int c = indent; c > 0; c--) res << ' '; } res << ']'; indent--; } break; case QVariant::StringList: { //for (int c = indent; c > 0; c--) res << ' '; res << "["; indent++; bool comma = false; QStringList m(val.toStringList()); foreach (const QString &v, m) { if (comma) res << ",\n"; else { res << '\n'; comma = true; } for (int c = indent; c > 0; c--) res << ' '; res << Json::quote(v).toUtf8(); } indent--; if (comma) { res << '\n'; for (int c = indent; c > 0; c--) res << ' '; } res << ']'; indent--; } break; default: return false; } return true; }
AllPrimitiveTypes AbstractBitfieldDataInformation::fromVariant(const QVariant& variant, bool* ok) const { return AllPrimitiveTypes(variant.toULongLong(ok)); }
QString PostFilter::match(const QMap<QString, Token> &tokens, QString filter, bool invert) { // Invert the filter by prepending '-' if (filter.startsWith('-')) { filter = filter.right(filter.length() - 1); invert = !invert; } // Tokens if (filter.startsWith('%') && filter.endsWith('%')) { QString key = filter.mid(1, filter.length() - 2); bool cond = tokens.contains(key) && !isVariantEmpty(tokens[key].value()); if (cond && invert) { return QObject::tr("image has a \"%1\" token").arg(key); } else if (!cond && !invert) { return QObject::tr("image does not have a \"%1\" token").arg(key); } } // Meta-tags else if (filter.contains(":")) { QString type = filter.section(':', 0, 0).toLower(); filter = filter.section(':', 1).toLower(); if (!tokens.contains(type)) { QStringList keys = tokens.keys(); return QObject::tr("unknown type \"%1\" (available types: \"%2\")").arg(type, keys.join("\", \"")); } QVariant token = tokens[type].value(); if (token.type() == QVariant::Int || token.type() == QVariant::DateTime || token.type() == QVariant::ULongLong) { int input = 0; if (token.type() == QVariant::Int) { input = token.toInt(); } else if (token.type() == QVariant::DateTime) { input = token.toDateTime().toString("yyyyMMdd").toInt(); } else if (token.type() == QVariant::ULongLong) { input = token.toULongLong(); } bool cond; if (token.type() == QVariant::DateTime) { if (filter.startsWith("..") || filter.startsWith("<=")) { cond = input <= toDate(filter.right(filter.size()-2)); } else if (filter.endsWith("..")) { cond = input >= toDate(filter.left(filter.size()-2)); } else if (filter.startsWith(">=")) { cond = input >= toDate(filter.right(filter.size()-2)); } else if (filter.startsWith("<")) { cond = input < toDate(filter.right(filter.size()-1)); } else if (filter.startsWith(">")) { cond = input > toDate(filter.right(filter.size()-1)); } else if (filter.contains("..")) { cond = input >= toDate(filter.left(filter.indexOf(".."))) && input <= toDate(filter.right(filter.size()-filter.indexOf("..")-2)); } else { cond = input == toDate(filter); } } else { if (filter.startsWith("..") || filter.startsWith("<=")) { cond = input <= filter.rightRef(filter.size()-2).toInt(); } else if (filter.endsWith("..")) { cond = input >= filter.leftRef(filter.size()-2).toInt(); } else if (filter.startsWith(">=")) { cond = input >= filter.rightRef(filter.size()-2).toInt(); } else if (filter.startsWith("<")) { cond = input < filter.rightRef(filter.size()-1).toInt(); } else if (filter.startsWith(">")) { cond = input > filter.rightRef(filter.size()-1).toInt(); } else if (filter.contains("..")) { cond = input >= filter.leftRef(filter.indexOf("..")).toInt() && input <= filter.rightRef(filter.size()-filter.indexOf("..")-2).toInt(); } else { cond = input == filter.toInt(); } } if (!cond && !invert) { return QObject::tr("image's %1 does not match").arg(type); } if (cond && invert) { return QObject::tr("image's %1 match").arg(type); } } else { if (type == "rating") { QMap<QString, QString> assoc; assoc["s"] = "safe"; assoc["q"] = "questionable"; assoc["e"] = "explicit"; if (assoc.contains(filter)) filter = assoc[filter]; bool cond = !filter.isEmpty() && token.toString().toLower().startsWith(filter.at(0)); if (!cond && !invert) { return QObject::tr("image is not \"%1\"").arg(filter); } if (cond && invert) { return QObject::tr("image is \"%1\"").arg(filter); } } else if (type == "source") { QRegExp rx(filter + "*", Qt::CaseInsensitive, QRegExp::Wildcard); bool cond = rx.exactMatch(token.toString()); if (!cond && !invert) { return QObject::tr("image's source does not starts with \"%1\"").arg(filter); } if (cond && invert) { return QObject::tr("image's source starts with \"%1\"").arg(filter); } } else { QString input = token.toString(); bool cond = input == filter; if (!cond && !invert) { return QObject::tr("image's %1 does not match").arg(type); } if (cond && invert) { return QObject::tr("image's %1 match").arg(type); } } } } else if (!filter.isEmpty()) { QStringList tags = tokens["allos"].value().toStringList(); // Check if any tag match the filter (case insensitive plain text with wildcards allowed) bool cond = false; for (const QString &tag : tags) { QRegExp reg(filter.trimmed(), Qt::CaseInsensitive, QRegExp::Wildcard); if (reg.exactMatch(tag)) { cond = true; break; } } if (!cond && !invert) { return QObject::tr("image does not contains \"%1\"").arg(filter); } if (cond && invert) { return QObject::tr("image contains \"%1\"").arg(filter); } } return QString(); }
void toXmlRpcValue( const int spaces, const QVariant &child, QByteArray &b ) { #ifdef DEBUG_XMLRPC qDebug() << "toXmlRpcValue()"; #endif switch ( child.type() ) { case QVariant::LongLong: #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( "<value><longlong>" + QString::number( child.toLongLong()) + "</longlong></value>" ); break; case QVariant::ULongLong: #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( "<value><ulonglong>" + QString::number( child.toULongLong()) + "</ulonglong></value>" ); break; case QVariant::Int: #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( "<value><int>" + QString::number( child.toInt()) + "</int></value>" ); break; case QVariant::Bool: #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( QString( "<value><boolean>") + (child.toBool() ? "1" : "0") + "</boolean></value>" ); break; case QVariant::String: #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( "<value><string>" + child.toString() + "</string></value>" ); break; case QVariant::Double: #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( "<value><double>" + QString::number( child.toDouble()) + "</double></value>" ); break; case QVariant::Time: #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( "<value><time.iso8601>" + child.toTime().toString( "HH:mm:ss") + "</time.iso8601></value>" ); break; case QVariant::Date: #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( "<value><date.iso8601>" + child.toDate().toString( "yyyyMMdd") + "</date.iso8601></value>" ); break; case QVariant::DateTime: #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( "<value><dateTime.iso8601>" + child.toDateTime().toString( "yyyyMMddTHH:mm:ss") + "</dateTime.iso8601></value>" ); break; case QVariant::ByteArray: #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( "<value><base64>" + child.toByteArray().toBase64() + "</base64></value>" ); break; case QVariant::List: #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( "<value><array><data>" ); toXmlRpcArray( spaces + 2, child.toList(), b ); #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( "</data></array></value>" ); break; case QVariant::Map: #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( "<value><struct>" ); toXmlRpcStruct( spaces + 2, child.toMap(), b ); #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append( "</struct></value>" ); break; case QVariant::Invalid: #ifdef XMLRPC_WITHSPACES b.append( '\n' ); b.append( QByteArray( spaces, ' ') ); #endif b.append("<value><invalid/></value>"); break; default: qCritical() << "toXmlRpcValue(): unknown return xmlrpc type" << child.typeName() << endl << child; qFatal( "programming error" ); } }
static QString variantToTextValue(const QVariant &value, const QString &typeNs, const QString &type) { switch (value.userType()) { case QVariant::Char: // fall-through case QVariant::String: return value.toString(); case QVariant::Url: // xmlpatterns/data/qatomicvalue.cpp says to do this: return value.toUrl().toString(); case QVariant::ByteArray: { const QByteArray data = value.toByteArray(); if (typeNs == KDSoapNamespaceManager::xmlSchema1999() || typeNs == KDSoapNamespaceManager::xmlSchema2001()) { if (type == QLatin1String("hexBinary")) { const QByteArray hb = data.toHex(); return QString::fromLatin1(hb.constData(), hb.size()); } } // default to base64Binary, like variantToXMLType() does. const QByteArray b64 = value.toByteArray().toBase64(); return QString::fromLatin1(b64.constData(), b64.size()); } case QVariant::Int: // fall-through case QVariant::LongLong: // fall-through case QVariant::UInt: return QString::number(value.toLongLong()); case QVariant::ULongLong: return QString::number(value.toULongLong()); case QVariant::Bool: case QMetaType::Float: case QVariant::Double: return value.toString(); case QVariant::Time: { const QTime time = value.toTime(); if (time.msec()) { // include milli-seconds return time.toString(QLatin1String("hh:mm:ss.zzz")); } else { return time.toString(Qt::ISODate); } } case QVariant::Date: return value.toDate().toString(Qt::ISODate); case QVariant::DateTime: // http://www.w3.org/TR/xmlschema-2/#dateTime return KDDateTime(value.toDateTime()).toDateString(); case QVariant::Invalid: qDebug() << "ERROR: Got invalid QVariant in a KDSoapValue"; return QString(); default: if (value.canConvert<KDDateTime>()) { return value.value<KDDateTime>().toDateString(); } if (value.userType() == qMetaTypeId<float>()) { return QString::number(value.value<float>()); } qDebug() << QString::fromLatin1("QVariants of type %1 are not supported in " "KDSoap, see the documentation").arg(QLatin1String(value.typeName())); return value.toString(); } }
VALUE RubyType<QVariant>::toVALUE(const QVariant& v) { #ifdef QROSS_RUBY_VARIANT_DEBUG qrossdebug( QString("RubyType<QVariant>::toVALUE variant.toString=%1 variant.typeid=%2 variant.typeName=%3").arg(v.toString()).arg(v.type()).arg(v.typeName()) ); #endif switch( v.type() ) { case QVariant::Int: return RubyType<int>::toVALUE(v.toInt()); case QVariant::UInt: return RubyType<uint>::toVALUE(v.toUInt()); case QVariant::Double: return RubyType<double>::toVALUE(v.toDouble()); case QVariant::ByteArray: return RubyType<QByteArray>::toVALUE(v.toByteArray()); case QVariant::String: return RubyType<QString>::toVALUE(v.toString()); case QVariant::Bool: return RubyType<bool>::toVALUE(v.toBool()); case QVariant::StringList: return RubyType<QStringList>::toVALUE(v.toStringList()); case QVariant::Map: return RubyType<QVariantMap>::toVALUE(v.toMap()); case QVariant::List: return RubyType<QVariantList>::toVALUE(v.toList()); case QVariant::LongLong: return RubyType<qlonglong>::toVALUE(v.toLongLong()); case QVariant::ULongLong: return RubyType<qlonglong>::toVALUE(v.toULongLong()); case QVariant::Size: return RubyType<QSize>::toVALUE(v.toSize()); case QVariant::SizeF: return RubyType<QSizeF>::toVALUE(v.toSizeF()); case QVariant::Point: return RubyType<QPoint>::toVALUE(v.toPoint()); case QVariant::PointF: return RubyType<QPointF>::toVALUE(v.toPointF()); case QVariant::Rect: return RubyType<QRect>::toVALUE(v.toRect()); case QVariant::RectF: return RubyType<QRectF>::toVALUE(v.toRectF()); case QVariant::Color: return RubyType<QColor>::toVALUE( v.value<QColor>() ); case QVariant::Url: return RubyType<QUrl>::toVALUE(v.toUrl()); case QVariant::Date: return RubyType<QDate>::toVALUE( v.value<QDate>() ); case QVariant::Time: return RubyType<QTime>::toVALUE( v.value<QTime>() ); case QVariant::DateTime: return RubyType<QDateTime>::toVALUE( v.value<QDateTime>() ); case QVariant::Invalid: { #ifdef QROSS_RUBY_VARIANT_DEBUG qrossdebug( QString("RubyType<QVariant>::toVALUE variant=%1 is QVariant::Invalid. Returning Qnil.").arg(v.toString()) ); #endif return Qnil; } // fall through case QVariant::UserType: { #ifdef QROSS_RUBY_VARIANT_DEBUG qrossdebug( QString("RubyType<QVariant>::toVALUE variant=%1 is QVariant::UserType. Trying to cast now.").arg(v.toString()) ); #endif } // fall through default: { if( strcmp(v.typeName(),"float") == 0 ) { #ifdef QROSS_RUBY_VARIANT_DEBUG qrossdebug( QString("RubyType<QVariant>::toVALUE Casting '%1' to double").arg(v.typeName()) ); #endif return RubyType<double>::toVALUE(v.toDouble()); } if( strcmp(v.typeName(),"Qross::VoidList") == 0 ) { VoidList list = v.value<VoidList>(); Qross::MetaTypeHandler* handler = Qross::Manager::self().metaTypeHandler(list.typeName); #ifdef QROSS_RUBY_VARIANT_DEBUG qrossdebug( QString("RubyType<QVariant>::toVALUE Casting '%1' to QList<%2> with %3 items, hasHandler=%4").arg(v.typeName()).arg(list.typeName.constData()).arg(list.count()).arg(handler ? "true" : "false") ); #endif QVariantList l; foreach(void* ptr, list) { if( handler ) { l << handler->callHandler(ptr); } else { QVariant v; v.setValue(ptr); l << v; } } return RubyType<QVariantList>::toVALUE(l); } if( qVariantCanConvert< Qross::Object::Ptr >(v) ) { #ifdef QROSS_RUBY_VARIANT_DEBUG qrossdebug( QString("RubyType<QVariant>::toPyObject Casting '%1' to Qross::Object::Ptr").arg(v.typeName()) ); #endif Qross::Object::Ptr obj = v.value< Qross::Object::Ptr >(); Qross::RubyObject* rbobj = dynamic_cast< Qross::RubyObject* >(obj.data()); if(! obj) { #ifdef QROSS_RUBY_VARIANT_DEBUG qrossdebug( QString("RubyType<QVariant>::toPyObject To Qross::RubyObject* casted '%1' is NULL").arg(v.typeName()) ); #endif return Qnil; } return rbobj->rbObject(); } if( qVariantCanConvert< QWidget* >(v) ) { #ifdef QROSS_RUBY_VARIANT_DEBUG qrossdebug( QString("RubyType<QVariant>::toVALUE Casting '%1' to QWidget").arg(v.typeName()) ); #endif QWidget* widget = qvariant_cast< QWidget* >(v); if(! widget) { #ifdef QROSS_RUBY_VARIANT_DEBUG qrosswarning( QString("RubyType<QVariant>::toVALUE To QWidget casted '%1' is NULL").arg(v.typeName()) ); #endif return Qnil; } return RubyExtension::toVALUE( new RubyExtension(widget), true /*owner*/ ); } if( qVariantCanConvert< QObject* >(v) ) { #ifdef QROSS_RUBY_VARIANT_DEBUG qrossdebug( QString("RubyType<QVariant>::toVALUE Casting '%1' to QObject*").arg(v.typeName()) ); #endif QObject* obj = qvariant_cast< QObject* >(v); if(! obj) { #ifdef QROSS_RUBY_VARIANT_DEBUG qrosswarning( QString("RubyType<QVariant>::toVALUE To QObject casted '%1' is NULL").arg(v.typeName()) ); #endif return Qnil; } return RubyExtension::toVALUE( new RubyExtension(obj), true /*owner*/ ); } if( qVariantCanConvert< void* >(v) ) { return Data_Wrap_Struct( rb_cObject, 0, 0, qvariant_cast<void*>(v)); } //QObject* obj = (*reinterpret_cast< QObject*(*)>( variantargs[0]->toVoidStar() )); //PyObject* qobjectptr = PyLong_FromVoidPtr( (void*) variantargs[0]->toVoidStar() ); #ifdef QROSS_RUBY_VARIANT_DEBUG qrosswarning( QString("RubyType<QVariant>::toVALUE Not possible to convert the QVariant '%1' with type '%2' (%3) to a VALUE.").arg(v.toString()).arg(v.typeName()).arg(v.type()) ); #endif //throw Py::TypeError( QString("Variant of type %1 can not be casted to a Ruby object.").arg(v.typeName()).toLatin1().constData() ); return 0; } }
void XmlPListSerializer::RenderValue(const QString &sName, const QVariant &vValue, bool needKey) { if ( vValue.canConvert<QObject*>()) { const QObject *pObject = vValue.value<QObject*>(); SerializePListObjectProperties(sName, pObject, needKey); return; } switch(vValue.type()) { case QVariant::List: { RenderList(sName, vValue.toList()); break; } case QVariant::StringList: { RenderStringList(sName, vValue.toStringList()); break; } case QVariant::Map: { RenderMap(sName, vValue.toMap()); break; } case QVariant::DateTime: { if (vValue.toDateTime().isValid()) { if (needKey) m_pXmlWriter->writeTextElement("key", sName); m_pXmlWriter->writeTextElement("date", vValue.toDateTime() .toUTC().toString("yyyy-MM-ddThh:mm:ssZ")); } break; } case QVariant::ByteArray: { if (!vValue.toByteArray().isNull()) { if (needKey) m_pXmlWriter->writeTextElement("key", sName); m_pXmlWriter->writeTextElement("data", vValue.toByteArray().toBase64().data()); } break; } case QVariant::Bool: { if (needKey) m_pXmlWriter->writeTextElement("key", sName); m_pXmlWriter->writeEmptyElement(vValue.toBool() ? "true" : "false"); break; } case QVariant::UInt: case QVariant::ULongLong: { if (needKey) m_pXmlWriter->writeTextElement("key", sName); m_pXmlWriter->writeTextElement("integer", QString::number(vValue.toULongLong())); break; } case QVariant::Int: case QVariant::LongLong: case QVariant::Double: { if (needKey) m_pXmlWriter->writeTextElement("key", sName); m_pXmlWriter->writeTextElement("real", QString("%1").arg(vValue.toDouble(), 0, 'f', 6)); break; } // anything else will be unrecognised, so wrap in a string case QVariant::String: default: { if (needKey) m_pXmlWriter->writeTextElement("key", sName); m_pXmlWriter->writeTextElement("string", vValue.toString()); break; } } }
bool JSON_Model::setData(QModelIndex const& index, QVariant const& value, int role) { if (!index.isValid()) { return false; } auto* ti = (Tree_Item*)index.internalPointer(); if (!ti || !ti->m_json) { return false; } bool modified = false; auto* json = ti->m_json; if (role == Qt::DisplayRole || role == Qt::EditRole) { if (index.column() == 1) { if (json->IsBool()) { json->SetBool(value.toBool()); modified = true; } else if (json->IsInt()) { json->SetInt(value.toInt()); modified = true; } else if (json->IsUint()) { json->SetUint(value.toUInt()); modified = true; } else if (json->IsInt64()) { json->SetInt64(value.toLongLong()); modified = true; } else if (json->IsUint64()) { json->SetUint64(value.toULongLong()); modified = true; } else if (json->IsDouble() || json->IsNumber()) { json->SetDouble(value.toDouble()); modified = true; } else if (json->IsString()) { json->SetString(value.toString().toLatin1().data(), m_document->GetAllocator()); modified = true; } } } if (modified) { emit dataChanged(createIndex(index.row(), 0, index.internalPointer()), createIndex(index.row(), columnCount(), index.internalPointer())); } return modified; }