bool SyncableObject::setInitValue(const QString &property, const QVariant &value) { QString handlername = QString("initSet") + property; handlername[7] = handlername[7].toUpper(); QString methodSignature = QString("%1(%2)").arg(handlername).arg(value.typeName()); int methodIdx = metaObject()->indexOfMethod(methodSignature.toAscii().constData()); if(methodIdx < 0) { QByteArray normedMethodName = QMetaObject::normalizedSignature(methodSignature.toAscii().constData()); methodIdx = metaObject()->indexOfMethod(normedMethodName.constData()); } if(methodIdx < 0) { return false; } QGenericArgument param(value.typeName(), value.constData()); return QMetaObject::invokeMethod(this, handlername.toAscii(), param); }
NPVariant NPVariant::fromQVariant(QtNPInstance *This, const QVariant &qvariant) { Q_ASSERT(This); NPVariant npvar; npvar.type = Null; QVariant qvar(qvariant); switch(qvariant.type()) { case QVariant::Bool: npvar.value.boolValue = qvar.toBool(); npvar.type = Boolean; break; case QVariant::Int: npvar.value.intValue = qvar.toInt(); npvar.type = Int32; break; case QVariant::Double: npvar.value.doubleValue = qvar.toDouble(); npvar.type = Double; break; case QVariant::UserType: { QByteArray userType = qvariant.typeName(); if (userType.endsWith('*')) { QtNPInstance *that = new QtNPInstance; that->npp = This->npp; that->qt.object = *(QObject**)qvariant.constData(); NPClass *npclass = new NPClass(that); npclass->delete_qtnp = true; npvar.value.objectValue = NPN_CreateObject(This->npp, npclass); npvar.type = Object; } } break; default: // including QVariant::String if (!qvar.convert(QVariant::String)) break; npvar.type = String; npvar.value.stringValue = NPString::fromQString(qvar.toString()); break; } return npvar; }
void MakeArrayNode::inputsUpdated( qint64 pTimeStamp ) { NodeControlBase::inputsUpdated( pTimeStamp ); QMetaType::Type CurrType = QMetaType::Type( variant( mPinInput ).userType() ); if( CurrType == QMetaType::UnknownType ) { return; } if( CurrType != mValOutput->type() ) { mValOutput->setType( CurrType ); mValOutput->setStride( QMetaType::sizeOf( CurrType ) ); } QList<QSharedPointer<fugio::PinInterface>> PinLst = mNode->enumInputPins(); if( mValOutput->count() != PinLst.size() ) { mValOutput->setCount( PinLst.size() ); } if( PinLst.isEmpty() ) { return; } char *P = static_cast<char *>( mValOutput->array() ); for( int i = 0 ; i < PinLst.size() ; i++ ) { const QVariant V = variant( PinLst.at( i ) ); memcpy( P, V.constData(), mValOutput->stride() ); P += mValOutput->stride(); } pinUpdated( mPinOutput ); }
bool QDBusMarshaller::appendRegisteredType(const QVariant &arg) { ref.ref(); // reference up QDBusArgument self(QDBusArgumentPrivate::create(this)); return QDBusMetaType::marshall(self, arg.userType(), arg.constData()); }
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 QSpatiaLiteResult::exec() { const QVector<QVariant> values = boundValues(); d->skippedStatus = false; d->skipRow = false; d->rInf.clear(); clearValues(); setLastError(QSqlError()); int res = sqlite3_reset(d->stmt); if (res != SQLITE_OK) { setLastError(qMakeError(d->access, QCoreApplication::translate("QSpatiaLiteResult", "Unable to reset statement"), QSqlError::StatementError, res)); d->finalize(); return false; } int paramCount = sqlite3_bind_parameter_count(d->stmt); if (paramCount == values.count()) { for (int i = 0; i < paramCount; ++i) { res = SQLITE_OK; const QVariant value = values.at(i); if (value.isNull()) { res = sqlite3_bind_null(d->stmt, i + 1); } else { switch (value.type()) { case QVariant::ByteArray: { const QByteArray *ba = static_cast<const QByteArray*>(value.constData()); res = sqlite3_bind_blob(d->stmt, i + 1, ba->constData(), ba->size(), SQLITE_STATIC); break; } case QVariant::Int: res = sqlite3_bind_int(d->stmt, i + 1, value.toInt()); break; case QVariant::Double: res = sqlite3_bind_double(d->stmt, i + 1, value.toDouble()); break; case QVariant::UInt: case QVariant::LongLong: res = sqlite3_bind_int64(d->stmt, i + 1, value.toLongLong()); break; case QVariant::String: { // lifetime of string == lifetime of its qvariant const QString *str = static_cast<const QString*>(value.constData()); res = sqlite3_bind_text16(d->stmt, i + 1, str->utf16(), (str->size()) * sizeof(QChar), SQLITE_STATIC); break; } default: { QString str = value.toString(); // SQLITE_TRANSIENT makes sure that sqlite buffers the data res = sqlite3_bind_text16(d->stmt, i + 1, str.utf16(), (str.size()) * sizeof(QChar), SQLITE_TRANSIENT); break; } } } if (res != SQLITE_OK) { setLastError(qMakeError(d->access, QCoreApplication::translate("QSpatiaLiteResult", "Unable to bind parameters"), QSqlError::StatementError, res)); d->finalize(); return false; } } } else { setLastError(QSqlError(QCoreApplication::translate("QSpatiaLiteResult", "Parameter count mismatch"), QString(), QSqlError::StatementError)); return false; } d->skippedStatus = d->fetchNext(d->firstRow, 0, true); if (lastError().isValid()) { setSelect(false); setActive(false); return false; } setSelect(!d->rInf.isEmpty()); setActive(true); return true; }
int QServiceProxy::qt_metacall(QMetaObject::Call c, int id, void **a) { id = QServiceProxyBase::qt_metacall(c, id, a); if (id < 0 || !d->meta) return id; if (c == QMetaObject::InvokeMetaMethod) { const int mcount = d->meta->methodCount() - d->meta->methodOffset(); const int metaIndex = id + d->meta->methodOffset(); QMetaMethod method = d->meta->method(metaIndex); const int returnType = method.returnType(); //process arguments const QList<QByteArray> pTypes = method.parameterTypes(); const int pTypesCount = pTypes.count(); QVariantList args ; if (pTypesCount > 10) { qWarning() << "Cannot call" << method.methodSignature() << ". More than 10 parameter."; return id; } for (int i=0; i < pTypesCount; i++) { const QByteArray& t = pTypes[i]; int variantType = QMetaType::type(t); if (variantType == QMetaType::QVariant) { //ignore whether QVariant is declared as metatype args << *reinterpret_cast<const QVariant(*)>(a[i+1]); } else if ( variantType == 0 ){ qWarning("%s: argument %s has unknown type. Use qRegisterMetaType to register it.", method.methodSignature().constData(), t.data()); return id; } else { args << QVariant(variantType, a[i+1]); } } if (returnType == QMetaType::Void) { qServiceLog() << "event" << "nonblocking void call" << "method" << QString::fromLatin1(method.methodSignature()) << "endpoint" << d->endPoint->objectName(); d->endPoint->invokeRemote(d->localToRemote[metaIndex], args, returnType); } else { //TODO: invokeRemote() parameter list needs review qServiceLog() << "event" << "nonblocking call" << "method" << QString::fromLatin1(method.methodSignature()) << "endpoint" << d->endPoint->objectName(); QVariant result = d->endPoint->invokeRemote(d->localToRemote[metaIndex], args, returnType); if (result.type() != QVariant::Invalid){ if (returnType != QMetaType::QVariant) { QByteArray buffer; QDataStream stream(&buffer, QIODevice::ReadWrite); QMetaType::save(stream, returnType, result.constData()); stream.device()->seek(0); QMetaType::load(stream, returnType, a[0]); } else { if (a[0]) *reinterpret_cast< QVariant*>(a[0]) = result; } } } id-=mcount; } else if ( c == QMetaObject::ReadProperty || c == QMetaObject::WriteProperty || c == QMetaObject::ResetProperty ) { const int pCount = d->meta->propertyCount() - d->meta->propertyOffset(); const int metaIndex = id + d->meta->propertyOffset(); QMetaProperty property = d->meta->property(metaIndex); if (property.isValid()) { int pType = property.userType(); QVariant arg; if ( c == QMetaObject::WriteProperty ) { qServiceLog() << "event" << "property write" << "property" << property.name() << "endpoint" << d->endPoint->objectName(); if (pType == QMetaType::QVariant) arg = *reinterpret_cast<const QVariant(*)>(a[0]); else if (pType == 0) { qWarning("%s: property %s has unkown type", property.name(), property.typeName()); return id; } else { arg = QVariant(pType, a[0]); } } QVariant result; if (c == QMetaObject::ReadProperty) { qServiceLog() << "event" << "property read" << "property" << property.name() << "endpoint" << d->endPoint->objectName(); result = d->endPoint->invokeRemoteProperty(metaIndex, arg, pType, c); //wrap result for client if (pType != 0) { QByteArray buffer; QDataStream stream(&buffer, QIODevice::ReadWrite); QMetaType::save(stream, pType, result.constData()); stream.device()->seek(0); QMetaType::load(stream, pType, a[0]); } else { if (a[0]) *reinterpret_cast< QVariant*>(a[0]) = result; } } else { d->endPoint->invokeRemoteProperty(metaIndex, arg, pType, c); } } id-=pCount; } else if ( c == QMetaObject::QueryPropertyDesignable || c == QMetaObject::QueryPropertyScriptable || c == QMetaObject::QueryPropertyStored || c == QMetaObject::QueryPropertyEditable || c == QMetaObject::QueryPropertyUser ) { //Nothing to do? //These values are part of the transferred meta object already } else { //TODO qWarning() << "MetaCall type" << c << "not yet handled"; } return id; }
bool lessThan( const QVariant & a, const QVariant & b ) { return Data::lessThan( a.userType(), a.constData(), b.userType(), b.constData() ); }
void placeCall(const QString &service, const QString &path, const QString &interface, const QString &member, int argc, const char *const *argv) { QDBusInterfacePtr iface(*connection, service, path, interface); if (!iface->isValid()) { QDBusError err(iface->lastError()); fprintf(stderr, "Interface '%s' not available in object %s at %s:\n%s (%s)\n", qPrintable(interface), qPrintable(path), qPrintable(service), qPrintable(err.name()), qPrintable(err.message())); exit(1); } const QMetaObject *mo = iface->metaObject(); QByteArray match = member.toLatin1(); match += '('; int midx = -1; for (int i = mo->methodOffset(); i < mo->methodCount(); ++i) { QMetaMethod mm = mo->method(i); QByteArray signature = mm.signature(); if (signature.startsWith(match)) { midx = i; break; } } if (midx == -1) { fprintf(stderr, "Cannot find '%s.%s' in object %s at %s\n", qPrintable(interface), qPrintable(member), qPrintable(path), qPrintable(service)); exit(1); } QMetaMethod mm = mo->method(midx); QList<QByteArray> types = mm.parameterTypes(); QVariantList params; for (int i = 0; argc && i < types.count(); ++i) { int id = QVariant::nameToType(types.at(i)); if ((id == QVariant::UserType || id == QVariant::Map) && types.at(i) != "QVariant") { fprintf(stderr, "Sorry, can't pass arg of type %s yet\n", types.at(i).constData()); exit(1); } if (id == QVariant::UserType) id = QMetaType::type(types.at(i)); Q_ASSERT(id); QVariant p; if ((id == QVariant::List || id == QVariant::StringList) && QLatin1String("(") == argv[0]) p = readList(argc, argv); else p = QString::fromLocal8Bit(argv[0]); if (id < int(QVariant::UserType)) { // avoid calling it for QVariant p.convert( QVariant::Type(id) ); if (p.type() == QVariant::Invalid) { fprintf(stderr, "Could not convert '%s' to type '%s'.\n", argv[0], types.at(i).constData()); exit(1); } } else if (types.at(i) == "QVariant") { QVariant tmp(id, p.constData()); p = tmp; } params += p; --argc; ++argv; } if (params.count() != types.count()) { fprintf(stderr, "Invalid number of parameters\n"); exit(1); } QDBusMessage reply = iface->callWithArgs(member, params, QDBusInterface::NoUseEventLoop); if (reply.type() == QDBusMessage::ErrorMessage) { QDBusError err = reply; printf("Error: %s\n%s\n", qPrintable(err.name()), qPrintable(err.message())); exit(2); } else if (reply.type() != QDBusMessage::ReplyMessage) { fprintf(stderr, "Invalid reply type %d\n", int(reply.type())); exit(1); } foreach (QVariant v, reply) { if (v.userType() == QVariant::StringList) { foreach (QString s, v.toStringList()) printf("%s\n", qPrintable(s)); } else { if (v.userType() == qMetaTypeId<QVariant>()) v = qvariant_cast<QVariant>(v); printf("%s\n", qPrintable(v.toString())); } } exit(0); }
int QServiceProxy::qt_metacall(QMetaObject::Call c, int id, void **a) { #ifdef QT_SFW_ENDPOINT_DEBUG qDebug() << "QServiceProxy::qt_metacall: Start"; #endif id = QObject::qt_metacall(c, id, a); if (id < 0 || !d->meta) return id; //Let the object endpoint monitor keep track of the usage... #ifdef Q_OS_SYMBIAN ObjectEndPointMonitor aOem(d->endPoint); #endif //End Q_OS_SYMBIAN if(localSignals.at(id)){ QMetaObject::activate(this, d->meta, id, a); return id; } if (c == QMetaObject::InvokeMetaMethod) { const int mcount = d->meta->methodCount() - d->meta->methodOffset(); const int metaIndex = id + d->meta->methodOffset(); QMetaMethod method = d->meta->method(metaIndex); const int returnType = QMetaType::type(method.typeName()); //process arguments const QList<QByteArray> pTypes = method.parameterTypes(); const int pTypesCount = pTypes.count(); QVariantList args ; if (pTypesCount > 10) { qWarning() << "Cannot call" << method.signature() << ". More than 10 parameter."; return id; } for (int i=0; i < pTypesCount; i++) { const QByteArray& t = pTypes[i]; int variantType = QVariant::nameToType(t); if (variantType == QVariant::UserType) variantType = QMetaType::type(t); if (t == "QVariant") { //ignore whether QVariant is declared as metatype args << *reinterpret_cast<const QVariant(*)>(a[i+1]); } else if ( variantType == 0 ){ qWarning("%s: argument %s has unknown type. Use qRegisterMetaType to register it.", method.signature(), t.data()); return id; } else { args << QVariant(variantType, a[i+1]); } } //QVariant looks the same as Void type. we need to distinguish them if (returnType == QMetaType::Void && strcmp(method.typeName(),"QVariant") ) { d->endPoint->invokeRemote(metaIndex, args, returnType); } else { //TODO: ugly but works //add +1 if we have a variant return type to avoid triggering of void //code path //invokeRemote() parameter list needs review QVariant result = d->endPoint->invokeRemote(metaIndex, args, returnType==0 ? returnType+1: returnType); if(result.type() != QVariant::Invalid){ if (returnType != 0 && strcmp(method.typeName(),"QVariant")) { QByteArray buffer; QDataStream stream(&buffer, QIODevice::ReadWrite); QMetaType::save(stream, returnType, result.constData()); stream.device()->seek(0); QMetaType::load(stream, returnType, a[0]); } else { if (a[0]) *reinterpret_cast< QVariant*>(a[0]) = result; } } } id-=mcount; } else if ( c == QMetaObject::ReadProperty || c == QMetaObject::WriteProperty || c == QMetaObject::ResetProperty ) { const int pCount = d->meta->propertyCount() - d->meta->propertyOffset(); const int metaIndex = id + d->meta->propertyOffset(); QMetaProperty property = d->meta->property(metaIndex); if (property.isValid()) { int pType = property.type(); if (pType == QVariant::UserType) pType = QMetaType::type(property.typeName()); QVariant arg; if ( c == QMetaObject::WriteProperty ) { if (pType == QVariant::Invalid && QByteArray(property.typeName()) == "QVariant") arg = *reinterpret_cast<const QVariant(*)>(a[0]); else if (pType == 0) { qWarning("%s: property %s has unknown type", property.name(), property.typeName()); return id; } else { arg = QVariant(pType, a[0]); } } QVariant result; if (c == QMetaObject::ReadProperty) { result = d->endPoint->invokeRemoteProperty(metaIndex, arg, pType, c); //wrap result for client if (pType != 0) { QByteArray buffer; QDataStream stream(&buffer, QIODevice::ReadWrite); QMetaType::save(stream, pType, result.constData()); stream.device()->seek(0); QMetaType::load(stream, pType, a[0]); } else { if (a[0]) *reinterpret_cast< QVariant*>(a[0]) = result; } } else { d->endPoint->invokeRemoteProperty(metaIndex, arg, pType, c); } } id-=pCount; } else if ( c == QMetaObject::QueryPropertyDesignable || c == QMetaObject::QueryPropertyScriptable || c == QMetaObject::QueryPropertyStored || c == QMetaObject::QueryPropertyEditable || c == QMetaObject::QueryPropertyUser ) { //Nothing to do? //These values are part of the transferred meta object already } else { //TODO qWarning() << "MetaCall type" << c << "not yet handled"; } #ifdef QT_SFW_ENDPOINT_DEBUG qDebug() << "QServiceProxy::qt_metacall: End"; #endif return id; }
bool QSymSQLResult::exec() { if (d->prepareCalled == false) { setLastError(qMakeError(d->access, QCoreApplication::translate("QSymSQLResult", "Statement is not prepared"), QSqlError::StatementError, KErrGeneral)); return false; } const QVector<QVariant> values = boundValues(); d->skippedStatus = false; d->skipRow = false; setAt(QSql::BeforeFirstRow); setLastError(QSqlError()); int res = d->stmt.Reset(); if (res != KErrNone) { setLastError(qMakeError(d->access, QCoreApplication::translate("QSymSQLResult", "Unable to reset statement"), QSqlError::StatementError, res)); d->finalize(); return false; } TPtrC tmp; TInt paramCount = 0; while (d->stmt.ParamName(paramCount, tmp) == KErrNone) paramCount++; if (paramCount == values.count()) { for (int i = 0; i < paramCount; ++i) { res = KErrNone; const QVariant value = values.at(i); if (value.isNull()) { res = d->stmt.BindNull(i); //replaced i + 1 with i } else { switch (value.type()) { case QVariant::ByteArray: { const QByteArray *ba = static_cast<const QByteArray*>(value.constData()); TPtrC8 data(reinterpret_cast<const TUint8 *>(ba->constData()), ba->length()); res = d->stmt.BindBinary(i, data); //replaced i + 1 with i break; } case QVariant::Int: res = d->stmt.BindInt(i, value.toInt()); //replaced i + 1 with i break; case QVariant::Double: res = d->stmt.BindReal(i, value.toDouble()); //replaced i + 1 with i break; case QVariant::UInt: case QVariant::LongLong: res = d->stmt.BindReal(i, value.toLongLong()); //replaced i + 1 with i break; case QVariant::String: { // lifetime of string == lifetime of its qvariant const QString *str = static_cast<const QString*>(value.constData()); res = d->stmt.BindText(i, qt_QString2TPtrC(*str)); // replaced i + 1 with i break; } default: { QString str = value.toString(); res = d->stmt.BindText(i, qt_QString2TPtrC(str)); //replaced i + 1 with i break; } } } if (res != KErrNone) { setLastError(qMakeError(d->access, QCoreApplication::translate("QSymSQLResult", "Unable to bind parameters"), QSqlError::StatementError, res)); d->finalize(); return false; } } } else { setLastError(QSqlError(QCoreApplication::translate("QSymSQLResult", "Parameter count mismatch"), QString(), QSqlError::StatementError)); return false; } d->skippedStatus = d->fetchNext(true); if (lastError().isValid()) { setSelect(false); setActive(false); return false; } if (d->stmt.ColumnCount() > 0) { //If there is something, it has to be select setSelect(true); } else { //If there isn't it might be just bad query, let's check manually whether we can find SELECT QString query = this->lastQuery(); query = query.trimmed(); query = query.toLower(); //Just check whether there is one in the beginning, don't know if this is enough //Comments should be at the end of line if those are passed //For some reason, case insensitive indexOf didn't work for me if (query.indexOf(QLatin1String("select")) == 0) { setSelect(true); } else { setSelect(false); } } setActive(true); return true; }
bool SyncableObject::setInitValue(const QString &property, const QVariant &value) { QString handlername = QString("initSet") + property; handlername[7] = handlername[7].toUpper(); QGenericArgument param(value.typeName(), value.constData()); return QMetaObject::invokeMethod(this, handlername.toAscii(), param); }
void QQmlValueType::setValue(const QVariant &value) { Q_ASSERT(typeId == value.userType()); metaType.destruct(gadgetPtr); metaType.construct(gadgetPtr, value.constData()); }
static qint32 castQVariantToInt32(const QVariant &variant) { return *reinterpret_cast<const qint32 *>(variant.constData()); }
/*! This virtual function returns the linear interpolation between variants \a from and \a to, at \a progress, usually a value between 0 and 1. You can reimplement this function in a subclass of QVariantAnimation to provide your own interpolation algorithm. Note that in order for the interpolation to work with a QEasingCurve that return a value smaller than 0 or larger than 1 (such as QEasingCurve::InBack) you should make sure that it can extrapolate. If the semantic of the datatype does not allow extrapolation this function should handle that gracefully. You should call the QVariantAnimation implementation of this function if you want your class to handle the types already supported by Qt (see class QVariantAnimation description for a list of supported types). \sa QEasingCurve */ QVariant QVariantAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const { return d_func()->interpolator(from.constData(), to.constData(), progress); }
bool equals( const QVariant & a, const QVariant & b ) { return ( a == b ) || Data::equals( a.userType(), a.constData(), b.userType(), b.constData() ); }
bool QDeclarativePropertyPrivate::write(QObject *object, const QDeclarativePropertyCache::Data &property, const QVariant &value, QDeclarativeContextData *context, WriteFlags flags) { int coreIdx = property.coreIndex; int status = -1; //for dbus if (property.flags & QDeclarativePropertyCache::Data::IsEnumType) { QMetaProperty prop = object->metaObject()->property(property.coreIndex); QVariant v = value; // Enum values come through the script engine as doubles if (value.userType() == QVariant::Double) { double integral; double fractional = modf(value.toDouble(), &integral); if (qFuzzyIsNull(fractional)) v.convert(QVariant::Int); } return writeEnumProperty(prop, coreIdx, object, v, flags); } int propertyType = property.propType; int variantType = value.userType(); QDeclarativeEnginePrivate *enginePriv = QDeclarativeEnginePrivate::get(context); if (propertyType == QVariant::Url) { QUrl u; bool found = false; if (variantType == QVariant::Url) { u = value.toUrl(); found = true; } else if (variantType == QVariant::ByteArray) { u = QUrl(QString::fromUtf8(value.toByteArray())); found = true; } else if (variantType == QVariant::String) { u = QUrl(value.toString()); found = true; } if (!found) return false; if (context && u.isRelative() && !u.isEmpty()) u = context->resolvedUrl(u); int status = -1; void *argv[] = { &u, 0, &status, &flags }; QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, argv); } else if (variantType == propertyType) { void *a[] = { (void *)value.constData(), 0, &status, &flags }; QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, a); } else if (qMetaTypeId<QVariant>() == propertyType) { void *a[] = { (void *)&value, 0, &status, &flags }; QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, a); } else if (property.flags & QDeclarativePropertyCache::Data::IsQObjectDerived) { const QMetaObject *valMo = rawMetaObjectForType(enginePriv, value.userType()); if (!valMo) return false; QObject *o = *(QObject **)value.constData(); const QMetaObject *propMo = rawMetaObjectForType(enginePriv, propertyType); if (o) valMo = o->metaObject(); if (canConvert(valMo, propMo)) { void *args[] = { &o, 0, &status, &flags }; QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, args); } else if (!o && canConvert(propMo, valMo)) { // In the case of a null QObject, we assign the null if there is // any change that the null variant type could be up or down cast to // the property type. void *args[] = { &o, 0, &status, &flags }; QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, args); } else { return false; } } else if (property.flags & QDeclarativePropertyCache::Data::IsQList) { const QMetaObject *listType = 0; if (enginePriv) { listType = enginePriv->rawMetaObjectForType(enginePriv->listType(property.propType)); } else { QDeclarativeType *type = QDeclarativeMetaType::qmlType(QDeclarativeMetaType::listType(property.propType)); if (!type) return false; listType = type->baseMetaObject(); } if (!listType) return false; QDeclarativeListProperty<void> prop; void *args[] = { &prop, 0 }; QMetaObject::metacall(object, QMetaObject::ReadProperty, coreIdx, args); if (!prop.clear) return false; prop.clear(&prop); if (value.userType() == qMetaTypeId<QList<QObject *> >()) { const QList<QObject *> &list = qvariant_cast<QList<QObject *> >(value); for (int ii = 0; ii < list.count(); ++ii) { QObject *o = list.at(ii); if (o && !canConvert(o->metaObject(), listType)) o = 0; prop.append(&prop, (void *)o); } } else { QObject *o = enginePriv?enginePriv->toQObject(value):QDeclarativeMetaType::toQObject(value); if (o && !canConvert(o->metaObject(), listType)) o = 0; prop.append(&prop, (void *)o); } } else { Q_ASSERT(variantType != propertyType); QVariant v = value; if (v.convert((QVariant::Type)propertyType)) { void *a[] = { (void *)v.constData(), 0, &status, &flags}; QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, a); } else if ((uint)propertyType >= QVariant::UserType && variantType == QVariant::String) { QDeclarativeMetaType::StringConverter con = QDeclarativeMetaType::customStringConverter(propertyType); if (!con) return false; QVariant v = con(value.toString()); if (v.userType() == propertyType) { void *a[] = { (void *)v.constData(), 0, &status, &flags}; QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, a); } } else if (variantType == QVariant::String) { bool ok = false; QVariant v = QDeclarativeStringConverters::variantFromString(value.toString(), propertyType, &ok); if (!ok) return false; void *a[] = { (void *)v.constData(), 0, &status, &flags}; QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, a); } else { return false; } } return true; }
void SqlQuery::bindValue(int pos, const QVariant &value) { qCDebug(lcSql) << "SQL bind" << pos << value; int res = -1; if (!_stmt) { ASSERT(false); return; } 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: case QVariant::ULongLong: 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) { qCWarning(lcSql) << "ERROR binding SQL value:" << value << "error:" << res; } ASSERT(res == SQLITE_OK); }