QDBusArgument Class

See also QDBusAbstractInterface, The Qt D-Bus type system, Using Adaptors, qdbus_cast()

This enum describes the type of element held by the argument.

See Also▲

Constructs an empty QDBusArgument argument.

An empty QDBusArgument object does not allow either reading or writing to be performed.

Constructs a copy of the other QDBusArgument object.

Both objects will therefore contain the same state from this point forward. QDBusArguments are explicitly shared and, therefore, any modification to either copy will affect the other one too.

Disposes of the resources associated with this QDBusArgument object.

Returns the current argument in the form of a QVariant. Basic types will be decoded and returned in the QVariant, but for complex types, this function will return a QDBusArgument object in the QVariant. It is the caller's responsibility to decode the argument (for example, by calling asVariant() in it).

For example, if the current argument is an INT32, this function will return a QVariant with an argument of type QMetaType::Int. For an array of INT32, it will return a QVariant containing a QDBusArgument.

If an error occurs or if there are no more arguments to decode (i.e., we are at the end of the argument list), this function will return an invalid QVariant.

See Also▲

Returns true if there are no more elements to be extracted from this QDBusArgument. This function is usually used in QDBusArgument objects returned from beginMap() and beginArray().

Opens a new D-Bus array suitable for appending elements of meta-type id.

This function is used usually in operator<< streaming operators, as in the following example:

// Append an array of MyElement types
QDBusArgument &operator<<(QDBusArgument &argument, const MyArray &myArray)
{
    argument.beginArray(qMetaTypeId<MyElement>());
    for (const auto &element : myArray)
        argument << element;
    argument.endArray();
    return argument;
}

If the type you want to marshall is a QList or any of the Qt's Container Classes that take one template parameter, you need not declare an operator<< function for it, since Qt D-Bus provides generic templates to do the job of marshalling the data. The same applies for STL's sequence containers, such as std::list, std::vector, etc.

See Also▲

Recurses into the D-Bus array to allow extraction of the array elements.

This function is used usually in operator>> streaming operators, as in the following example:

// Extract a MyArray array of MyElement elements
const QDBusArgument &operator>>(const QDBusArgument &argument, MyArray &myArray)
{
    argument.beginArray();
    myArray.clear();

    while (!argument.atEnd()) {
        MyElement element;
        argument >> element;
        myArray.append(element);
    }

    argument.endArray();
    return argument;
}

If the type you want to demarshall is a QList or any of the Qt's Container Classes that take one template parameter, you need not declare an operator>> function for it, since Qt D-Bus provides generic templates to do the job of demarshalling the data. The same applies for STL's sequence containers, such as std::list, std::vector, etc.

See Also▲

Opens a new D-Bus map suitable for appending elements. Maps are containers that associate one entry (the key) to another (the value), such as Qt's QMap or QHash. The ids of the map's key and value meta types must be passed in keyMetaType and valueMetaType respectively.

This function is used usually in operator<< streaming operators, as in the following example:

// Append a dictionary that associates ints to MyValue types
QDBusArgument &operator<<(QDBusArgument &argument, const MyDictionary &myDict)
{
    argument.beginMap(QMetaType::fromType<int>(), QMetaType::fromType<MyValue>());
    MyDictionary::const_iterator i;
    for (i = myDict.cbegin(); i != myDict.cend(); ++i) {
        argument.beginMapEntry();
        argument << i.key() << i.value();
        argument.endMapEntry();
    }
    argument.endMap();
    return argument;
}

You usually don't need to provide an operator<< or operator>> function for associative containers such as QHash or std::map, since Qt D-Bus provides generic templates to do the job of marshalling the data.

See Also▲

Recurses into the D-Bus map to allow extraction of the map's elements.

This function is used usually in operator>> streaming operators, as in the following example:

