QDBusMarshaller Class Reference

#include <qdbusargument_p.h>

Inheritance diagram for QDBusMarshaller:

Public Functions
void	append (uchar arg)
void	append (bool arg)
void	append (short arg)
void	append (ushort arg)
void	append (int arg)
void	append (uint arg)
void	append (qlonglong arg)
void	append (qulonglong arg)
void	append (double arg)
void	append (const QString &arg)
void	append (const QDBusObjectPath &arg)
void	append (const QDBusSignature &arg)
void	append (const QDBusUnixFileDescriptor &arg)
void	append (const QStringList &arg)
void	append (const QByteArray &arg)
bool	append (const QDBusVariant &arg)
bool	appendCrossMarshalling (QDBusDemarshaller *arg)
bool	appendRegisteredType (const QVariant &arg)
bool	appendVariantInternal (const QVariant &arg)
QDBusMarshaller *	beginArray (int id)
QDBusMarshaller *	beginCommon (int code, const char *signature)
QDBusMarshaller *	beginMap (int kid, int vid)
QDBusMarshaller *	beginMapEntry ()
QDBusMarshaller *	beginStructure ()
void	close ()
QString	currentSignature ()
QDBusMarshaller *	endArray ()
QDBusMarshaller *	endCommon ()
QDBusMarshaller *	endMap ()
QDBusMarshaller *	endMapEntry ()
QDBusMarshaller *	endStructure ()
void	error (const QString &message)
void	open (QDBusMarshaller &sub, int code, const char *signature)
	QDBusMarshaller (int flags)
	~QDBusMarshaller ()
Public Functions inherited from QDBusArgumentPrivate
QDBusDemarshaller *	demarshaller ()
QDBusMarshaller *	marshaller ()
	QDBusArgumentPrivate (int flags=0)
	~QDBusArgumentPrivate ()

Public Variables
QByteArray *	ba
char	closeCode
QString	errorString
DBusMessageIter	iterator
bool	ok
QDBusMarshaller *	parent
Public Variables inherited from QDBusArgumentPrivate
int	capabilities
enum QDBusArgumentPrivate::Direction	direction
DBusMessage *	message
QAtomicInt	ref

Additional Inherited Members
Public Types inherited from QDBusArgumentPrivate
enum	Direction { Marshalling, Demarshalling }
Static Public Functions inherited from QDBusArgumentPrivate
static bool	checkRead (QDBusArgumentPrivate *d)
static bool	checkReadAndDetach (QDBusArgumentPrivate *&d)
static bool	checkWrite (QDBusArgumentPrivate *&d)
static QDBusArgument	create (QDBusArgumentPrivate *d)
static QByteArray	createSignature (int id)
static QDBusArgumentPrivate *	d (QDBusArgument &q)

Detailed Description

Definition at line 105 of file qdbusargument_p.h.

Constructors and Destructors

QDBusMarshaller()

QDBusMarshaller::QDBusMarshaller ( int  flags )

inline

Definition at line 108 of file qdbusargument_p.h.

Referenced by beginCommon().

                               : QDBusArgumentPrivate(flags), parent(0), ba(0), closeCode(0), ok(true)
    { direction = Marshalling; }

~QDBusMarshaller()

QDBusMarshaller::~QDBusMarshaller

(

)

Definition at line 59 of file qdbusmarshaller.cpp.

{
    close();
}

Functions

append() [1/16]

void QDBusMarshaller::append ( uchar  arg )

inline

Definition at line 71 of file qdbusmarshaller.cpp.

Referenced by append(), appendVariantInternal(), QDBusArgument::operator<<(), and QDBusMessagePrivate::toDBusMessage().

{
    qIterAppend(&iterator, ba, DBUS_TYPE_BYTE, &arg);
}

append() [2/16]

void QDBusMarshaller::append ( bool  arg )

inline

Definition at line 76 of file qdbusmarshaller.cpp.

{
    dbus_bool_t cast = arg;
    qIterAppend(&iterator, ba, DBUS_TYPE_BOOLEAN, &cast);
}

append() [3/16]

void QDBusMarshaller::append ( short  arg )

inline

Definition at line 82 of file qdbusmarshaller.cpp.

{
    qIterAppend(&iterator, ba, DBUS_TYPE_INT16, &arg);
}

append() [4/16]

void QDBusMarshaller::append ( ushort  arg )

inline

