En esta página

QDBusArgument Class

La clase QDBusArgument se utiliza para marshalar y desmarshalar argumentos de D-Bus. Más información...

Encabezado: #include <QDBusArgument>
CMake: find_package(Qt6 REQUIRED COMPONENTS DBus)
target_link_libraries(mytarget PRIVATE Qt6::DBus)
qmake: QT += dbus

Tipos públicos

enum ElementType { BasicType, VariantType, ArrayType, StructureType, MapType, …, UnknownType }

Funciones públicas

QDBusArgument()
QDBusArgument(const QDBusArgument &other)
~QDBusArgument()
QVariant asVariant() const
bool atEnd() const
void beginArray() const
void beginArray(QMetaType id)
void beginMap() const
void beginMap(QMetaType keyMetaType, QMetaType valueMetaType)
void beginMapEntry()
void beginMapEntry() const
void beginStructure()
void beginStructure() const
QDBusArgument::ElementType currentType() const
void endArray()
void endArray() const
void endMap()
void endMap() const
void endMapEntry()
void endMapEntry() const
void endStructure()
void endStructure() const
void swap(QDBusArgument &other)
QDBusArgument &operator<<(uchar arg)
QDBusArgument &operator<<(bool arg)
QDBusArgument &operator<<(const QByteArray &arg)
QDBusArgument &operator<<(const QDBusVariant &arg)
QDBusArgument &operator<<(const QString &arg)
QDBusArgument &operator<<(const QStringList &arg)
QDBusArgument &operator<<(double arg)
QDBusArgument &operator<<(int arg)
QDBusArgument &operator<<(qlonglong arg)
QDBusArgument &operator<<(qulonglong arg)
QDBusArgument &operator<<(short arg)
QDBusArgument &operator<<(uint arg)
QDBusArgument &operator<<(ushort arg)
QDBusArgument &operator=(const QDBusArgument &other)
const QDBusArgument &operator>>(uchar &arg) const
const QDBusArgument &operator>>(QByteArray &arg) const
const QDBusArgument &operator>>(QDBusVariant &arg) const
const QDBusArgument &operator>>(QString &arg) const
const QDBusArgument &operator>>(QStringList &arg) const
const QDBusArgument &operator>>(bool &arg) const
const QDBusArgument &operator>>(double &arg) const
const QDBusArgument &operator>>(int &arg) const
const QDBusArgument &operator>>(qlonglong &arg) const
const QDBusArgument &operator>>(qulonglong &arg) const
const QDBusArgument &operator>>(short &arg) const
const QDBusArgument &operator>>(uint &arg) const
const QDBusArgument &operator>>(ushort &arg) const
QMetaType qDBusRegisterMetaType()
T qdbus_cast(const QDBusArgument &arg)

Descripción detallada

Esta clase se utiliza para enviar argumentos a través de D-Bus a aplicaciones remotas y para recibirlos de vuelta. D-Bus ofrece un sistema de tipos extensible, basado en unos pocos tipos primitivos y en sus asociaciones. Consulta la página «Sistema de tipos deQt D-Bus » para obtener más información sobre el sistema de tipos.

QDBusArgument es la clase central del sistema de tipos de Qt D-Bus, que proporciona funciones para marshall y demarshall de los tipos primitivos. A continuación, los tipos compuestos se crean mediante la asociación de uno o más de los tipos primitivos en matrices, diccionarios o estructuras.

El siguiente ejemplo ilustra cómo se puede construir una estructura que contenga un entero y una cadena utilizando el sistema de tipos deQt D-Bus :

struct MyStructure
{
    int count;
    QString name;

    // ...
};
Q_DECLARE_METATYPE(MyStructure)

// Marshall the MyStructure data into a D-Bus argument
QDBusArgument &operator<<(QDBusArgument &argument, const MyStructure &myStruct)
{
    argument.beginStructure();
    argument << myStruct.count << myStruct.name;
    argument.endStructure();
    return argument;
}

