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);
}