Definition at line 87 of file qdbusmarshaller.cpp.

{
    qIterAppend(&iterator, ba, DBUS_TYPE_UINT16, &arg);
}

append() [5/16]

void QDBusMarshaller::append ( int  arg )

inline

Definition at line 92 of file qdbusmarshaller.cpp.

{
    qIterAppend(&iterator, ba, DBUS_TYPE_INT32, &arg);
}

append() [6/16]

void QDBusMarshaller::append ( uint  arg )

inline

Definition at line 97 of file qdbusmarshaller.cpp.

{
    qIterAppend(&iterator, ba, DBUS_TYPE_UINT32, &arg);
}

append() [7/16]

void QDBusMarshaller::append ( qlonglong  arg )

inline

Definition at line 102 of file qdbusmarshaller.cpp.

{
    qIterAppend(&iterator, ba, DBUS_TYPE_INT64, &arg);
}

append() [8/16]

void QDBusMarshaller::append ( qulonglong  arg )

inline

Definition at line 107 of file qdbusmarshaller.cpp.

{
    qIterAppend(&iterator, ba, DBUS_TYPE_UINT64, &arg);
}

append() [9/16]

void QDBusMarshaller::append ( double  arg )

inline

Definition at line 112 of file qdbusmarshaller.cpp.

{
    qIterAppend(&iterator, ba, DBUS_TYPE_DOUBLE, &arg);
}

append() [10/16]

void QDBusMarshaller::append

(

const QString &

arg

)

Definition at line 117 of file qdbusmarshaller.cpp.

{
    QByteArray data = arg.toUtf8();
    const char *cdata = data.constData();
    qIterAppend(&iterator, ba, DBUS_TYPE_STRING, &cdata);
}

append() [11/16]

void QDBusMarshaller::append ( const QDBusObjectPath &  arg )

inline

Definition at line 124 of file qdbusmarshaller.cpp.

{
    QByteArray data = arg.path().toUtf8();
    if (!ba && data.isEmpty())
        error(QLatin1String("Invalid object path passed in arguments"));
    const char *cdata = data.constData();
    qIterAppend(&iterator, ba, DBUS_TYPE_OBJECT_PATH, &cdata);
}

append() [12/16]

void QDBusMarshaller::append ( const QDBusSignature &  arg )

inline

Definition at line 133 of file qdbusmarshaller.cpp.

{
    QByteArray data = arg.signature().toUtf8();
    if (!ba && data.isEmpty())
        error(QLatin1String("Invalid signature passed in arguments"));
    const char *cdata = data.constData();
    qIterAppend(&iterator, ba, DBUS_TYPE_SIGNATURE, &cdata);
}

append() [13/16]

void QDBusMarshaller::append ( const QDBusUnixFileDescriptor &  arg )

inline

Definition at line 142 of file qdbusmarshaller.cpp.

{
    int fd = arg.fileDescriptor();
    if (!ba && fd == -1) {
        error(QLatin1String("Invalid file descriptor passed in arguments"));
    } else {
        qIterAppend(&iterator, ba, DBUS_TYPE_UNIX_FD, &fd);
    }
}

append() [14/16]

void QDBusMarshaller::append ( const QStringList &  arg )

inline

Definition at line 210 of file qdbusmarshaller.cpp.

{
    if (ba) {
        *ba += DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING;
        return;
    }

    QDBusMarshaller sub(capabilities);
    open(sub, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING);
    QStringList::ConstIterator it = arg.constBegin();
    QStringList::ConstIterator end = arg.constEnd();
    for ( ; it != end; ++it)
        sub.append(*it);
    // don't call sub.close(): it auto-closes
}

append() [15/16]

void QDBusMarshaller::append ( const QByteArray &  arg )

inline

Definition at line 152 of file qdbusmarshaller.cpp.

{
    if (ba) {
        *ba += DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING;
        return;
    }

    const char* cdata = arg.constData();
    DBusMessageIter subiterator;
    q_dbus_message_iter_open_container(&iterator, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING,
                                     &subiterator);
    q_dbus_message_iter_append_fixed_array(&subiterator, DBUS_TYPE_BYTE, &cdata, arg.length());
    q_dbus_message_iter_close_container(&iterator, &subiterator);
}

append() [16/16]

bool QDBusMarshaller::append ( const QDBusVariant &  arg )

inline

Definition at line 167 of file qdbusmarshaller.cpp.

