QDBusArgument Class

Documentation des fonctions membres

QDBusArgument::QDBusArgument()

Crée un objet `QDBusArgument` vide.

Un objet QDBusArgument vide ne permet ni la lecture ni l'écriture.

QDBusArgument::QDBusArgument(const QDBusArgument &other)

Crée une copie de l'objet QDBusArgument « other ».

Les deux objets auront donc le même état à partir de ce moment-là. Les QDBusArguments sont explicitement partagés ; par conséquent, toute modification apportée à l'une des deux copies affectera également l'autre.

[noexcept] QDBusArgument::~QDBusArgument()

Libère les ressources associées à cet objet « QDBusArgument ».

QVariant QDBusArgument::asVariant() const

Renvoie l'argument courant sous la forme d'un objet ` QVariant`. Les types de base seront décodés et renvoyés dans le ` QVariant`, mais pour les types complexes, cette fonction renverra un objet ` QDBusArgument ` dans le ` QVariant`. Il incombe à l'appelant de décoder l'argument (par exemple, en appelant la méthode `asVariant()` sur celui-ci).

Par exemple, si l'argument courant est un INT32, cette fonction renverra un QVariant avec un argument de type QMetaType::Int. Pour un tableau d'INT32, elle renverra un QVariant contenant un QDBusArgument.

Si une erreur se produit ou s’il n’y a plus d’arguments à décoder (c’est-à-dire que l’on se trouve à la fin de la liste d’arguments), cette fonction renvoie un QVariant invalide.

Voir également atEnd().

bool QDBusArgument::atEnd() const

Renvoie « true » s'il n'y a plus d'éléments à extraire de cet objet « QDBusArgument ». Cette fonction est généralement utilisée avec les objets « QDBusArgument » renvoyés par les méthodes « beginMap() » et « beginArray() ».

void QDBusArgument::beginArray() const

Effectue une récursion dans le tableau D-Bus pour permettre l'extraction des éléments du tableau.

Cette fonction est généralement utilisée dans les opérateurs de streaming d'operator>>, comme dans l'exemple suivant :

// 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 le type que vous souhaitez démarshaller est un ` QList ` ou l’une des classes de conteneurs Qt prenant un paramètre de modèle, vous n’avez pas besoin de déclarer de fonction ` operator>> ` pour celui-ci, car ` Qt D-Bus ` fournit des modèles génériques pour effectuer le démarshalling des données. Il en va de même pour les conteneurs de séquences de la STL, tels que ` std::list`, ` std::vector`, etc.

Voir également atEnd(), beginStructure() et beginMap().

void QDBusArgument::beginArray(QMetaType id)

Ouvre un nouveau tableau D-Bus permettant d'ajouter des éléments de méta-type « id ».

Cette fonction est généralement utilisée dans les opérateurs de flux operator<<, comme dans l'exemple suivant :

// 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 le type que vous souhaitez marshaller est un QList ou l'une des classes de conteneurs Qt prenant un paramètre de modèle, vous n'avez pas besoin de déclarer une fonction operator<< pour celui-ci, car Qt D-Bus fournit des modèles génériques permettant d'effectuer le marshalling des données. Il en va de même pour les conteneurs de séquences de la STL, tels que std::list, std::vector, etc.

Voir également endArray(), beginStructure() et beginMap().

void QDBusArgument::beginMap() const

Effectue une récursion dans la carte D-Bus afin de permettre l'extraction des éléments de celle-ci.

Cette fonction est généralement utilisée dans les opérateurs de streaming de type « operator>> », comme dans l'exemple suivant :

// 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 le type que vous souhaitez démarshaller est de type ` QMap ` ou ` QHash`, vous n’avez pas besoin de déclarer de fonction ` operator>> ` pour celui-ci, car ` Qt D-Bus ` fournit des modèles génériques pour effectuer le démarshalling des données.

Voir également endMap(), beginStructure(), beginArray() et beginMapEntry().

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