// Retrieve the MyStructure data from the D-Bus argument
const QDBusArgument &operator>>(const QDBusArgument &argument, MyStructure &myStruct)
{
    argument.beginStructure();
    argument >> myStruct.count >> myStruct.name;
    argument.endStructure();
    return argument;
}

El tipo debe registrarse con ` qDBusRegisterMetaType()` antes de poder utilizarse con `QDBusArgument`. Por lo tanto, en algún punto de tu programa, debes añadir el siguiente código:

qDBusRegisterMetaType<MyStructure>();

Una vez registrado, un tipo puede utilizarse en llamadas a métodos salientes (realizadas con ` QDBusAbstractInterface::call()`), en emisiones de señales de objetos registrados o en llamadas entrantes procedentes de aplicaciones remotas.

Es importante tener en cuenta que las funciones de streaming operator<< y operator>> deben producir siempre el mismo número de entradas en el caso de las estructuras, tanto en lectura como en escritura (marshalling y demarshalling); de lo contrario, las llamadas y las señales podrían empezar a fallar de forma silenciosa.

El siguiente ejemplo ilustra este uso incorrecto en el contexto de una clase que puede contener datos no válidos:

//bad code
    // Wrongly marshall the MyTime data into a D-Bus argument
    QDBusArgument &operator<<(QDBusArgument &argument, const MyTime &mytime)
    {
        argument.beginStructure();
        if (mytime.isValid)
            argument << true << mytime.hour
                     << mytime.minute << mytime.second;
        else
            argument << false;
        argument.endStructure();
        return argument;
    }

En este ejemplo, tanto la función operator<< como la operator>> pueden producir un número diferente de lecturas/escrituras. Esto puede confundir al sistema de tipos de Qt D-Bus y debe evitarse.

Véase también QDBusAbstractInterface, El sistema de tipos Qt D-Bus , Uso de adaptadores y qdbus_cast().

Documentación sobre tipos de miembro

enum QDBusArgument::ElementType

Esta enumeración describe el tipo de elemento que contiene el argumento.

ConstanteValorDescripción
QDBusArgument::BasicType0Un elemento básico, que es reconocido por ` QVariant`. Se consideran básicos los siguientes tipos: `bool`, `byte`, `short`, `ushort`, `int`, `uint`, `qint64`, `quint64`, `double`, ` QString`, ` QByteArray`, ` QDBusObjectPath`, QDBusSignature
QDBusArgument::VariantType1El elemento variante (QDBusVariant)
QDBusArgument::ArrayType2Un elemento de matriz, normalmente representado por QList<T>. Nota: QByteArray y los mapas asociativos no se consideran matrices, aunque el protocolo D-Bus los transporte como tales.
QDBusArgument::StructureType3Un tipo personalizado representado por una estructura, como QDateTime, QPoint, etc.
QDBusArgument::MapType4Un contenedor asociativo, como QMap<Clave, Valor> o QHash<Clave, Valor>
QDBusArgument::MapEntryType5Una entrada en un contenedor asociativo: tanto la clave como el valor forman un tipo de entrada de mapa.
QDBusArgument::UnknownType-1El tipo es desconocido o se ha llegado al final de la lista.

Véase también currentType().

Documentación de funciones miembro

QDBusArgument::QDBusArgument()

Crea un objeto QDBusArgument vacío.

Un objeto QDBusArgument vacío no permite realizar ni lecturas ni escrituras.

QDBusArgument::QDBusArgument(const QDBusArgument &other)

Crea una copia del objeto QDBusArgument « other ».

Por lo tanto, ambos objetos contendrán el mismo estado a partir de este momento. Los QDBusArguments se comparten explícitamente y, por lo tanto, cualquier modificación en cualquiera de las copias afectará también a la otra.

[noexcept] QDBusArgument::~QDBusArgument()

Libera los recursos asociados a este objeto ` QDBusArgument `.

QVariant QDBusArgument::asVariant() const

Devuelve el argumento actual en forma de ` QVariant`. Los tipos básicos se descodificarán y se devolverán en ` QVariant`, pero en el caso de los tipos complejos, esta función devolverá un objeto ` QDBusArgument ` en ` QVariant`. Es responsabilidad de quien realiza la llamada descodificar el argumento (por ejemplo, llamando a `asVariant()` en él).