{
    if (ba) {
        *ba += DBUS_TYPE_VARIANT_AS_STRING;
        return true;
    }

    const QVariant &value = arg.variant();
    QVariant::Type id = QVariant::Type(value.userType());
    if (id == QVariant::Invalid) {
        qWarning("QDBusMarshaller: cannot add a null QDBusVariant");
        error(QLatin1String("Variant containing QVariant::Invalid passed in arguments"));
        return false;
    }

    QByteArray tmpSignature;
    const char *signature = 0;
    if (int(id) == QDBusMetaTypeId::argument) {
        // take the signature from the QDBusArgument object we're marshalling
        tmpSignature =
            qvariant_cast<QDBusArgument>(value).currentSignature().toLatin1();
        signature = tmpSignature.constData();
    } else {
        // take the signatuer from the metatype we're marshalling
        signature = QDBusMetaType::typeToSignature(id);
    }
    if (!signature) {
        qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. "
                 "Use qDBusRegisterMetaType to register it",
                 QVariant::typeToName( id ), id);
        error(QString::fromLatin1("Unregistered type %1 passed in arguments")
              .arg(QLatin1String(QVariant::typeToName(id))));
        return false;
    }

    QDBusMarshaller sub(capabilities);
    open(sub, DBUS_TYPE_VARIANT, signature);
    bool isOk = sub.appendVariantInternal(value);
    // don't call sub.close(): it auto-closes

    return isOk;
}

appendCrossMarshalling()

bool QDBusMarshaller::appendCrossMarshalling

(

QDBusDemarshaller *

arg

)

Definition at line 511 of file qdbusmarshaller.cpp.

Referenced by appendCrossMarshalling(), and appendVariantInternal().

{
    int code = q_dbus_message_iter_get_arg_type(&demarshaller->iterator);
    if (QDBusUtil::isValidBasicType(code)) {
        // easy: just append
        // do exactly like the D-BUS docs suggest
        // (see apidocs for q_dbus_message_iter_get_basic)

        qlonglong value;
        q_dbus_message_iter_get_basic(&demarshaller->iterator, &value);
        q_dbus_message_iter_next(&demarshaller->iterator);
        q_dbus_message_iter_append_basic(&iterator, code, &value);
        return true;
    }

    if (code == DBUS_TYPE_ARRAY) {
        int element = q_dbus_message_iter_get_element_type(&demarshaller->iterator);
        if (QDBusUtil::isValidFixedType(element) && element != DBUS_TYPE_UNIX_FD) {
            // another optimization: fixed size arrays
            // code is exactly like QDBusDemarshaller::toByteArray
            DBusMessageIter sub;
            q_dbus_message_iter_recurse(&demarshaller->iterator, &sub);
            q_dbus_message_iter_next(&demarshaller->iterator);
            int len;
            void* data;
            q_dbus_message_iter_get_fixed_array(&sub,&data,&len);

            char signature[2] = { char(element), 0 };
            q_dbus_message_iter_open_container(&iterator, DBUS_TYPE_ARRAY, signature, &sub);
            q_dbus_message_iter_append_fixed_array(&sub, element, &data, len);
            q_dbus_message_iter_close_container(&iterator, &sub);

            return true;
        }
    }

    // We have to recurse
    QDBusDemarshaller *drecursed = demarshaller->beginCommon();

    QDBusMarshaller mrecursed(capabilities);  // create on the stack makes it autoclose
    QByteArray subSignature;
    const char *sig = 0;
    if (code == DBUS_TYPE_VARIANT || code == DBUS_TYPE_ARRAY) {
        subSignature = drecursed->currentSignature().toLatin1();
        if (!subSignature.isEmpty())
            sig = subSignature.constData();
    }
    open(mrecursed, code, sig);

    while (!drecursed->atEnd()) {
        if (!mrecursed.appendCrossMarshalling(drecursed)) {
            delete drecursed;
            return false;
        }
    }

    delete drecursed;
    return true;
}

appendRegisteredType()

bool QDBusMarshaller::appendRegisteredType

(

const QVariant &

arg

)

Definition at line 504 of file qdbusmarshaller.cpp.

Referenced by appendVariantInternal().

{
    ref.ref();                  // reference up
    QDBusArgument self(QDBusArgumentPrivate::create(this));
    return QDBusMetaType::marshall(self, arg.userType(), arg.constData());
}

appendVariantInternal()

