QDBusArgument QDBusDemarshaller::duplicate()
{
QDBusDemarshaller *d = new QDBusDemarshaller;
d->iterator = iterator;
d->message = q_dbus_message_ref(message);
q_dbus_message_iter_next(&iterator);
return QDBusArgumentPrivate::create(d);
}
inline QDBusVariant QDBusDemarshaller::toVariant()
{
QDBusDemarshaller sub;
sub.message = q_dbus_message_ref(message);
q_dbus_message_iter_recurse(&iterator, &sub.iterator);
q_dbus_message_iter_next(&iterator);
return QDBusVariant( sub.toVariantInternal() );
}
QDBusDemarshaller *QDBusDemarshaller::beginCommon()
{
QDBusDemarshaller *d = new QDBusDemarshaller;
d->parent = this;
d->message = q_dbus_message_ref(message);
// recurse
q_dbus_message_iter_recurse(&iterator, &d->iterator);
q_dbus_message_iter_next(&iterator);
return d;
}
/*!
Constructs a new DBus message representing an error reply message,
with the given \a name and \a msg.
*/
QDBusMessage QDBusMessage::createErrorReply(const QString name, const QString &msg) const
{
QDBusMessage reply = QDBusMessage::createError(name, msg);
if (d_ptr->msg)
reply.d_ptr->reply = q_dbus_message_ref(d_ptr->msg);
if (d_ptr->localMessage) {
reply.d_ptr->localMessage = true;
d_ptr->localReply = new QDBusMessage(reply); // keep an internal copy
}
// the reply must have a msg or be a local-loop optimization
Q_ASSERT(reply.d_ptr->reply || reply.d_ptr->localMessage);
return reply;
}
/*!
\internal
Constructs a QDBusMessage by parsing the given DBusMessage object.
*/
QDBusMessage QDBusMessagePrivate::fromDBusMessage(DBusMessage *dmsg, QDBusConnection::ConnectionCapabilities capabilities)
{
QDBusMessage message;
if (!dmsg)
return message;
message.d_ptr->type = q_dbus_message_get_type(dmsg);
message.d_ptr->path = QString::fromUtf8(q_dbus_message_get_path(dmsg));
message.d_ptr->interface = QString::fromUtf8(q_dbus_message_get_interface(dmsg));
message.d_ptr->name = message.d_ptr->type == DBUS_MESSAGE_TYPE_ERROR ?
QString::fromUtf8(q_dbus_message_get_error_name(dmsg)) :
QString::fromUtf8(q_dbus_message_get_member(dmsg));
message.d_ptr->service = QString::fromUtf8(q_dbus_message_get_sender(dmsg));
message.d_ptr->signature = QString::fromUtf8(q_dbus_message_get_signature(dmsg));
message.d_ptr->msg = q_dbus_message_ref(dmsg);
QDBusDemarshaller demarshaller(capabilities);
demarshaller.message = q_dbus_message_ref(dmsg);
if (q_dbus_message_iter_init(demarshaller.message, &demarshaller.iterator))
while (!demarshaller.atEnd())
message << demarshaller.toVariantInternal();
return message;
}
/*!
\fn QDBusMessage QDBusMessage::createReply(const QList<QVariant> &arguments) const
Constructs a new DBus message representing a reply, with the given
\a arguments.
*/
QDBusMessage QDBusMessage::createReply(const QVariantList &arguments) const
{
QDBusMessage reply;
reply.setArguments(arguments);
reply.d_ptr->type = DBUS_MESSAGE_TYPE_METHOD_RETURN;
if (d_ptr->msg)
reply.d_ptr->reply = q_dbus_message_ref(d_ptr->msg);
if (d_ptr->localMessage) {
reply.d_ptr->localMessage = true;
d_ptr->localReply = new QDBusMessage(reply); // keep an internal copy
}
// the reply must have a msg or be a local-loop optimization
Q_ASSERT(reply.d_ptr->reply || reply.d_ptr->localMessage);
return reply;
}
bool QDBusArgumentPrivate::checkReadAndDetach(QDBusArgumentPrivate *&d)
{
if (!checkRead(d))
return false; // don't bother
if (d->ref.load() == 1)
return true; // no need to detach
QDBusDemarshaller *dd = new QDBusDemarshaller(d->capabilities);
dd->message = q_dbus_message_ref(d->message);
dd->iterator = static_cast<QDBusDemarshaller*>(d)->iterator;
if (!d->ref.deref())
delete d;
d = dd;
return true;
}
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;
}