Por ejemplo, si el argumento actual es un INT32, esta función devolverá un ` QVariant ` con un argumento de tipo ` QMetaType::Int`. En el caso de una matriz de INT32, devolverá un ` QVariant ` que contenga un ` QDBusArgument`.

Si se produce un error o si no hay más argumentos que decodificar (es decir, si nos encontramos al final de la lista de argumentos), esta función devolverá un QVariant no válido.

Véase también atEnd().

bool QDBusArgument::atEnd() const

Devuelve ` true ` si ya no hay más elementos que extraer de este ` QDBusArgument`. Esta función se suele utilizar en los objetos ` QDBusArgument ` devueltos por ` beginMap()` y ` beginArray()`.

void QDBusArgument::beginArray() const

Accede de forma recursiva al array de D-Bus para permitir la extracción de los elementos del array.

Esta función se utiliza habitualmente en los operadores de streaming de operator>>, como en el siguiente ejemplo:

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

Si el tipo que deseas desmarcar es un ` QList ` o cualquiera de las clases contenedoras de Qt XML que admiten un parámetro de plantilla, no es necesario declarar una función ` operator>> ` para él, ya que ` Qt D-Bus ` proporciona plantillas genéricas que se encargan de desmarcar los datos. Lo mismo se aplica a los contenedores de secuencia de la STL, como ` std::list`, ` std::vector`, etc.

Véase también atEnd(), beginStructure() y beginMap().

void QDBusArgument::beginArray(QMetaType id)

Abre una nueva matriz D-Bus adecuada para añadir elementos del metatipo id.

Esta función se utiliza habitualmente en los operadores de streaming de operator<<, como en el siguiente ejemplo:

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

Si el tipo que deseas marshallar es un ` QList ` o cualquiera de las clases contenedoras de Qt que admiten un parámetro de plantilla, no es necesario que declares una función ` operator<< ` para él, ya que ` Qt D-Bus ` proporciona plantillas genéricas que se encargan de marshallar los datos. Lo mismo se aplica a los contenedores de secuencia de la STL, como ` std::list`, ` std::vector`, etc.

Véase también endArray(), beginStructure() y beginMap().

void QDBusArgument::beginMap() const

Accede de forma recursiva al mapa de D-Bus para permitir la extracción de los elementos del mapa.

Esta función se utiliza habitualmente en los operadores de streaming de operator>>, como en el siguiente ejemplo:

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

Si el tipo que deseas desmarcar es un ` QMap ` o un ` QHash`, no es necesario que declares una función ` operator>> ` para él, ya que ` Qt D-Bus ` proporciona plantillas genéricas que se encargan de desmarcar los datos.

Véanse también endMap(), beginStructure(), beginArray() y beginMapEntry().

void QDBusArgument::beginMap(QMetaType keyMetaType, QMetaType valueMetaType)

Abre un nuevo mapa D-Bus adecuado para añadir elementos. Los mapas son contenedores que asocian una entrada (la clave) a otra (el valor), como por ejemplo « QMap » o « QHash » de Qt. Los identificadores de los metatipos de clave y valor del mapa deben pasarse en « keyMetaType » y « valueMetaType », respectivamente.

Esta función se utiliza habitualmente en los operadores de streaming de operator<<, como en el siguiente ejemplo:

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

Normalmente no es necesario proporcionar una función operator<< o operator>> para contenedores asociativos como QHash o std::map, ya que Qt D-Bus proporciona plantillas genéricas que se encargan de la conversión de los datos.

Véanse también endMap(), beginStructure(), beginArray() y beginMapEntry().

void QDBusArgument::beginMapEntry()

Abre una entrada de mapa de D-Bus adecuada para añadir entradas de clave y valor. Esta función solo es válida cuando se ha abierto un mapa con beginMap().

Consulte beginMap() para ver un ejemplo de uso de esta función.

Véanse también endMapEntry() y beginMap().

void QDBusArgument::beginMapEntry() const

