QDBusArgument Class

Documentation des fonctions membres

QDBusArgument::QDBusArgument()

Construit un argument QDBusArgument vide.

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

QDBusArgument::QDBusArgument(const QDBusArgument &other)

Construit une copie de l'objet other QDBusArgument.

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

[noexcept] QDBusArgument::~QDBusArgument()

Se débarrasse des ressources associées à cet objet QDBusArgument.

QVariant QDBusArgument::asVariant() const

Renvoie l'argument courant sous la forme d'un 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 asVariant() dans l'argument).

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.

En cas d'erreur ou s'il n'y a plus d'arguments à décoder (c'est-à-dire si nous sommes à la fin de la liste d'arguments), cette fonction renverra un QVariant invalide.

Voir aussi 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 dans les objets QDBusArgument renvoyés par beginMap() et beginArray().

void QDBusArgument::beginArray() const

Recourt à la récursivité 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 de 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 de Qt qui prennent un paramètre de modèle, vous n'avez pas besoin de déclarer une fonction operator>> pour cela, puisque Qt D-Bus fournit des modèles génériques pour faire le travail de démarshallisation des données. Il en va de même pour les conteneurs de séquence 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 adapté à l'ajout d'éléments du méta-type id.

Cette fonction est généralement utilisée dans les opérateurs de streaming 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 voulez marshaller est un QList ou n'importe quelle classe de conteneur de Qt qui prend un paramètre de modèle, vous n'avez pas besoin de déclarer une fonction operator<< pour cela, puisque Qt D-Bus fournit des modèles génériques pour faire le travail de marshalling des données. Il en va de même pour les conteneurs de séquence de la STL, tels que std::list, std::vector, etc.

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

void QDBusArgument::beginMap() const

Recourt à la carte D-Bus pour permettre l'extraction des éléments de la carte.

Cette fonction est généralement utilisée dans les opérateurs de streaming 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 un QMap ou un QHash, il n'est pas nécessaire de déclarer une fonction operator>> pour lui, puisque Qt D-Bus fournit des modèles génériques pour effectuer le travail de démarshallage des données.

Voir aussi 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), comme QMap ou QHash. Les identifiants des méta types clé et 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 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;
}

Il n'est généralement pas nécessaire de fournir une fonction operator<< ou operator>> pour les conteneurs associatifs tels que QHash ou std::map, puisque Qt D-Bus fournit des modèles génériques pour faire le travail de marshalling des données.

Voir aussi endMap(), beginStructure(), beginArray() et beginMapEntry().

void QDBusArgument::beginMapEntry()

Ouvre une entrée de carte D-Bus adaptée à l'ajout des entrées de clé et de valeur. Cette fonction n'est valable que lorsqu'une carte a été ouverte avec beginMap().

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

Voir également endMapEntry() et beginMap().

void QDBusArgument::beginMapEntry() const

Recourt à l'entrée de la carte D-Bus pour permettre l'extraction de la paire clé/valeur.

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

Voir également endMapEntry() et beginMap().

void QDBusArgument::beginStructure()

Ouvre une nouvelle structure D-Bus adaptée à l'ajout de nouveaux arguments.

Cette fonction est généralement utilisée dans les opérateurs de flux 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, de sorte que le code suivant est également valable :

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 adaptée à l'extraction d'éléments.

Cette fonction est généralement utilisée dans les opérateurs de flux 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 aussi endStructure(), beginArray() et beginMap().

QDBusArgument::ElementType QDBusArgument::currentType() const

Renvoie la classification du type de l'élément courant. Si une erreur de décodage du type se produit ou si nous sommes à la fin de l'argument, cette fonction renvoie QDBusArgument::UnknownType.

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

void QDBusArgument::endArray()

Ferme un tableau D-Bus ouvert avec beginArray(). Cette fonction doit être appelée le même nombre de fois que beginArray().

Voir aussi beginArray(), endStructure() et endMap().

void QDBusArgument::endArray() const

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

Voir aussi beginArray().

void QDBusArgument::endMap()

Ferme une carte D-Bus ouverte avec beginMap(). Cette fonction doit être appelée le même nombre de fois que beginMap().

Voir aussi beginMap(), endStructure() et endArray().

void QDBusArgument::endMap() const

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

Voir aussi beginMap().

void QDBusArgument::endMapEntry()

Ferme une entrée de carte D-Bus ouverte avec beginMapEntry(). Cette fonction doit être appelée le même nombre de fois que beginMapEntry().

Voir aussi beginMapEntry().

void QDBusArgument::endMapEntry() const

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

Voir aussi beginMapEntry().

void QDBusArgument::endStructure()

Ferme une structure D-Bus ouverte avec beginStructure(). Cette fonction doit être appelée le même nombre de fois que beginStructure().

Voir aussi beginStructure(), endArray() et endMap().

void QDBusArgument::endStructure() const

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

Voir également beginStructure().

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

Remplace cet argument par other. Cette opération est très rapide et n'échoue jamais.

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 le QByteArray donné par arg en tant que 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 répandue dans les applications Qt.

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

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

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

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

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 le QStringList donné par arg en tant que ARRAY of STRING 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 répandue dans les applications Qt.

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

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

Ajoute la valeur primitive arg de type DOUBLE (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. Les QDBusArguments sont explicitement partagés et, par conséquent, toute modification apportée à l'une des copies affectera également l'autre.

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

Extrait du flux D-Bus un argument primitif D-Bus de type BYTE 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 forme de QByteArray.

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

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

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

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

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

Si la variante contient un type qui n'est pas directement pris en charge par QDBusArgument, la valeur de QDBusVariant renvoyée contiendra un autre QDBusArgument. Il est de votre responsabilité de la transformer en un autre type.

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

Extrait un argument primitif D-Bus 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 forme de QStringList.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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