Ouvre une nouvelle carte D-Bus permettant d'ajouter des éléments. Les cartes sont des conteneurs qui associent une entrée (la clé) à une autre (la valeur), à l'instar de ` QMap ` ou ` QHash` de Qt. Les identifiants des méta-types de clé et de valeur de la carte doivent être transmis respectivement dans ` keyMetaType ` et ` valueMetaType `.

Cette fonction est généralement utilisée dans les opérateurs de flux de type ` operator<< `, comme dans l’exemple suivant :

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

En général, il n’est pas nécessaire de fournir une fonction operator<< ou operator>> pour les conteneurs associatifs tels que QHash ou std::map, car Qt D-Bus fournit des modèles génériques chargés de gérer le marshalling des données.

Voir également endMap(), beginStructure(), beginArray() et beginMapEntry().

void QDBusArgument::beginMapEntry()

Ouvre une entrée de table D-Bus permettant d'ajouter des entrées de clé et de valeur. Cette fonction n'est valable que si une table a été ouverte à l'aide de la fonction beginMap().

Voir beginMap() pour un exemple d'utilisation de cette fonction.

Voir également endMapEntry() et beginMap().

void QDBusArgument::beginMapEntry() const

Accède de manière récursive à l'entrée de la table D-Bus pour permettre l'extraction de la paire clé-valeur.

Voir beginMap() pour un exemple d'utilisation courante de cette fonction.

Voir également endMapEntry() et beginMap().

void QDBusArgument::beginStructure()

Ouvre une nouvelle structure D-Bus permettant d'ajouter de nouveaux arguments.

Cette fonction est généralement utilisée dans les opérateurs de streaming d’ operator<<, comme dans l’exemple suivant :

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

Les structures peuvent contenir d'autres structures ; le code suivant est donc également valide :

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

Voir également endStructure(), beginArray() et beginMap().

void QDBusArgument::beginStructure() const

Ouvre une structure D-Bus permettant d'extraire des éléments.

Cette fonction est généralement utilisée dans les opérateurs de flux d'operator>>, comme dans l'exemple suivant :

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

Voir également endStructure(), beginArray() et beginMap().

QDBusArgument::ElementType QDBusArgument::currentType() const

Renvoie la classification du type de l'élément courant. Si une erreur survient lors du décodage du type ou si l'on se trouve à la fin de l'argument, cette fonction renvoie « QDBusArgument::UnknownType ».

Cette fonction n'a de sens que lors du démarshalling des arguments. Si elle est utilisée lors du marshalling, elle renvoie toujours UnknownType.

void QDBusArgument::endArray()

Ferme un tableau D-Bus ouvert avec beginArray(). Cette fonction doit être appelée autant de fois qu’ beginArray() a été appelée.

Voir également beginArray(), endStructure() et endMap().

void QDBusArgument::endArray() const

Ferme le tableau D-Bus et permet d'extraire l'élément suivant après le tableau.

Voir aussi beginArray().

void QDBusArgument::endMap()

Ferme une carte D-Bus ouverte avec la fonction ` beginMap()`. Cette fonction doit être appelée autant de fois que la fonction ` beginMap()` a été appelée.

Voir également beginMap(), endStructure() et endArray().

void QDBusArgument::endMap() const

Ferme la carte D-Bus et permet d'extraire l'élément suivant après la carte.

Voir aussi beginMap().

void QDBusArgument::endMapEntry()

Ferme une entrée de la carte D-Bus ouverte avec ` beginMapEntry()`. Cette fonction doit être appelée autant de fois que la fonction ` beginMapEntry()` a été appelée.

Voir également beginMapEntry().

void QDBusArgument::endMapEntry() const

Ferme l'entrée de la carte D-Bus et permet d'extraire l'élément suivant de la carte.

Voir également beginMapEntry().

void QDBusArgument::endStructure()

Ferme une structure D-Bus ouverte avec la fonction beginStructure(). Cette fonction doit être appelée autant de fois qu’ beginStructure() a été appelée.

Voir également beginStructure(), endArray() et endMap().

void QDBusArgument::endStructure() const

Ferme la structure D-Bus et permet d'extraire l'élément suivant après la structure.

Voir aussi beginStructure().

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

Permute cet argument avec other. Cette opération est très rapide et ne rencontre jamais d'échec.

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

