bool qgsVariantLessThan( const QVariant& lhs, const QVariant& rhs ) { switch ( lhs.type() ) { case QVariant::Int: return lhs.toInt() < rhs.toInt(); case QVariant::UInt: return lhs.toUInt() < rhs.toUInt(); case QVariant::LongLong: return lhs.toLongLong() < rhs.toLongLong(); case QVariant::ULongLong: return lhs.toULongLong() < rhs.toULongLong(); case QVariant::Double: return lhs.toDouble() < rhs.toDouble(); case QVariant::Char: return lhs.toChar() < rhs.toChar(); case QVariant::Date: return lhs.toDate() < rhs.toDate(); case QVariant::Time: return lhs.toTime() < rhs.toTime(); case QVariant::DateTime: return lhs.toDateTime() < rhs.toDateTime(); default: return QString::localeAwareCompare( lhs.toString(), rhs.toString() ) < 0; } }
QScriptValueImpl Variant::method_valueOf(QScriptContextPrivate *context, QScriptEnginePrivate *eng, QScriptClassInfo *classInfo) { if (Instance *instance = Instance::get(context->thisObject(), classInfo)) { QVariant v = instance->value; switch (v.type ()) { case QVariant::Invalid: return eng->undefinedValue(); case QVariant::String: return (QScriptValueImpl(eng, v.toString())); case QVariant::Int: return (QScriptValueImpl(v.toInt())); case QVariant::Bool: return (QScriptValueImpl(v.toBool())); case QVariant::Double: return (QScriptValueImpl(v.toDouble())); // ### hmmm case QVariant::Char: return (QScriptValueImpl(v.toChar().unicode())); case QVariant::UInt: return (QScriptValueImpl(v.toUInt())); default: return context->thisObject(); } // switch } return context->thisObject(); }
void lua::push_qvariant(lua_State* const state, const QVariant& value) { switch (value.userType()) { case QVariant::Invalid: lua::push(state, lua::value::nil); break; case QVariant::Bool: lua::push(state, value.toBool()); break; case QVariant::Char: lua::push(state, value.toChar()); break; case QVariant::Int: { lua::push(state, value.toInt()); break; } case QVariant::Double: case QVariant::UInt: lua::push(state, value.toDouble()); break; case QVariant::String: lua::push(state, value.toString()); break; case QVariant::Hash: { auto hash = value.toHash(); auto table = lua::push(state, lua::value::table); for (auto i = hash.begin(); i != hash.end(); ++i) { lua::table::set(table, i.key(), i.value()); } break; } case QVariant::StringList: { auto list = value.toStringList(); auto table = lua::push(state, lua::value::table); for (int i = 0; i < list.size(); ++i) { lua::table::set(table, i + 1, list[i]); } break; } default: { auto converter = qvariant_push_handler.find(value.userType()); if (converter != qvariant_push_handler.end()) { converter->second(state, value); } else { throw std::logic_error(std::string("No handler exists to push QVariant type: ") + value.typeName()); } } } }
QString AsteriskManager::valueToString(QVariant value) { switch (value.type()) { case QVariant::Char: return value.toChar() == 1 ? "true" : "false"; default: return value.toString(); } }
uint qHash(const QVariant &var) { if (!var.isValid() || var.isNull()) return -1; switch (var.type()) { case QVariant::Int: return qHash( var.toInt() ); case QVariant::UInt: return qHash( var.toUInt() ); case QVariant::Bool: return qHash( var.toUInt() ); case QVariant::Double: return qHash( var.toUInt() ); case QVariant::LongLong: return qHash( var.toLongLong() ); case QVariant::ULongLong: return qHash( var.toULongLong() ); case QVariant::String: return qHash( var.toString() ); case QVariant::Char: return qHash( var.toChar() ); case QVariant::StringList: return qHash( var.toString() ); case QVariant::ByteArray: return qHash( var.toByteArray() ); case QVariant::Date: case QVariant::Time: case QVariant::DateTime: case QVariant::Url: case QVariant::Locale: case QVariant::RegExp: return qHash( var.toString() ); case QVariant::Map: case QVariant::List: case QVariant::BitArray: case QVariant::Size: case QVariant::SizeF: case QVariant::Rect: case QVariant::LineF: case QVariant::Line: case QVariant::RectF: case QVariant::Point: case QVariant::UserType: case QVariant::Invalid: default: Q_ASSERT(false); } // could not generate a hash for the given variant Q_ASSERT(false); return 0; }
int MultiSortFilterProxy::Compare(const QVariant& left, const QVariant& right) const { // Copied from the QSortFilterProxyModel::lessThan implementation, but returns // -1, 0 or 1 instead of true or false. switch (left.userType()) { case QVariant::Invalid: return (right.type() != QVariant::Invalid) ? -1 : 0; case QVariant::Int: return DoCompare(left.toInt(), right.toInt()); case QVariant::UInt: return DoCompare(left.toUInt(), right.toUInt()); case QVariant::LongLong: return DoCompare(left.toLongLong(), right.toLongLong()); case QVariant::ULongLong: return DoCompare(left.toULongLong(), right.toULongLong()); case QMetaType::Float: return DoCompare(left.toFloat(), right.toFloat()); case QVariant::Double: return DoCompare(left.toDouble(), right.toDouble()); case QVariant::Char: return DoCompare(left.toChar(), right.toChar()); case QVariant::Date: return DoCompare(left.toDate(), right.toDate()); case QVariant::Time: return DoCompare(left.toTime(), right.toTime()); case QVariant::DateTime: return DoCompare(left.toDateTime(), right.toDateTime()); case QVariant::String: default: if (isSortLocaleAware()) return left.toString().localeAwareCompare(right.toString()); else return left.toString().compare(right.toString(), sortCaseSensitivity()); } return 0; }
char AppSettings::getCsvSeparator (void) { QVariant var = m_Settings.value(SETTINGNAME_CSV_SEPARATOR); if (var.canConvert(QVariant::Char)) { char c = var.toChar().toAscii(); if (ExporterSinkCsv::isAllowedSeparator(c)) return c; else this->setCsvSeparator(ExporterSinkCsv::defaultSeparator()); } return ExporterSinkCsv::defaultSeparator(); }
bool ResultsTree::GroupSortProxyModel::QVariantCompare::operator() (QVariant l, QVariant r) { // CODE COPIED FROM QSortFilterProxyModel::lessThan switch (l.userType()) { case QVariant::Invalid: return (r.type() != QVariant::Invalid); case QVariant::Int: return l.toInt() < r.toInt(); case QVariant::UInt: return l.toUInt() < r.toUInt(); case QVariant::LongLong: return l.toLongLong() < r.toLongLong(); case QVariant::ULongLong: return l.toULongLong() < r.toULongLong(); case QMetaType::Float: return l.toFloat() < r.toFloat(); case QVariant::Double: return l.toDouble() < r.toDouble(); case QVariant::Char: return l.toChar() < r.toChar(); case QVariant::Date: return l.toDate() < r.toDate(); case QVariant::Time: return l.toTime() < r.toTime(); case QVariant::DateTime: return l.toDateTime() < r.toDateTime(); case QVariant::String: default: //if (d->sort_localeaware) return l.toString().localeAwareCompare(r.toString()) < 0; /*else return l.toString().compare(r.toString(), d->sort_casesensitivity) < 0;*/ } return false; }
Qt::Key QtUiTest::variantToKey(const QVariant &keyValue) { Qt::Key key = (Qt::Key)0; switch(keyValue.type()) { default: key = (Qt::Key)keyValue.toInt(); break; case QVariant::Char: key = QtUiTest::asciiToKey(keyValue.toChar().toAscii()); break; case QVariant::String: if (keyValue.toString().length() == 1) key = QtUiTest::asciiToKey(keyValue.toString()[0].toAscii()); break; } return key; }
void MergeTool::chooseAction() { m_merging = (m_mergeType == NormalMerge); if (m_merging) return; QMessageBox msgBox; msgBox.setWindowTitle(tr("Merge Conflict")); msgBox.setIcon(QMessageBox::Question); msgBox.setStandardButtons(QMessageBox::Abort); msgBox.setText(tr("%1 merge conflict for \"%2\"\nLocal: %3\nRemote: %4") .arg(mergeTypeName()) .arg(m_fileName) .arg(stateName(m_localState, m_localInfo)) .arg(stateName(m_remoteState, m_remoteInfo)) ); switch (m_mergeType) { case SubmoduleMerge: case SymbolicLinkMerge: addButton(&msgBox, tr("&Local"), 'l'); addButton(&msgBox, tr("&Remote"), 'r'); break; case DeletedMerge: if (m_localState == CreatedState || m_remoteState == CreatedState) addButton(&msgBox, tr("&Created"), 'c'); else addButton(&msgBox, tr("&Modified"), 'm'); addButton(&msgBox, tr("&Deleted"), 'd'); break; default: break; } msgBox.exec(); QByteArray ba; QVariant key; QAbstractButton *button = msgBox.clickedButton(); if (button) key = button->property("key"); // either the message box was closed without clicking anything, or abort was clicked if (!key.isValid()) key = QVariant(QLatin1Char('a')); // abort ba.append(key.toChar().toLatin1()); ba.append('\n'); m_process->write(ba); m_process->waitForBytesWritten(); }
QScriptValue ScriptToolbox::variantToScriptValue(QScriptEngine * engine, QVariant var) { if(var.isNull()) return engine->nullValue(); switch(var.type()) { case QVariant::Invalid: return engine->nullValue(); case QVariant::Bool: return QScriptValue(engine, var.toBool()); case QVariant::Int: return QScriptValue(engine, var.toInt()); case QVariant::UInt: return QScriptValue(engine, var.toUInt()); case QVariant::Double: return QScriptValue(engine, var.toDouble()); case QVariant::Char: return QScriptValue(engine, var.toChar().unicode()); case QVariant::String: return QScriptValue(engine, var.toString()); case QVariant::LongLong: return QScriptValue(engine, qsreal(var.toLongLong())); case QVariant::ULongLong: return QScriptValue(engine, qsreal(var.toULongLong())); case QVariant::Date: case QVariant::Time: case QVariant::DateTime: return engine->newDate(var.toDateTime()); case QVariant::RegExp: return engine->newRegExp(var.toRegExp()); /* * Would be ideal to have these as well but I don't know if they are really necessary case QVariant::StringList: case QVariant::List: case QVariant::Map: */ default: return engine->newVariant(var); } // If we are not doing an explicity conversion just pass the variant back // and see what happens return engine->newVariant(var); }
void AsteriskManager::insertNotEmpty(QVariantMap *headers, QString key, QVariant value) { bool isEmpty = false; switch (value.type()) { case QMetaType::Int: isEmpty = value.toChar() == -1; break; case QMetaType::UInt: isEmpty = value.toUInt() == 0; break; default: isEmpty = value.isNull(); break; } if (!isEmpty) headers->insert(key, value); }
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; }
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 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; }
uint qHash( const QVariant &variant ) { if ( !variant.isValid() || variant.isNull() ) return std::numeric_limits<uint>::max(); switch ( variant.type() ) { case QVariant::Int: return qHash( variant.toInt() ); case QVariant::UInt: return qHash( variant.toUInt() ); case QVariant::Bool: return qHash( variant.toBool() ); case QVariant::Double: return qHash( variant.toDouble() ); case QVariant::LongLong: return qHash( variant.toLongLong() ); case QVariant::ULongLong: return qHash( variant.toULongLong() ); case QVariant::String: return qHash( variant.toString() ); case QVariant::Char: return qHash( variant.toChar() ); case QVariant::List: #if QT_VERSION >= 0x050600 return qHash( variant.toList() ); #else { QVariantList list = variant.toList(); if ( list.isEmpty() ) return -1; else return qHash( list.at( 0 ) ); } #endif case QVariant::StringList: #if QT_VERSION >= 0x050600 return qHash( variant.toStringList() ); #else { QStringList list = variant.toStringList(); if ( list.isEmpty() ) return -1; else return qHash( list.at( 0 ) ); } #endif case QVariant::ByteArray: return qHash( variant.toByteArray() ); case QVariant::Date: return qHash( variant.toDate() ); case QVariant::Time: return qHash( variant.toTime() ); case QVariant::DateTime: return qHash( variant.toDateTime() ); case QVariant::Url: case QVariant::Locale: case QVariant::RegExp: return qHash( variant.toString() ); default: break; } return std::numeric_limits<uint>::max(); }
bool ParamComboBox :: StoreParameterValue () { QVariant v = pcb_combo_box_p -> currentData (); bool success_flag = false; switch (bpw_param_p -> pa_type) { case PT_LARGE_STRING: case PT_STRING: case PT_FILE_TO_READ: case PT_FILE_TO_WRITE: case PT_DIRECTORY: case PT_KEYWORD: { QString s (v.toString ()); QByteArray ba = s.toLocal8Bit (); const char *value_s = ba.constData (); success_flag = SetParameterValue (bpw_param_p, value_s, true); qDebug () << "Setting " << bpw_param_p -> pa_name_s << " to " << value_s; } break; case PT_CHAR: { QChar qc = v.toChar (); char c = qc.toLatin1 (); success_flag = SetParameterValue (bpw_param_p, &c, true); qDebug () << "Setting " << bpw_param_p -> pa_name_s << " to " << c; } break; case PT_BOOLEAN: { bool b = v.toBool (); success_flag = SetParameterValue (bpw_param_p, &b, true); qDebug () << "Setting " << bpw_param_p -> pa_name_s << " to " << b; } break; case PT_SIGNED_INT: case PT_UNSIGNED_INT: { bool conv_flag = false; int i = v.toInt (&conv_flag); if (conv_flag) { success_flag = SetParameterValue (bpw_param_p, &i, true); qDebug () << "Setting " << bpw_param_p -> pa_name_s << " to " << i; } } break; case PT_SIGNED_REAL: case PT_UNSIGNED_REAL: { bool conv_flag = false; double d = v.toDouble (&conv_flag); if (conv_flag) { success_flag = SetParameterValue (bpw_param_p, &d, true); qDebug () << "Setting " << bpw_param_p -> pa_name_s << " to " << d; } } break; default: break; } return success_flag; }
// 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; }
/* Generate a string given a value, using formatting defined within this class. */ QString QEStringFormatting::formatString( const QVariant& value ) const { QEStringFormatting* self = (QEStringFormatting*) this; // this works as modified members are just used as temp. variables. QString result; if( value.type() != QVariant::List ){ // "Simple" scalar result = self->formatElementString( value ); } else { // Array variable const QVariantList valueArray = value.toList(); const int number = valueArray.count (); switch( arrayAction ) { case APPEND: // Interpret each element in the array as an unsigned integer and append // string representations of each element from the array with a space in // between each. for( int j = 0; j < number; j++ ){ QVariant element = valueArray.value (j); QString elementString; elementString = self->formatElementString( element ); if( j > 0 )result.append ( " " ); result.append( elementString ); } break; case ASCII: // Interpret each element from the array as a character in a string. // Translate all non printing characters to '?' except for trailing // zeros (ignore them) for( int j = 0; j < number; j++ ){ QVariant element = valueArray.value( j ); bool okay; int c = element.toInt( &okay ); if( !okay || (c == 0) ) break; // Not an int or got a zero - end of string. // Ignore carriage returns. // Note this will cause problems when implementing on Commodore 8-bit machines, // Acorn BBC, ZX Spectrum, and TRS-80 as they don't use a line feed. if( c == '\r' ) { } // Translate all non printing characters (except for space and line feed) to a '?' else if( (c!= '\n') && (c < ' ' || c > '~') ) { result.append( "?" ); } // Use everything else as is. else { result.append( element.toChar() ); } } break; case INDEX: // Interpret the element selected by setArrayIndex(). if( arrayIndex < (unsigned int)(number) ) { QVariant element = valueArray.value ((int) arrayIndex); result = self->formatElementString( element ); } break; default: self->formatFailure( QString ( "Invalid arrayAction: %d" ).arg ( (int) arrayAction )); result = "---"; break; } } // Add units if required, if there are any present, and if the text is not an error message int eguLen = dbEgu.length(); // ??? Why cant this be in the 'if' statement? If it is it never adds an egu if( addUnits && eguLen && (format != FORMAT_TIME) ) { result.append( " " ).append( dbEgu ); } return result; }
/** * @brief is a help function that returns the hex representation of a value * @param value that is given * @return hex representation of the value given */ QString TextPanelItemDelegate::toText(QVariant value) const { return qPrintable(value.toChar()); }
bool qgsVariantLessThan( const QVariant& lhs, const QVariant& rhs ) { // invalid < NULL < any value if ( !lhs.isValid() ) return rhs.isValid(); else if ( lhs.isNull() ) return rhs.isValid() && !rhs.isNull(); else if ( !rhs.isValid() || rhs.isNull() ) return false; switch ( lhs.type() ) { case QVariant::Int: return lhs.toInt() < rhs.toInt(); case QVariant::UInt: return lhs.toUInt() < rhs.toUInt(); case QVariant::LongLong: return lhs.toLongLong() < rhs.toLongLong(); case QVariant::ULongLong: return lhs.toULongLong() < rhs.toULongLong(); case QVariant::Double: return lhs.toDouble() < rhs.toDouble(); case QVariant::Char: return lhs.toChar() < rhs.toChar(); case QVariant::Date: return lhs.toDate() < rhs.toDate(); case QVariant::Time: return lhs.toTime() < rhs.toTime(); case QVariant::DateTime: return lhs.toDateTime() < rhs.toDateTime(); case QVariant::Bool: return lhs.toBool() < rhs.toBool(); case QVariant::List: { const QList<QVariant> &lhsl = lhs.toList(); const QList<QVariant> &rhsl = rhs.toList(); int i, n = qMin( lhsl.size(), rhsl.size() ); for ( i = 0; i < n && lhsl[i].type() == rhsl[i].type() && lhsl[i].isNull() == rhsl[i].isNull() && lhsl[i] == rhsl[i]; i++ ) ; if ( i == n ) return lhsl.size() < rhsl.size(); else return qgsVariantLessThan( lhsl[i], rhsl[i] ); } case QVariant::StringList: { const QStringList &lhsl = lhs.toStringList(); const QStringList &rhsl = rhs.toStringList(); int i, n = qMin( lhsl.size(), rhsl.size() ); for ( i = 0; i < n && lhsl[i] == rhsl[i]; i++ ) ; if ( i == n ) return lhsl.size() < rhsl.size(); else return lhsl[i] < rhsl[i]; } default: return QString::localeAwareCompare( lhs.toString(), rhs.toString() ) < 0; } }
/*! \internal Stringifies \a variant. */ void JsonWriter::stringify(const QVariant &variant, int depth) { if (variant.type() == QVariant::List || variant.type() == QVariant::StringList) { m_result += QLatin1Char('['); QVariantList list = variant.toList(); for (int i = 0; i < list.count(); i++) { if (i != 0) { m_result += QLatin1Char(','); if (m_autoFormatting) m_result += QLatin1Char(' '); } stringify(list[i], depth+1); } m_result += QLatin1Char(']'); } else if (variant.type() == QVariant::Map) { QString indent = m_autoFormattingIndent.repeated(depth); QVariantMap map = variant.toMap(); if (m_autoFormatting && depth != 0) { m_result += QLatin1Char('\n'); m_result += indent; m_result += QLatin1String("{\n"); } else { m_result += QLatin1Char('{'); } for (QVariantMap::const_iterator it = map.constBegin(); it != map.constEnd(); ++it) { if (it != map.constBegin()) { m_result += QLatin1Char(','); if (m_autoFormatting) m_result += QLatin1Char('\n'); } if (m_autoFormatting) m_result += indent + QLatin1Char(' '); m_result += QLatin1Char('\"') + escape(it.key()) + QLatin1String("\":"); stringify(it.value(), depth+1); } if (m_autoFormatting) { m_result += QLatin1Char('\n'); m_result += indent; } m_result += QLatin1Char('}'); } else if (variant.type() == QVariant::String || variant.type() == QVariant::ByteArray) { m_result += QLatin1Char('\"') + escape(variant) + QLatin1Char('\"'); } else if (variant.type() == QVariant::Double || (int)variant.type() == (int)QMetaType::Float) { double d = variant.toDouble(); if (qIsFinite(d)) m_result += QString::number(variant.toDouble(), 'g', 15); else m_result += QLatin1String("null"); } else if (variant.type() == QVariant::Bool) { m_result += variant.toBool() ? QLatin1String("true") : QLatin1String("false"); } else if (variant.type() == QVariant::Invalid) { m_result += QLatin1String("null"); } else if (variant.type() == QVariant::ULongLong) { m_result += QString::number(variant.toULongLong()); } else if (variant.type() == QVariant::LongLong) { m_result += QString::number(variant.toLongLong()); } else if (variant.type() == QVariant::Int) { m_result += QString::number(variant.toInt()); } else if (variant.type() == QVariant::UInt) { m_result += QString::number(variant.toUInt()); } else if (variant.type() == QVariant::Char) { QChar c = variant.toChar(); if (c.unicode() > 127) m_result += QLatin1String("\"\\u") + QString::number(c.unicode(), 16).rightJustified(4, QLatin1Char('0')) + QLatin1Char('\"'); else m_result += QLatin1Char('\"') + c + QLatin1Char('\"'); } else if (variant.canConvert<qlonglong>()) { m_result += QString::number(variant.toLongLong()); } else if (variant.canConvert<QString>()) { m_result += QLatin1Char('\"') + escape(variant) + QLatin1Char('\"'); } else { if (!m_errorString.isEmpty()) m_errorString.append(QLatin1Char('\n')); QString msg = QString::fromLatin1("Unsupported type %1 (id: %2)").arg(QString::fromUtf8(variant.typeName())).arg(variant.userType()); m_errorString.append(msg); qWarning() << "JsonWriter::stringify - " << msg; m_result += QLatin1String("null"); } }
bool GCF::Message::encodeVariant(QDataStream& ds, const QVariant& value) { QString typeName; if( value.isValid() ) { typeName = QString(value.typeName()); if( typeName.isEmpty() ) return false; } else typeName = "Invalid"; if( value.type() >= QVariant::UserType ) return false; // Prepare the typename in-case of bool, char, int, double switch(value.type()) { case QVariant::Int: typeName = is32Bit() ? "qint32" : "qint64"; break; case QVariant::Char: typeName = "quint8"; break; case QVariant::UInt: typeName = is32Bit() ? "quint32" : "quint64"; break; default: break; } // Serialize value on to the byte array switch( value.type() ) { case QVariant::Invalid: ds << typeName; ds << qint32(0); break; case QVariant::Bool: ds << typeName; ds << value.toBool(); break; case QVariant::Char: ds << typeName; ds << value.toChar(); break; case QVariant::Color: ds << typeName; ds << value.value<QColor>(); break; case QVariant::Date: ds << typeName; ds << value.toDate(); break; case QVariant::DateTime: ds << typeName; ds << value.toDateTime(); break; case QVariant::Double: ds << typeName; ds << value.toDouble(); break; case QVariant::Int: ds << typeName; if( is32Bit() ) ds << (qint32)value.toInt(); else ds << (qint64)value.toInt(); break; case QVariant::Time: ds << typeName; ds << value.toTime(); break; case QVariant::UInt: ds << typeName; if( is32Bit() ) ds << (quint32)value.toUInt(); else ds << (quint64)value.toUInt(); break; case QVariant::String: ds << typeName; ds << value.toString(); break; case QVariant::Pixmap: ds << typeName; ds << value.value<QPixmap>(); break; case QVariant::ByteArray: ds << typeName; ds << value.toByteArray(); break; case QVariant::BitArray: ds << typeName; ds << value.toBitArray(); break; case QVariant::Image: ds << typeName; ds << value.value<QImage>(); break; case QVariant::Url: ds << typeName; ds << value.toUrl(); break; case QVariant::StringList: ds << typeName; ds << value.toStringList(); break; case QVariant::SizePolicy: ds << typeName; ds << value.value<QSizePolicy>(); break; case QVariant::SizeF: ds << typeName; ds << value.toSizeF(); break; case QVariant::Size: ds << typeName; ds << value.toSize(); break; case QVariant::RegExp: ds << typeName; ds << value.toRegExp(); break; case QVariant::RectF: ds << typeName; ds << value.toRectF(); break; case QVariant::Rect: ds << typeName; ds << value.toRect(); break; case QVariant::Polygon: ds << typeName; ds << value.value<QPolygon>(); break; case QVariant::PointF: ds << typeName; ds << value.toPointF(); break; case QVariant::Point: ds << typeName; ds << value.toPoint(); break; case QVariant::Matrix: ds << typeName; ds << value.value<QMatrix>(); break; case QVariant::LineF: ds << typeName; ds << value.toLineF(); break; case QVariant::Line: ds << typeName; ds << value.toLine(); break; case QVariant::Brush: ds << typeName; ds << value.value<QBrush>(); break; case QVariant::Bitmap: ds << typeName; ds << value.value<QBitmap>(); break; case QVariant::Transform: ds << typeName; ds << value.value<QTransform>(); break; default: // Other types will be supported shortly. // TODO: support user defined types. return false; } return true; }
void JSON::gen(QByteArray &res, const QVariant &val) { switch (val.type()) { case QVariant::Invalid: res += QLatin1String("null"); break; case QVariant::Bool: res += (val.toBool() ? QLatin1String("true") : QLatin1String("false")); break; case QVariant::Char: res += quote(QString(val.toChar())).toUtf8(); break; case QVariant::Double: res += QByteArray::number(val.toDouble()); break; //CHECKME: is '.' always '.'? case QVariant::Int: res += QByteArray::number(val.toInt()); break; case QVariant::LongLong: res += QByteArray::number(val.toLongLong()); break; case QVariant::UInt: res += QByteArray::number(val.toUInt()); break; case QVariant::ULongLong: res += QByteArray::number(val.toULongLong()); break; case QVariant::String: res += quote(val.toString()).toUtf8(); break; case QVariant::ByteArray: res += quote(val.toByteArray()); break; case QVariant::Map: { res += '{'; bool comma = false; QVariantMap m(val.toMap()); QMapIterator<QString, QVariant> i(m); while (i.hasNext()) { i.next(); if (comma) res += ','; else comma = true; res += quote(i.key()).toUtf8(); res += ':'; gen(res, i.value()); } res += '}'; } break; case QVariant::Hash: { res += '{'; bool comma = false; QVariantHash m(val.toHash()); QHashIterator<QString, QVariant> i(m); while (i.hasNext()) { i.next(); if (comma) res += ','; else comma = true; res += quote(i.key()).toUtf8(); res += ':'; gen(res, i.value()); } res += '}'; } break; case QVariant::List: { res += '['; bool comma = false; QVariantList m(val.toList()); foreach (const QVariant &v, m) { if (comma) res += ','; else comma = true; gen(res, v); } res += ']'; } break; case QVariant::StringList: { res += '['; bool comma = false; QStringList m(val.toStringList()); foreach (const QString &v, m) { if (comma) res += ','; else comma = true; res += quote(v).toUtf8(); } res += ']'; } break; default: if (val.canConvert(QVariant::String)) gen(res, val.toString()); else res += QLatin1String("null"); } }