void QNetworkReplyImplPrivate::_q_copyReadyRead()
{
Q_Q(QNetworkReplyImpl);
if (state != Working)
return;
if (!copyDevice || !q->isOpen())
return;
// FIXME Optimize to use download buffer if it is a QBuffer.
// Needs to be done where sendCacheContents() (?) of HTTP is emitting
// metaDataChanged ?
forever {
qint64 bytesToRead = nextDownstreamBlockSize();
if (bytesToRead == 0)
// we'll be called again, eventually
break;
bytesToRead = qBound<qint64>(1, bytesToRead, copyDevice->bytesAvailable());
QByteArray byteData;
byteData.resize(bytesToRead);
qint64 bytesActuallyRead = copyDevice->read(byteData.data(), byteData.size());
if (bytesActuallyRead == -1) {
byteData.clear();
backendNotify(NotifyCopyFinished);
break;
}
byteData.resize(bytesActuallyRead);
readBuffer.append(byteData);
if (!copyDevice->isSequential() && copyDevice->atEnd()) {
backendNotify(NotifyCopyFinished);
bytesDownloaded += bytesActuallyRead;
break;
}
bytesDownloaded += bytesActuallyRead;
}
if (bytesDownloaded == lastBytesDownloaded) {
// we didn't read anything
return;
}
lastBytesDownloaded = bytesDownloaded;
QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
if (preMigrationDownloaded != Q_INT64_C(-1))
totalSize = totalSize.toLongLong() + preMigrationDownloaded;
pauseNotificationHandling();
// emit readyRead before downloadProgress incase this will cause events to be
// processed and we get into a recursive call (as in QProgressDialog).
emit q->readyRead();
if (downloadProgressSignalChoke.elapsed() >= progressSignalInterval) {
downloadProgressSignalChoke.restart();
emit q->downloadProgress(bytesDownloaded,
totalSize.isNull() ? Q_INT64_C(-1) : totalSize.toLongLong());
}
resumeNotificationHandling();
}
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;
}
}
static void
writeValue(trace::Writer &writer, const QVariant &var, unsigned &id)
{
int arrayType = QMetaType::type("ApiArray");
int bitmaskType = QMetaType::type("ApiBitmask");
int structType = QMetaType::type("ApiStruct");
int pointerType = QMetaType::type("ApiPointer");
int enumType = QMetaType::type("ApiEnum");
int type = var.userType();
switch(type) {
case QVariant::Bool:
writer.writeBool(var.toBool());
break;
case QVariant::ByteArray: {
QByteArray ba = var.toByteArray();
writer.writeBlob((const void*)ba.constData(), ba.size());
}
break;
case QVariant::Double:
writer.writeDouble(var.toDouble());
break;
case QMetaType::Float:
writer.writeFloat(var.toFloat());
break;
case QVariant::Int:
writer.writeSInt(var.toInt());
break;
case QVariant::LongLong:
writer.writeSInt(var.toLongLong());
break;
case QVariant::String: {
QString str = var.toString();
writer.writeString(str.toLocal8Bit().constData(), str.length());
}
break;
case QVariant::UInt:
writer.writeUInt(var.toInt());
break;
case QVariant::ULongLong:
writer.writeUInt(var.toLongLong());
break;
default:
if (type == arrayType) {
ApiArray array = var.value<ApiArray>();
QVector<QVariant> vals = array.values();
writer.beginArray(vals.count());
foreach(QVariant el, vals) {
writer.beginElement();
writeValue(writer, el, ++id);
writer.endElement();
}
writer.endArray();
} else if (type == bitmaskType) {
bool ImageSortSettings::lessThan(const QVariant& left, const QVariant& right) const
{
if (left.type() != right.type())
{
return false;
}
switch (left.type())
{
case QVariant::Int:
return compareByOrder(left.toInt(), right.toInt(), currentSortOrder);
case QVariant::UInt:
return compareByOrder(left.toUInt(), right.toUInt(), currentSortOrder);
case QVariant::LongLong:
return compareByOrder(left.toLongLong(), right.toLongLong(), currentSortOrder);
case QVariant::ULongLong:
return compareByOrder(left.toULongLong(), right.toULongLong(), currentSortOrder);
case QVariant::Double:
return compareByOrder(left.toDouble(), right.toDouble(), currentSortOrder);
case QVariant::Date:
return compareByOrder(left.toDate(), right.toDate(), currentSortOrder);
case QVariant::DateTime:
return compareByOrder(left.toDateTime(), right.toDateTime(), currentSortOrder);
case QVariant::Time:
return compareByOrder(left.toTime(), right.toTime(), currentSortOrder);
case QVariant::Rect:
case QVariant::RectF:
{
QRectF rectLeft = left.toRectF();
QRectF rectRight = right.toRectF();
int result;
if ((result = compareByOrder(rectLeft.top(), rectRight.top(), currentSortOrder)) != 0)
{
return result < 0;
}
if ((result = compareByOrder(rectLeft.left(), rectRight.left(), currentSortOrder)) != 0)
{
return result < 0;
}
QSizeF sizeLeft = rectLeft.size(), sizeRight = rectRight.size();
if ((result = compareByOrder(sizeLeft.width()*sizeLeft.height(), sizeRight.width()*sizeRight.height(), currentSortOrder)) != 0)
{
return result < 0;
}
// FIXME: fall through?? If not, add "break" here
}
default:
return naturalCompare(left.toString(), right.toString(), currentSortOrder, sortCaseSensitivity);
}
}
QString DateDelegate::displayText(const QVariant &value, const QLocale &locale) const {
Q_UNUSED(locale); // suppress unused variable
if (value.toLongLong() == 0)
return "";
QDateTime timestamp;
timestamp.setTime_t(value.toLongLong()/1000);
// if (timestamp.date() == QDate::currentDate())
// return tr("Today") +" " + timestamp.time().toString(global.getTimeFormat());
return timestamp.toString(global.getDateTimeFormat());
}
bool QgsAttributeTableFilterModel::lessThan( const QModelIndex &left, const QModelIndex &right ) const
{
if ( mSelectedOnTop )
{
bool leftSelected = layer()->selectedFeaturesIds().contains( masterModel()->rowToId( left.row() ) );
bool rightSelected = layer()->selectedFeaturesIds().contains( masterModel()->rowToId( right.row() ) );
if ( leftSelected && !rightSelected )
{
return true;
}
else if ( rightSelected && !leftSelected )
{
return false;
}
}
QVariant leftData = left.data( QgsAttributeTableModel::SortRole );
QVariant rightData = right.data( QgsAttributeTableModel::SortRole );
if ( leftData.isNull() )
return true;
if ( rightData.isNull() )
return false;
switch ( leftData.type() )
{
case QVariant::Int:
case QVariant::UInt:
case QVariant::LongLong:
case QVariant::ULongLong:
return leftData.toLongLong() < rightData.toLongLong();
case QVariant::Double:
return leftData.toDouble() < rightData.toDouble();
case QVariant::Date:
return leftData.toDate() < rightData.toDate();
case QVariant::DateTime:
return leftData.toDateTime() < rightData.toDateTime();
default:
return leftData.toString().localeAwareCompare( rightData.toString() ) < 0;
}
// Avoid warning. Will never reach this
return false;
}
int KCategorizedSortFilterProxyModel::compareCategories ( const QModelIndex &left, const QModelIndex &right ) const
{
QVariant l = ( left.model() ? left.model()->data ( left, CategorySortRole ) : QVariant() );
QVariant r = ( right.model() ? right.model()->data ( right, CategorySortRole ) : QVariant() );
Q_ASSERT ( l.isValid() );
Q_ASSERT ( r.isValid() );
Q_ASSERT ( l.type() == r.type() );
if ( l.type() == QVariant::String )
{
QString lstr = l.toString();
QString rstr = r.toString();
/*
if ( d->sortCategoriesByNaturalComparison )
{
return KStringHandler::naturalCompare ( lstr, rstr );
}
else
{
*/
if ( lstr < rstr )
{
return -1;
}
if ( lstr > rstr )
{
return 1;
}
return 0;
//}
}
qlonglong lint = l.toLongLong();
qlonglong rint = r.toLongLong();
if ( lint < rint )
{
return -1;
}
if ( lint > rint )
{
return 1;
}
return 0;
}
void QNetworkReplyImplPrivate::_q_copyReadyRead()
{
Q_Q(QNetworkReplyImpl);
if (state != Working)
return;
if (!copyDevice || !q->isOpen())
return;
forever {
qint64 bytesToRead = nextDownstreamBlockSize();
if (bytesToRead == 0)
// we'll be called again, eventually
break;
bytesToRead = qBound<qint64>(1, bytesToRead, copyDevice->bytesAvailable());
QByteArray byteData;
byteData.resize(bytesToRead);
qint64 bytesActuallyRead = copyDevice->read(byteData.data(), byteData.size());
if (bytesActuallyRead == -1) {
byteData.clear();
backendNotify(NotifyCopyFinished);
break;
}
byteData.resize(bytesActuallyRead);
readBuffer.append(byteData);
if (!copyDevice->isSequential() && copyDevice->atEnd()) {
backendNotify(NotifyCopyFinished);
bytesDownloaded += bytesActuallyRead;
break;
}
bytesDownloaded += bytesActuallyRead;
}
if (bytesDownloaded == lastBytesDownloaded) {
// we didn't read anything
return;
}
lastBytesDownloaded = bytesDownloaded;
QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
if (preMigrationDownloaded != Q_INT64_C(-1))
totalSize = totalSize.toLongLong() + preMigrationDownloaded;
pauseNotificationHandling();
emit q->downloadProgress(bytesDownloaded,
totalSize.isNull() ? Q_INT64_C(-1) : totalSize.toLongLong());
emit q->readyRead();
resumeNotificationHandling();
}
QString DateDelegate::displayText(const QVariant &value, const QLocale &locale) const {
Q_UNUSED(locale); // suppress unused variable
if (value.toLongLong() == 0)
return "";
QDateTime timestamp;
timestamp.setTime_t(value.toLongLong()/1000);
//QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedKingdom));
if (timestamp.date() == QDate::currentDate())
return tr("Today") +" " + timestamp.time().toString(global.timeFormat);
return timestamp.toString(global.dateFormat + QString(" ") +global.timeFormat);
// return timestamp.toString(Qt::SystemLocaleShortDate);
}
NetworkTimeInfo NetworkTime::parseNetworkTimeInfoFromMap(QVariantMap map)
{
QVariant tmp;
QDateTime dateTime;
int daylightAdjustment = -1; // -1 means "value not available"
int offsetFromUtc = 0;
qlonglong received = 0;
QString mnc, mcc;
bool ok;
if (!map.isEmpty()) {
tmp = map.value("UTC");
if (tmp.isValid() && tmp.type() == QVariant::LongLong) {
dateTime.setTimeSpec(Qt::UTC);
qlonglong secs = tmp.toLongLong(&ok);
if (ok) {
dateTime.setMSecsSinceEpoch(secs*1000);
} else {
QDateTime tmp;
dateTime = tmp;
}
}
tmp = map.value("Received");
if (tmp.isValid() && tmp.type() == QVariant::LongLong)
received = tmp.toLongLong(&ok);
tmp = map.value("Timezone");
if (tmp.isValid() && tmp.type() == QVariant::Int)
offsetFromUtc = tmp.toInt(&ok);
tmp = map.value("DST");
if (tmp.isValid() && tmp.type() == QVariant::UInt) {
daylightAdjustment = tmp.toInt(&ok);
if (!ok)
daylightAdjustment = -1;
}
tmp = map.value("MobileCountryCode");
if (tmp.isValid() && tmp.type() == QVariant::String)
mcc = tmp.toString();
tmp = map.value("MobileNetworkCode");
if (tmp.isValid() && tmp.type() == QVariant::String)
mnc = tmp.toString();
}
return NetworkTimeInfo(dateTime, daylightAdjustment, offsetFromUtc, received, 0, mnc, mcc);
}
void SqliteStatement::bind(int index, const QVariant &value)
{
checkBindingIndex(index);
switch (value.type()) {
case QVariant::Bool:
case QVariant::Int:
bind(index, value.toInt());
break;
case QVariant::UInt:
case QVariant::LongLong:
case QVariant::ULongLong:
bind(index, value.toLongLong());
break;
case QVariant::Double:
bind(index, value.toDouble());
break;
case QVariant::String:
bind(index, value.toString());
break;
case QVariant::ByteArray:
bind(index, value.toByteArray());
break;
default:
sqlite3_bind_null(compiledStatement.get(), index);
}
}
/**
* @brief QBsonValue::fromVariant converts a variant value to bsonvalue or
* a default constructed QBsonValue if vaiant could not converted.
* @param variant variant to convert
* @return
*/
QBsonValue QBsonValue::fromVariant(QVariant variant)
{
switch (variant.type()) {
case QVariant::Bool:
return QBsonValue(variant.toBool());
case QVariant::ByteArray:
return QBsonValue(variant.toByteArray());
case QVariant::String:
return QBsonValue(variant.toString());
case QVariant::LongLong:
return QBsonValue(variant.toLongLong());
case QVariant::Int:
return QBsonValue(variant.toInt());
case QVariant::Double:
return QBsonValue(variant.toDouble());
case QVariant::DateTime:
return QBsonValue(variant.toDateTime());
}
if (variant.canConvert<QBsonObject>()) {
return QBsonValue(variant.value<QBsonObject>());
}
if (variant.canConvert<QBsonOid>()) {
return QBsonValue(variant.value<QBsonOid>());
}
if (variant.canConvert<QBsonArray>()) {
return QBsonValue(variant.value<QBsonArray>());
}
return QBsonValue();
}
QString toArgument(const QVariant& v)
{
switch (v.type()) {
case QVariant::Bool:
return v.toBool() ? "true" : "false";
case QVariant::Int:
case QVariant::UInt:
case QVariant::LongLong:
case QVariant::ULongLong:
return QString("%1").arg(v.toLongLong());
case QVariant::Double: {
double f = v.toDouble();
QString str;
str.sprintf("%f", f);
return str;
}
case QVariant::Date:
case QVariant::Time:
case QVariant::DateTime:
return QString("new Date(%1)").arg(v.toDateTime().toTime_t() * 1000);
case QVariant::String: {
QString s = v.toString();
s.replace("\\", "\\\\");
s.replace("\r", "\\r");
s.replace("\n", "\\n");
s.replace("\t", "\\t");
s.replace("\"", "\\\"");
return "\"" + s + "\"";
}
default:
qDebug() << "Unsupport type: " << v.type();
return "undefined";
}
}
JValue JClass::variantToValue(QVariant& v)
{
//JScope s;
switch (v.type())
{
case QVariant::Int:
case QVariant::UInt:
return JValue(v.toInt());
case QVariant::Double:
return JValue(v.toDouble());
case QVariant::LongLong:
return JValue(v.toLongLong());
case QVariant::Bool:
return JValue(v.toBool());
case QVariant::String:
{
JString str = JString(v.toString());
return JValue(str);
}
default:
if (v.canConvert<JObject>())
{
JObject obj = v.value<JObject>();
return JValue(obj);
}
else if (v.canConvert<JArray>())
{
JArray arr = v.value<JArray>();
return JValue(arr);
}
else
throw RuntimeException(QObject::tr("Unknown data type"));
}
}
/*!
Returns the 64bit integer value associated to \a name in \a section or in the
default section if the \a section name is empty.
Sets \a ok to false if no such value could be found and \a ok is not null.
*/
qint64 XmlPreferences::getInt64(const QString& name, const QString& section, bool* ok)
{
QVariant v = d->getData(name, section);
if (ok != 0)
*ok = v.isValid() && v.type() == QVariant::LongLong;
return v.toLongLong();
}
void MDCompanyIDEdit::setVariantValue(const QVariant &value)
{
if (value.toLongLong())
setText(formatCompanyID(value));
else
setText(QString());
}
/*
Format a variant value as an integer representation of a string.
This method was written to convert a QVariant of type String, but should cope with a variant of any type.
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.
*/
long QEIntegerFormatting::formatFromString( const QVariant &value ) {
// Extract the value as a long using whatever conversion the QVariant uses.
// If that fails, try extracting the value as a double using whatever conversion the QVariant uses, then cast it as a long.
//
// 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::toLongLong()
// work if the value it holds is the string 1.0001 and should it?
// If QVariant::toLongLong() 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::toLongLong() as required.
bool convertOk;
long lValue = value.toLongLong( &convertOk );
if( convertOk )
return lValue;
double dValue = value.toDouble( &convertOk );
if( convertOk )
{
lValue = (long)dValue;
return lValue;
}
return formatFailure( QString( "Warning from QEIntegerFormatting::formatFromString(). A variant could not be converted to a string." ) );
}
void MainTabPageForm::OnTorchlight2SharedStashItemAdded(QListWidgetItem* item)
{
qint32 count = ui->Torchlight2SharedStashListWidget->count();
ui->SharedStashItemCountLabel->setText(QString::number(count));
if (!mIsLoading && mStashItemsTable != NULL)
{
QVariant itemId = item->data(Qt::UserRole);
StashItem itemData = mStashItemsTable->GetStashItem(itemId.toLongLong());
if (mStashItemsTable->DeleteStashItem(itemId.toLongLong()))
{
}
}
}
// Emit signals required when input value matches or fails to match
void QELink::emitValue( QVariant value )
{
emit out( value.toBool() );
emit out( value.toLongLong() );
emit out( value.toDouble() );
emit out( value.toString() );
}
bool QgsField::convertCompatible( QVariant& v ) const
{
if ( v.isNull() )
{
v.convert( d->type );
return true;
}
if ( d->type == QVariant::Int && v.toInt() != v.toLongLong() )
{
v = QVariant( d->type );
return false;
}
//String representations of doubles in QVariant will return false to convert( QVariant::Int )
//work around this by first converting to double, and then checking whether the double is convertible to int
if ( d->type == QVariant::Int && v.canConvert( QVariant::Double ) )
{
bool ok = false;
double dbl = v.toDouble( &ok );
if ( !ok )
{
//couldn't convert to number
v = QVariant( d->type );
return false;
}
double round = qgsRound( dbl );
if ( round > INT_MAX || round < -INT_MAX )
{
//double too large to fit in int
v = QVariant( d->type );
return false;
}
v = QVariant( qRound( dbl ) );
return true;
}
if ( !v.convert( d->type ) )
{
v = QVariant( d->type );
return false;
}
if ( d->type == QVariant::Double && d->precision > 0 )
{
double s = qPow( 10, d->precision );
double d = v.toDouble() * s;
v = QVariant(( d < 0 ? ceil( d - 0.5 ) : floor( d + 0.5 ) ) / s );
return true;
}
if ( d->type == QVariant::String && d->length > 0 && v.toString().length() > d->length )
{
v = v.toString().left( d->length );
return false;
}
return true;
}
value takeCamlObj(const QObject* o) {
QVariant ans = o -> property(CAMLOBJ_PROPERTY);
if (ans.isValid())
return ans.toLongLong();
else
return 0;
}
QString FillCellHelper::displayText( const QVariant& value ) const
{
QLocale locale; // in QStyledItemDelegate this is configurable, it comes from QWidget::locale()...
QString text;
switch (value.userType()) {
case QMetaType::Float:
case QVariant::Double:
text = locale.toString(value.toReal());
break;
case QVariant::Int:
case QVariant::LongLong:
text = locale.toString(value.toLongLong());
break;
case QVariant::UInt:
case QVariant::ULongLong:
text = locale.toString(value.toULongLong());
break;
case QVariant::Date:
text = locale.toString(value.toDate(), QLocale::ShortFormat);
break;
case QVariant::Time:
text = locale.toString(value.toTime(), QLocale::ShortFormat);
break;
case QVariant::DateTime:
text = locale.toString(value.toDateTime().date(), QLocale::ShortFormat);
text += QLatin1Char(' ');
text += locale.toString(value.toDateTime().time(), QLocale::ShortFormat);
break;
default:
text = value.toString();
break;
}
return text;
}
QString QItemDelegatePrivate::valueToText(const QVariant &value, const QStyleOptionViewItemV4 &option)
{
QString text;
switch (value.userType()) {
case QMetaType::Float:
text = option.locale.toString(value.toFloat(), 'g');
break;
case QVariant::Double:
text = option.locale.toString(value.toDouble(), 'g', DBL_DIG);
break;
case QVariant::Int:
case QVariant::LongLong:
text = option.locale.toString(value.toLongLong());
break;
case QVariant::UInt:
case QVariant::ULongLong:
text = option.locale.toString(value.toULongLong());
break;
case QVariant::Date:
text = option.locale.toString(value.toDate(), QLocale::ShortFormat);
break;
case QVariant::Time:
text = option.locale.toString(value.toTime(), QLocale::ShortFormat);
break;
case QVariant::DateTime:
text = option.locale.toString(value.toDateTime().date(), QLocale::ShortFormat);
text += QLatin1Char(' ');
text += option.locale.toString(value.toDateTime().time(), QLocale::ShortFormat);
break;
default:
text = replaceNewLine(value.toString());
break;
}
return text;
}
/*!
Generate an integer given a value, using formatting defined within this class.
*/
long QCaIntegerFormatting::formatInteger( const QVariant &value ) {
// Determine the format from the variant type.
// Only the types used to store ca data are used. any other type is considered a failure.
switch( value.type() ) {
case QVariant::Double :
{
return formatFromFloating( value );
}
case QVariant::LongLong :
{
return value.toLongLong(); // No conversion requried. Stored in variant as required type
}
case QVariant::ULongLong :
{
return formatFromUnsignedInteger( value );
}
case QVariant::String :
{
return formatFromString( value );
}
default :
{
return formatFailure( QString( "Bug in QCaIntegerFormatting::formatInteger(). The QVariant type was not expected" ) );
}
}
}
cmmn::T_id cmmn::safeQVariantToIdType(const QVariant &value)
{
bool bOk = false;
auto idValue = value.toLongLong(&bOk);
throwConversionIdErrorMsg(bOk, value);
return idValue;
}
QString QgsField::displayString( const QVariant &v ) const
{
if ( v.isNull() )
{
return QgsApplication::nullRepresentation();
}
// Special treatment for numeric types if group separator is set or decimalPoint is not a dot
if ( d->type == QVariant::Double )
{
// Locales with decimal point != '.' or that require group separator: use QLocale
if ( QLocale().decimalPoint() != '.' ||
!( QLocale().numberOptions() & QLocale::NumberOption::OmitGroupSeparator ) )
{
if ( d->precision > 0 )
{
return QLocale().toString( v.toDouble(), 'f', d->precision );
}
else
{
// Precision is not set, let's guess it from the
// standard conversion to string
QString s( v.toString() );
int dotPosition( s.indexOf( '.' ) );
int precision;
if ( dotPosition < 0 )
{
precision = 0;
}
else
{
precision = s.length() - dotPosition - 1;
}
return QLocale().toString( v.toDouble(), 'f', precision );
}
}
// Default for doubles with precision
else if ( d->type == QVariant::Double && d->precision > 0 )
{
return QString::number( v.toDouble(), 'f', d->precision );
}
}
// Other numeric types than doubles
else if ( isNumeric() &&
!( QLocale().numberOptions() & QLocale::NumberOption::OmitGroupSeparator ) )
{
bool ok;
qlonglong converted( v.toLongLong( &ok ) );
if ( ok )
return QLocale().toString( converted );
}
else if ( d->typeName == QLatin1String( "json" ) || d->typeName == QLatin1String( "jsonb" ) )
{
QJsonDocument doc = QJsonDocument::fromVariant( v );
return QString::fromUtf8( doc.toJson().data() );
}
// Fallback if special rules do not apply
return v.toString();
}
void SqlQuery::bindValue(int pos, const QVariant& value)
{
int res = -1;
Q_ASSERT(_stmt);
if( _stmt ) {
switch (value.type()) {
case QVariant::Int:
case QVariant::Bool:
res = sqlite3_bind_int(_stmt, pos, value.toInt());
break;
case QVariant::Double:
res = sqlite3_bind_double(_stmt, pos, value.toDouble());
break;
case QVariant::UInt:
case QVariant::LongLong:
res = sqlite3_bind_int64(_stmt, pos, value.toLongLong());
break;
case QVariant::DateTime: {
const QDateTime dateTime = value.toDateTime();
const QString str = dateTime.toString(QLatin1String("yyyy-MM-ddThh:mm:ss.zzz"));
res = sqlite3_bind_text16(_stmt, pos, str.utf16(),
str.size() * sizeof(ushort), SQLITE_TRANSIENT);
break;
}
case QVariant::Time: {
const QTime time = value.toTime();
const QString str = time.toString(QLatin1String("hh:mm:ss.zzz"));
res = sqlite3_bind_text16(_stmt, pos, str.utf16(),
str.size() * sizeof(ushort), SQLITE_TRANSIENT);
break;
}
case QVariant::String: {
if( !value.toString().isNull() ) {
// lifetime of string == lifetime of its qvariant
const QString *str = static_cast<const QString*>(value.constData());
res = sqlite3_bind_text16(_stmt, pos, str->utf16(),
(str->size()) * sizeof(QChar), SQLITE_TRANSIENT);
} else {
res = sqlite3_bind_null(_stmt, pos);
}
break; }
case QVariant::ByteArray: {
auto ba = value.toByteArray();
res = sqlite3_bind_text(_stmt, pos, ba.constData(), ba.size(), SQLITE_TRANSIENT);
break;
}
default: {
QString str = value.toString();
// SQLITE_TRANSIENT makes sure that sqlite buffers the data
res = sqlite3_bind_text16(_stmt, pos, str.utf16(),
(str.size()) * sizeof(QChar), SQLITE_TRANSIENT);
break; }
}
}
if (res != SQLITE_OK) {
qDebug() << Q_FUNC_INFO << "ERROR" << value << res;
}
Q_ASSERT( res == SQLITE_OK );
}
static bool qVariantToIteratorInternal(DBusMessageIter *it, const QVariant &var,
const QDBusType &type)
{
switch (type.dbusType()) {
case DBUS_TYPE_BYTE:
qIterAppend( it, type, QDBusTypeHelper<uchar>::fromVariant(var) );
break;
case DBUS_TYPE_BOOLEAN:
qIterAppend( it, type, static_cast<dbus_bool_t>(var.toBool()) );
break;
case DBUS_TYPE_INT16:
qIterAppend( it, type, QDBusTypeHelper<short>::fromVariant(var) );
break;
case DBUS_TYPE_UINT16:
qIterAppend( it, type, QDBusTypeHelper<ushort>::fromVariant(var) );
break;
case DBUS_TYPE_INT32:
qIterAppend( it, type, static_cast<dbus_int32_t>(var.toInt()) );
break;
case DBUS_TYPE_UINT32:
qIterAppend( it, type, static_cast<dbus_uint32_t>(var.toUInt()) );
break;
case DBUS_TYPE_INT64:
qIterAppend( it, type, static_cast<dbus_int64_t>(var.toLongLong()) );
break;
case DBUS_TYPE_UINT64:
qIterAppend( it, type, static_cast<dbus_uint64_t>(var.toULongLong()) );
break;
case DBUS_TYPE_DOUBLE:
qIterAppend( it, type, var.toDouble() );
break;
case DBUS_TYPE_STRING:
case DBUS_TYPE_OBJECT_PATH:
case DBUS_TYPE_SIGNATURE:
qIterAppend( it, type, var.toString().toUtf8().constData() );
break;
// compound types:
case DBUS_TYPE_ARRAY:
// could be many things
return qAppendArrayToMessage( it, type.arrayElement(), var );
case DBUS_TYPE_VARIANT:
return qAppendVariantToMessage( it, type, var );
case DBUS_TYPE_STRUCT:
return qAppendStructToMessage( it, type.subTypes(), var.toList() );
case DBUS_TYPE_DICT_ENTRY:
qFatal("qVariantToIterator got a DICT_ENTRY!");
return false;
default:
qWarning("Found unknown DBus type '%s'", type.dbusSignature().constData());
return false;
}
return true;
}
Item AtomicValue::toXDM(const QVariant &value)
{
Q_ASSERT_X(value.isValid(), Q_FUNC_INFO,
"QVariants sent to Patternist must be valid.");
switch(value.userType())
{
case QVariant::Char:
/* Fallthrough. A single codepoint is a string in XQuery. */
case QVariant::String:
return AtomicString::fromValue(value.toString());
case QVariant::Url:
{
/* QUrl doesn't follow the spec properly, so we
* have to let it be an xs:string. Calling QVariant::toString()
* on a QVariant that contains a QUrl returns, surprisingly,
* an empty string. */
return AtomicString::fromValue(value.toUrl().toString());
}
case QVariant::ByteArray:
return HexBinary::fromValue(value.toByteArray());
case QVariant::Int:
/* Fallthrough. */
case QVariant::LongLong:
/* Fallthrough. */
case QVariant::UInt:
return Integer::fromValue(value.toLongLong());
case QVariant::ULongLong:
return DerivedInteger<TypeUnsignedLong>::fromValueUnchecked(value.toULongLong());
case QVariant::Bool:
return Boolean::fromValue(value.toBool());
case QVariant::Time:
return SchemaTime::fromDateTime(value.toDateTime());
case QVariant::Date:
return Date::fromDateTime(QDateTime(value.toDate(), QTime(), Qt::UTC));
case QVariant::DateTime:
return DateTime::fromDateTime(value.toDateTime());
case QMetaType::Float:
return Item(Double::fromValue(value.toFloat()));
case QVariant::Double:
return Item(Double::fromValue(value.toDouble()));
default:
{
if (value.userType() == qMetaTypeId<float>())
{
return Item(Float::fromValue(value.value<float>()));
}
else {
Q_ASSERT_X(false,
Q_FUNC_INFO,
qPrintable(QString::fromLatin1(
"QVariants of type %1 are not supported in "
"Patternist, see the documentation")
.arg(QLatin1String(value.typeName()))));
return AtomicValue::Ptr();
}
}
}
}
QString LengthItemDelegate::displayText(const QVariant& value, const QLocale&) const {
bool ok = false;
qint64 nanoseconds = value.toLongLong(&ok);
if (ok && nanoseconds > 0)
return Utilities::PrettyTimeNanosec(nanoseconds);
return QString::null;
}