Ajoute la valeur primitive arg de type BYTE au flux D-Bus.

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

Ajoute la valeur primitive arg de type BOOLEAN au flux D-Bus.

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

Ajoute l'QByteArray, tel que défini par arg sous le nom ARRAY of BYTE, au flux D-Bus.

QStringList et QByteArray sont les deux seuls types non primitifs pris en charge directement par QDBusArgument en raison de leur utilisation très répandue dans les applications Qt.

Les autres tableaux sont pris en charge via des types composés dans Qt D-Bus.

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

Ajoute la valeur primitive arg de type VARIANT au flux D-Bus.

Un type « variant » D-Bus peut contenir n'importe quel type, y compris d'autres « variants ». Il est similaire au type « QVariant » de Qt.

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

Ajoute la valeur primitive arg de type STRING (chaîne de caractères Unicode) au flux D-Bus.

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

Ajoute l'QStringList, tel que défini par arg sous la forme ARRAY of STRING, au flux D-Bus.

QStringList QByteArray et sont les deux seuls types non primitifs pris en charge directement par en raison de leur utilisation très répandue dans les applications Qt. QDBusArgument

Les autres tableaux sont pris en charge via des types composés dans Qt D-Bus.

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

Ajoute la valeur primitive arg de type DOUBLE (nombre à virgule flottante double précision) au flux D-Bus.

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

Ajoute la valeur primitive arg de type INT32 au flux D-Bus.

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

Ajoute la valeur primitive arg de type INT64 au flux D-Bus.

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

Ajoute la valeur primitive arg de type UINT64 au flux D-Bus.

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

Ajoute la valeur primitive arg de type INT16 au flux D-Bus.

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

Ajoute la valeur primitive arg de type UINT32 au flux D-Bus.

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

Ajoute la valeur primitive arg de type UINT16 au flux D-Bus.

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

Copie l'objet other QDBusArgument dans celui-ci.

Les deux objets contiendront donc le même état à partir de ce moment-là. Les QDBusArguments sont explicitement partagés et, par conséquent, toute modification apportée à l'une des deux copies affectera également l'autre.

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

Extrait un argument de primitive D-Bus de type « BYTE » du flux D-Bus et le place dans « arg ».

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

Extrait un tableau d'octets du flux D-Bus et le renvoie sous la forme d'un objet ` QByteArray`.

QStringList QByteArray et sont les deux seuls types non primitifs pris en charge directement par en raison de leur utilisation très répandue dans les applications Qt. QDBusArgument

Les autres tableaux sont pris en charge via des types composés dans ` Qt D-Bus`.

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

Extrait un argument de type « VARIANT » du flux D-Bus.

Un type variant D-Bus peut contenir n'importe quel type, y compris d'autres variants. Il est similaire au type Qt ` QVariant `.

Si la variante contient un type non pris en charge directement par ` QDBusArgument`, la valeur de l'QDBusVariant renvoyée contiendra une autre ` QDBusArgument`. Il vous appartient de la démarshaller ultérieurement en un autre type.

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

Extrait un argument de type « STRING » (chaîne de caractères Unicode) du flux D-Bus.

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

Extrait un tableau de chaînes de caractères du flux D-Bus et le renvoie sous la forme d'un objet ` QStringList`.

QStringList QByteArray et sont les deux seuls types non primitifs pris en charge directement par en raison de leur utilisation très répandue dans les applications Qt. QDBusArgument

Les autres tableaux sont pris en charge via des types composés dans ` Qt D-Bus`.

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

Extrait un argument de type « BOOLEAN » du flux D-Bus.

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

Extrait un argument de type « DOUBLE » (nombre à virgule flottante double précision) du flux D-Bus.

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

Extrait un argument de type « INT32 » du flux D-Bus.

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

Extrait un argument de type « INT64 » du flux D-Bus.

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

Extrait un argument de type « UINT64 » du flux D-Bus.

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

Extrait un argument de type « INT16 » du flux D-Bus.

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

Extrait un argument de type « UINT32 » du flux D-Bus.

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

Extrait un argument de type « UINT16 » du flux D-Bus.