// Extract a MyDictionary map that associates integers to MyElement items
const QDBusArgument &operator>>(const QDBusArgument &argument, MyDictionary &myDict)
{
    argument.beginMap();
    myDict.clear();

    while (!argument.atEnd()) {
        int key;
        MyElement value;
        argument.beginMapEntry();
        argument >> key >> value;
        argument.endMapEntry();
        myDict.insert(key, value);
    }

    argument.endMap();
    return argument;
}

If the type you want to demarshall is a QMap or QHash, you need not declare an operator>> function for it, since Qt D-Bus provides generic templates to do the job of demarshalling the data.

See Also▲

Opens a D-Bus map entry suitable for appending the key and value entries. This function is only valid when a map has been opened with beginMap().

See beginMap() for an example of usage of this function.

See Also▲

Recurses into the D-Bus map entry to allow extraction of the key and value pair.

See beginMap() for an example of how this function is usually used.

See Also▲

Opens a new D-Bus structure suitable for appending new arguments.

This function is used usually in operator<< streaming operators, as in the following example:

QDBusArgument &operator<<(QDBusArgument &argument, const MyStructure &myStruct)
{
    argument.beginStructure();
    argument << myStruct.member1 << myStruct.member2;
    argument.endStructure();
    return argument;
}

Structures can contain other structures, so the following code is also valid:

QDBusArgument &operator<<(QDBusArgument &argument, const MyStructure &myStruct)
{
    argument.beginStructure();
    argument << myStruct.member1 << myStruct.member2;

    argument.beginStructure();
    argument << myStruct.member3.subMember1 << myStruct.member3.subMember2;
    argument.endStructure();

    argument << myStruct.member4;
    argument.endStructure();
    return argument;
}

See Also▲

Opens a D-Bus structure suitable for extracting elements.

This function is used usually in operator>> streaming operators, as in the following example:

const QDBusArgument &operator>>(const QDBusArgument &argument, MyStructure &myStruct)
{
    argument.beginStructure();
    argument >> myStruct.member1 >> myStruct.member2 >> myStruct.member3;
    argument.endStructure();
    return argument;
}

See Also▲

Returns the classification of the current element type. If an error decoding the type occurs or if we're at the end of the argument, this function returns QDBusArgument::UnknownType.

This function only makes sense when demarshalling arguments. If it is used while marshalling, it will always return UnknownType.

Closes a D-Bus array opened with beginArray(). This function must be called same number of times that beginArray() is called.

See Also▲

Closes the D-Bus array and allow extracting of the next element after the array.

See Also▲

Closes a D-Bus map opened with beginMap(). This function must be called same number of times that beginMap() is called.

See Also▲

Closes the D-Bus map and allow extracting of the next element after the map.

See Also▲

Closes a D-Bus map entry opened with beginMapEntry(). This function must be called same number of times that beginMapEntry() is called.

See Also▲

Closes the D-Bus map entry and allow extracting of the next element on the map.

See Also▲

Closes a D-Bus structure opened with beginStructure(). This function must be called same number of times that beginStructure() is called.

See Also▲

Closes the D-Bus structure and allow extracting of the next element after the structure.

See Also▲

Swaps this QDBusArgument instance with other.

Appends the primitive value arg of type BYTE to the D-Bus stream.

This is an overloaded function.

Appends the primitive value arg of type BOOLEAN to the D-Bus stream.

This is an overloaded function.

Appends the primitive value arg of type INT16 to the D-Bus stream.

This is an overloaded function.

Appends the primitive value arg of type UINT16 to the D-Bus stream.

This is an overloaded function.

Appends the primitive value arg of type INT32 to the D-Bus stream.

This is an overloaded function.

Appends the primitive value arg of type UINT32 to the D-Bus stream.

This is an overloaded function.

Appends the primitive value arg of type INT64 to the D-Bus stream.

This is an overloaded function.

Appends the primitive value arg of type UINT64 to the D-Bus stream.

This is an overloaded function.

Appends the primitive value arg of type DOUBLE (double-precision floating-point) to the D-Bus stream.