Accede a la entrada del mapa de D-Bus para permitir la extracción del par clave-valor.

Consulta beginMap() para ver un ejemplo de cómo se suele utilizar esta función.

Véase también endMapEntry() y beginMap().

void QDBusArgument::beginStructure()

Abre una nueva estructura D-Bus adecuada para añadir nuevos argumentos.

Esta función se utiliza habitualmente en los operadores de streaming de « operator<< », como en el siguiente ejemplo:

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

Las estructuras pueden contener otras estructuras, por lo que el siguiente código también es válido:

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

Véase también endStructure(), beginArray() y beginMap().

void QDBusArgument::beginStructure() const

Abre una estructura D-Bus adecuada para extraer elementos.

Esta función se utiliza habitualmente en los operadores de streaming de operator>>, como en el siguiente ejemplo:

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

Véase también endStructure(), beginArray() y beginMap().

QDBusArgument::ElementType QDBusArgument::currentType() const

Devuelve la clasificación del tipo del elemento actual. Si se produce un error al decodificar el tipo o si se ha llegado al final del argumento, esta función devuelve « QDBusArgument::UnknownType ».

Esta función solo tiene sentido al desmarcar argumentos. Si se utiliza durante el marcado, siempre devolverá « UnknownType ».

void QDBusArgument::endArray()

Cierra una matriz de D-Bus abierta con ` beginArray()`. Esta función debe invocarse el mismo número de veces que se invoca ` beginArray()`.

Véase también beginArray(), endStructure() y endMap().

void QDBusArgument::endArray() const

Cierra el array de D-Bus y permite extraer el siguiente elemento tras el array.

Véase también beginArray().

void QDBusArgument::endMap()

Cierra un mapa de D-Bus abierto con ` beginMap()`. Esta función debe llamarse el mismo número de veces que se haya llamado a ` beginMap()`.

Véanse también beginMap(), endStructure() y endArray().

void QDBusArgument::endMap() const

Cierra el mapa de D-Bus y permite extraer el siguiente elemento tras el mapa.

Véase también beginMap().

void QDBusArgument::endMapEntry()

Cierra una entrada del mapa de D-Bus abierta con ` beginMapEntry()`. Esta función debe llamarse el mismo número de veces que se llama a ` beginMapEntry()`.

Véase también ` beginMapEntry()`.

void QDBusArgument::endMapEntry() const

Cierra la entrada del mapa de D-Bus y permite extraer el siguiente elemento del mapa.

Véase también beginMapEntry().

void QDBusArgument::endStructure()

Cierra una estructura D-Bus abierta con ` beginStructure()`. Esta función debe llamarse el mismo número de veces que se haya llamado a ` beginStructure()`.

Véanse también beginStructure(), endArray() y endMap().

void QDBusArgument::endStructure() const

Cierra la estructura de D-Bus y permite extraer el siguiente elemento después de la estructura.

Véase también beginStructure().

[noexcept] void QDBusArgument::swap(QDBusArgument &other)

Intercambia este argumento con other. Esta operación es muy rápida y nunca falla.

QDBusArgument &QDBusArgument::operator<<(uchar arg)

Añade el valor primitivo « arg », de tipo « BYTE », al flujo de D-Bus.

QDBusArgument &QDBusArgument::operator<<(bool arg)

Añade el valor primitivo « arg », de tipo « BOOLEAN », al flujo de D-Bus.

Esta es una función sobrecargada.

QDBusArgument &QDBusArgument::operator<<(const QByteArray &arg)

Añade el tipo « QByteArray », definido en arg como ARRAY of BYTE, al flujo de D-Bus.

QStringList y QByteArray son los dos únicos tipos no primitivos que QDBusArgument admite directamente debido a su uso generalizado en aplicaciones Qt.

El resto de matrices se admiten a través de tipos compuestos en Qt D-Bus.

Esta es una función sobrecargada.

QDBusArgument &QDBusArgument::operator<<(const QDBusVariant &arg)

Añade el valor primitivo « arg » de tipo « VARIANT » al flujo de D-Bus.