bool QDBusMarshaller::appendVariantInternal

(

const QVariant &

arg

)

Definition at line 361 of file qdbusmarshaller.cpp.

Referenced by append(), QDBusArgument::appendVariant(), and QDBusMessagePrivate::toDBusMessage().

{
    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",
                 QVariant::typeToName( QVariant::Type(id) ), id);
        error(QString::fromLatin1("Unregistered type %1 passed in arguments")
              .arg(QLatin1String(QVariant::typeToName(QVariant::Type(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:
            ;                   // fall through
        }
        // fall through

    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;
        }
        // fall through

    default:
        qWarning("QDBusMarshaller::appendVariantInternal: Found unknown D-BUS type '%s'",
                 signature);
        return false;
    }

    return true;
}

beginArray()

QDBusMarshaller * QDBusMarshaller::beginArray ( int  id )

inline

Definition at line 231 of file qdbusmarshaller.cpp.

Referenced by QDBusArgument::beginArray().

{
    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",
                 QVariant::typeToName( QVariant::Type(id) ), id);
        error(QString::fromLatin1("Unregistered type %1 passed in arguments")
              .arg(QLatin1String(QVariant::typeToName(QVariant::Type(id)))));
        return this;
    }

    return beginCommon(DBUS_TYPE_ARRAY, signature);
}

beginCommon()

QDBusMarshaller * QDBusMarshaller::beginCommon	(	int	code,
		const char *	signature
	)

Definition at line 316 of file qdbusmarshaller.cpp.

Referenced by beginArray(), beginMap(), beginMapEntry(), and beginStructure().

{
    QDBusMarshaller *d = new QDBusMarshaller(capabilities);
    open(*d, code, signature);
    return d;
}

beginMap()

QDBusMarshaller * QDBusMarshaller::beginMap ( int  kid, int  vid  )

inline

Definition at line 246 of file qdbusmarshaller.cpp.

Referenced by QDBusArgument::beginMap().

{
    const char *ksignature = QDBusMetaType::typeToSignature( QVariant::Type(kid) );
    if (!ksignature) {
        qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. "
                 "Use qDBusRegisterMetaType to register it",
                 QVariant::typeToName( QVariant::Type(kid) ), kid);
        error(QString::fromLatin1("Unregistered type %1 passed in arguments")
              .arg(QLatin1String(QVariant::typeToName(QVariant::Type(kid)))));
        return this;
    }
    if (ksignature[1] != 0 || !QDBusUtil::isValidBasicType(*ksignature)) {
        qWarning("QDBusMarshaller: type '%s' (%d) cannot be used as the key type in a D-BUS map.",
                 QVariant::typeToName( QVariant::Type(kid) ), kid);
        error(QString::fromLatin1("Type %1 passed in arguments cannot be used as a key in a map")
              .arg(QLatin1String(QVariant::typeToName(QVariant::Type(kid)))));
        return this;
    }

    const char *vsignature = QDBusMetaType::typeToSignature( QVariant::Type(vid) );
    if (!vsignature) {
        const char *typeName = QVariant::typeToName(QVariant::Type(vid));
        qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. "
                 "Use qDBusRegisterMetaType to register it",
                 typeName, vid);
        error(QString::fromLatin1("Unregistered type %1 passed in arguments")
              .arg(QLatin1String(typeName)));
        return this;
    }

    QByteArray signature;
    signature = DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING;
    signature += ksignature;
    signature += vsignature;
    signature += DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
    return beginCommon(DBUS_TYPE_ARRAY, signature);
}

beginMapEntry()

QDBusMarshaller * QDBusMarshaller::beginMapEntry ( )

inline

Definition at line 284 of file qdbusmarshaller.cpp.

Referenced by QDBusArgument::beginMapEntry().

{
    return beginCommon(DBUS_TYPE_DICT_ENTRY, 0);
}

beginStructure()

QDBusMarshaller * QDBusMarshaller::beginStructure ( )

inline

Definition at line 226 of file qdbusmarshaller.cpp.

Referenced by QDBusArgument::beginStructure().

{
    return beginCommon(DBUS_TYPE_STRUCT, 0);
}

close()

void QDBusMarshaller::close

(

)

Definition at line 342 of file qdbusmarshaller.cpp.

Referenced by ~QDBusMarshaller().

{
    if (ba) {
        if (closeCode)
            *ba += closeCode;
    } else if (parent) {
        q_dbus_message_iter_close_container(&parent->iterator, &iterator);
    }
}