This is an overloaded function.

Appends the primitive value arg of type STRING (Unicode character string) to the D-Bus stream.

This is an overloaded function.

Appends the primitive value arg of type VARIANT to the D-Bus stream.

A D-Bus variant type can contain any type, including other variants. It is similar to the Qt QVariant type.

This is an overloaded function.

Appends the QStringList given by arg as ARRAY of STRING to the D-Bus stream.

QStringList and QByteArray are the only two non-primitive types that are supported directly by QDBusArgument because of their widespread usage in Qt applications.

Other arrays are supported through compound types in Qt D-Bus.

This is an overloaded function.

Appends the QByteArray given by arg as ARRAY of BYTE to the D-Bus stream.

QStringList and QByteArray are the only two non-primitive types that are supported directly by QDBusArgument because of their widespread usage in Qt applications.

Other arrays are supported through compound types in Qt D-Bus.

Copies the other QDBusArgument object into this one.

Both objects will therefore contain the same state from this point forward. QDBusArguments are explicitly shared and, therefore, any modification to either copy will affect the other one too.

Extracts one D-BUS primitive argument of type BYTE from the D-BUS stream and puts it into arg.

This is an overloaded function.

Extracts one D-Bus primitive argument of type BOOLEAN from the D-Bus stream.

This is an overloaded function.

Extracts one D-Bus primitive argument of type INT16 from the D-Bus stream.

This is an overloaded function.

Extracts one D-Bus primitive argument of type UINT16 from the D-Bus stream.

This is an overloaded function.

Extracts one D-Bus primitive argument of type INT32 from the D-Bus stream.

This is an overloaded function.

Extracts one D-Bus primitive argument of type UINT32 from the D-Bus stream.

This is an overloaded function.

Extracts one D-Bus primitive argument of type INT64 from the D-Bus stream.

This is an overloaded function.

Extracts one D-Bus primitive argument of type UINT64 from the D-Bus stream.

This is an overloaded function.

Extracts one D-Bus primitive argument of type DOUBLE (double-precision floating point) from the D-Bus stream.

This is an overloaded function.

Extracts one D-Bus primitive argument of type STRING (Unicode character string) from the D-Bus stream.

This is an overloaded function.

Extracts one D-Bus primitive argument of type VARIANT from the D-Bus stream.

A D-Bus variant type can contain any type, including other variants. It is similar to the Qt QVariant type.

In case the variant contains a type not directly supported by QDBusArgument, the value of the returned QDBusVariant will contain another QDBusArgument. It is your responsibility to further demarshall it into another type.

This is an overloaded function.

Extracts an array of strings from the D-Bus stream and return it as a QStringList.

QStringList and QByteArray are the only two non-primitive types that are supported directly by QDBusArgument because of their widespread usage in Qt applications.

Other arrays are supported through compound types in Qt D-Bus.

This is an overloaded function.

Extracts an array of bytes from the D-Bus stream and return it as a QByteArray.

QStringList and QByteArray are the only two non-primitive types that are supported directly by QDBusArgument because of their widespread usage in Qt applications.

Other arrays are supported through compound types in Qt D-Bus.

Registers T with the Qt D-Bus Type System and the Qt meta-type system, if it's not already registered.

To register a type, it must be declared as a meta-type with the Q_DECLARE_METATYPE() macro, and then registered as in the following example:

#include <QDBusMetaType>

qDBusRegisterMetaType<MyClass>();

If T isn't one of Qt's container classes, the operator<< and operator>> streaming operators between T and QDBusArgument must be already declared. See the Qt D-Bus Type System page for more information on how to declare such types.

This function returns the Qt meta type id for the type (the same value that is returned from qRegisterMetaType()).

See Also▲

Attempts to demarshall the contents of arg into the type T. For example:

MyType item = qdbus_cast<Type>(argument);

Note that it is equivalent to the following:

MyType item;
argument >> item;