Un tipo variante de D-Bus puede contener cualquier tipo, incluidas otras variantes. Es similar al tipo « QVariant » de Qt XML.

Esta es una función sobrecargada.

QDBusArgument &QDBusArgument::operator<<(const QString &arg)

Añade el valor primitivo arg, de tipo STRING (cadena de caracteres Unicode), al flujo de D-Bus.

Se trata de una función sobrecargada.

QDBusArgument &QDBusArgument::operator<<(const QStringList &arg)

Añade el tipo « QStringList », definido en arg como ARRAY of STRING, al flujo de D-Bus.

QStringList y QByteArray son los dos únicos tipos no primitivos que QDBusArgument admite directamente debido a su uso generalizado en aplicaciones Qt.

El resto de matrices se admiten a través de tipos compuestos en Qt D-Bus.

Esta es una función sobrecargada.

QDBusArgument &QDBusArgument::operator<<(double arg)

Añade el valor primitivo arg, de tipo DOUBLE (punto flotante de doble precisión), al flujo de D-Bus.

Se trata de una función sobrecargada.

QDBusArgument &QDBusArgument::operator<<(int arg)

Añade el valor primitivo arg, de tipo INT32, al flujo de D-Bus.

Esta es una función sobrecargada.

QDBusArgument &QDBusArgument::operator<<(qlonglong arg)

Añade el valor primitivo arg, de tipo INT64, al flujo de D-Bus.

Esta es una función sobrecargada.

QDBusArgument &QDBusArgument::operator<<(qulonglong arg)

Añade el valor primitivo « arg » de tipo « UINT64 » al flujo de D-Bus.

Esta es una función sobrecargada.

QDBusArgument &QDBusArgument::operator<<(short arg)

Añade el valor primitivo arg, de tipo INT16, al flujo de D-Bus.

Esta es una función sobrecargada.

QDBusArgument &QDBusArgument::operator<<(uint arg)

Añade el valor primitivo arg, de tipo UINT32, al flujo de D-Bus.

Esta es una función sobrecargada.

QDBusArgument &QDBusArgument::operator<<(ushort arg)

Añade el valor primitivo arg, de tipo UINT16, al flujo de D-Bus.

Esta es una función sobrecargada.

QDBusArgument &QDBusArgument::operator=(const QDBusArgument &other)

Copia el objeto other QDBusArgument en este.

Por lo tanto, ambos objetos contendrán el mismo estado a partir de este momento. Los QDBusArguments se comparten explícitamente y, por lo tanto, cualquier modificación en cualquiera de las copias afectará también a la otra.

const QDBusArgument &QDBusArgument::operator>>(uchar &arg) const

Extrae un argumento primitivo de D-Bus de tipo « BYTE » del flujo de D-Bus y lo coloca en « arg ».

const QDBusArgument &QDBusArgument::operator>>(QByteArray &arg) const

Extrae una matriz de bytes del flujo de D-Bus y la devuelve como un objeto ` QByteArray`.

QStringList QByteArray y son los dos únicos tipos no primitivos que admite directamente debido a su uso generalizado en las aplicaciones Qt. QDBusArgument

El resto de matrices se admiten a través de tipos compuestos en ` Qt D-Bus`.

Esta es una función sobrecargada.

const QDBusArgument &QDBusArgument::operator>>(QDBusVariant &arg) const

Extrae un argumento primitivo de D-Bus de tipo « VARIANT » del flujo de D-Bus.

Un tipo variante de D-Bus puede contener cualquier tipo, incluidas otras variantes. Es similar al tipo « QVariant » de Qt.

En caso de que la variante contenga un tipo no compatible directamente con ` QDBusArgument`, el valor de ` QDBusVariant ` devuelto contendrá otro ` QDBusArgument`. Es responsabilidad del usuario desmarcarlo posteriormente a otro tipo.

Esta es una función sobrecargada.

const QDBusArgument &QDBusArgument::operator>>(QString &arg) const

Extrae un argumento primitivo de D-Bus de tipo « STRING » (cadena de caracteres Unicode) del flujo de D-Bus.

Se trata de una función sobrecargada.