currentSignature()

QString QDBusMarshaller::currentSignature ( )

inline

Definition at line 64 of file qdbusmarshaller.cpp.

Referenced by append(), and QDBusArgument::currentSignature().

{
    if (message)
        return QString::fromUtf8(q_dbus_message_get_signature(message));
    return QString();
}

endArray()

QDBusMarshaller * QDBusMarshaller::endArray ( )

inline

Definition at line 326 of file qdbusmarshaller.cpp.

Referenced by QDBusArgument::endArray().

{ return endCommon(); }

endCommon()

QDBusMarshaller * QDBusMarshaller::endCommon

(

)

Definition at line 335 of file qdbusmarshaller.cpp.

Referenced by endArray(), endMap(), endMapEntry(), and endStructure().

{
    QDBusMarshaller *retval = parent;
    delete this;
    return retval;
}

endMap()

QDBusMarshaller * QDBusMarshaller::endMap ( )

inline

Definition at line 329 of file qdbusmarshaller.cpp.

Referenced by QDBusArgument::endMap().

{ return endCommon(); }

endMapEntry()

QDBusMarshaller * QDBusMarshaller::endMapEntry ( )

inline

Definition at line 332 of file qdbusmarshaller.cpp.

Referenced by QDBusArgument::endMapEntry().

{ return endCommon(); }

endStructure()

QDBusMarshaller * QDBusMarshaller::endStructure ( )

inline

Definition at line 323 of file qdbusmarshaller.cpp.

Referenced by QDBusArgument::endStructure().

{ return endCommon(); }

error()

void QDBusMarshaller::error

(

const QString &

message

)

Definition at line 352 of file qdbusmarshaller.cpp.

Referenced by append(), appendVariantInternal(), beginArray(), beginMap(), and error().

{
    ok = false;
    if (parent)
        parent->error(msg);
    else
        errorString = msg;
}

open()

void QDBusMarshaller::open	(	QDBusMarshaller &	sub,
		int	code,
		const char *	signature
	)

Definition at line 289 of file qdbusmarshaller.cpp.

Referenced by append(), appendCrossMarshalling(), and beginCommon().

{
    sub.parent = this;
    sub.ba = ba;
    sub.ok = true;
    sub.capabilities = capabilities;

    if (ba)
        switch (code) {
        case DBUS_TYPE_ARRAY:
            *ba += char(code);
            *ba += signature;
            // fall through

        case DBUS_TYPE_DICT_ENTRY:
            sub.closeCode = 0;
            break;

        case DBUS_TYPE_STRUCT:
            *ba += DBUS_STRUCT_BEGIN_CHAR;
            sub.closeCode = DBUS_STRUCT_END_CHAR;
            break;
        }
    else
        q_dbus_message_iter_open_container(&iterator, code, signature, &sub.iterator);
}

Properties

ba

QByteArray* QDBusMarshaller::ba

Definition at line 152 of file qdbusargument_p.h.

Referenced by append(), appendVariantInternal(), close(), QDBusArgumentPrivate::createSignature(), and open().

closeCode

char QDBusMarshaller::closeCode

Definition at line 154 of file qdbusargument_p.h.

Referenced by close(), and open().

errorString

QString QDBusMarshaller::errorString

Definition at line 153 of file qdbusargument_p.h.

Referenced by error(), and QDBusMessagePrivate::toDBusMessage().

iterator

DBusMessageIter QDBusMarshaller::iterator

Definition at line 150 of file qdbusargument_p.h.

Referenced by append(), appendCrossMarshalling(), appendVariantInternal(), QDBusArgumentPrivate::checkWrite(), close(), open(), QDBusArgument::QDBusArgument(), and QDBusMessagePrivate::toDBusMessage().

ok

bool QDBusMarshaller::ok

Definition at line 155 of file qdbusargument_p.h.

Referenced by QDBusArgumentPrivate::checkWrite(), QDBusArgumentPrivate::createSignature(), error(), open(), and QDBusMessagePrivate::toDBusMessage().

parent

QDBusMarshaller* QDBusMarshaller::parent

Definition at line 151 of file qdbusargument_p.h.

Referenced by close(), endCommon(), error(), and open().

---

The documentation for this class was generated from the following files:

• /src/dbus/qdbusargument_p.h
• /src/dbus/qdbusmarshaller.cpp