const QDBusArgument &QDBusArgument::operator>>(QStringList &arg) const

Extrae una matriz de cadenas del flujo de D-Bus y la devuelve como un objeto ` QStringList`.

QStringList QByteArray y son los dos únicos tipos no primitivos que admite directamente debido a su uso generalizado en las aplicaciones Qt. QDBusArgument

El resto de matrices se admiten a través de tipos compuestos en ` Qt D-Bus`.

Esta es una función sobrecargada.

const QDBusArgument &QDBusArgument::operator>>(bool &arg) const

Extrae un argumento primitivo de D-Bus de tipo « BOOLEAN » del flujo de D-Bus.

Esta es una función sobrecargada.

const QDBusArgument &QDBusArgument::operator>>(double &arg) const

Extrae un argumento primitivo de D-Bus de tipo « DOUBLE » (punto flotante de doble precisión) del flujo de D-Bus.

Se trata de una función sobrecargada.

const QDBusArgument &QDBusArgument::operator>>(int &arg) const

Extrae un argumento primitivo de D-Bus de tipo « INT32 » del flujo de D-Bus.

Esta es una función sobrecargada.

const QDBusArgument &QDBusArgument::operator>>(qlonglong &arg) const

Extrae un argumento primitivo de D-Bus de tipo « INT64 » del flujo de D-Bus.

Esta es una función sobrecargada.

const QDBusArgument &QDBusArgument::operator>>(qulonglong &arg) const

Extrae un argumento primitivo de D-Bus de tipo « UINT64 » del flujo de D-Bus.

Esta es una función sobrecargada.

const QDBusArgument &QDBusArgument::operator>>(short &arg) const

Extrae un argumento primitivo de D-Bus de tipo « INT16 » del flujo de D-Bus.

Esta es una función sobrecargada.

const QDBusArgument &QDBusArgument::operator>>(uint &arg) const

Extrae un argumento primitivo de D-Bus de tipo « UINT32 » del flujo de D-Bus.

Esta es una función sobrecargada.

const QDBusArgument &QDBusArgument::operator>>(ushort &arg) const

Extrae un argumento primitivo de D-Bus de tipo UINT16 del flujo de D-Bus.

Esta es una función sobrecargada.

Elementos no miembros relacionados

template <typename T> QMetaType qDBusRegisterMetaType()

Registra ` T ` en el sistema de tipos deQt D-Bus y en Qt meta-type system, si aún no está registrado.

Para registrar un tipo, este debe declararse como un metatipo con la macro Q_DECLARE_METATYPE() y, a continuación, registrarse tal y como se muestra en el siguiente ejemplo:

#include <QDBusMetaType>

qDBusRegisterMetaType<MyClass>();

Si T no es una de las clases contenedoras de Qt, los operadores de streaming operator<< y operator>> entre T y QDBusArgument deben estar ya declarados. Consulta la página del sistema de tiposQt D-Bus para obtener más información sobre cómo declarar dichos tipos.

Esta función devuelve el identificador de metatipo Qt para el tipo (el mismo valor que devuelve qRegisterMetaType()).

Nota: La característica por la que un ` T ` que hereda de un tipo transmitible (incluidos los contenedores ` QList`, ` QHash ` o ` QMap`) puede transmitirse sin proporcionar ` operator<< ` y ` operator>> ` personalizados ha quedado obsoleta a partir de Qt 5.7, ya que ignora todo lo que hay en ` T ` excepto la clase base. No hay ningún mensaje de diagnóstico. Siempre debes proporcionar estos operadores para todos los tipos que desees transmitir y no confiar en los operadores de transmisión proporcionados por Qt para las clases base.

Nota: Esta función es segura para subprocesos.

Véase también Qt D-Bus Sistema de tipos, qRegisterMetaType() y QMetaType.

template <typename T> T qdbus_cast(const QDBusArgument &arg)

Intenta desmarcar el contenido de « arg » en el tipo « T ». Por ejemplo:

MyType item = qdbus_cast<Type>(argument);

Ten en cuenta que es equivalente a lo siguiente:

MyType item;
argument >> item;

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.