QDBusArgument Class

Dokumentation zu Mitgliedsfunktionen

QDBusArgument::QDBusArgument()

Erstellt ein leeres QDBusArgument-Objekt.

Ein leeres QDBusArgument-Objekt erlaubt weder Lese- noch Schreibvorgänge.

QDBusArgument::QDBusArgument(const QDBusArgument &other)

Erstellt eine Kopie des QDBusArgument-Objekts „ other “.

Beide Objekte weisen daher ab diesem Zeitpunkt denselben Zustand auf. QDBusArguments werden explizit gemeinsam genutzt, sodass sich jede Änderung an einer der beiden Kopien auch auf die andere auswirkt.

[noexcept] QDBusArgument::~QDBusArgument()

Gibt die mit diesem „ QDBusArgument “-Objekt verknüpften Ressourcen frei.

QVariant QDBusArgument::asVariant() const

Gibt das aktuelle Argument in Form eines ` QVariant` zurück. Grundtypen werden dekodiert und als ` QVariant` zurückgegeben; bei komplexen Typen gibt diese Funktion jedoch ein ` QDBusArgument `-Objekt im ` QVariant` zurück. Es liegt in der Verantwortung des Aufrufers, das Argument zu dekodieren (beispielsweise durch Aufruf von `asVariant()` darin).

Ist das aktuelle Argument beispielsweise ein INT32, gibt diese Funktion ein ` QVariant ` mit einem Argument vom Typ ` QMetaType::Int` zurück. Bei einem Array von INT32 gibt sie ein ` QVariant ` zurück, das ein ` QDBusArgument` enthält.

Tritt ein Fehler auf oder sind keine Argumente mehr zum Dekodieren vorhanden (d. h., wir befinden uns am Ende der Argumentliste), gibt diese Funktion ein ungültiges ` QVariant` zurück.

Siehe auch atEnd().

bool QDBusArgument::atEnd() const

Gibt „ true “ zurück, wenn aus diesem „ QDBusArgument “ keine Elemente mehr extrahiert werden können. Diese Funktion wird in der Regel bei „ QDBusArgument “-Objekten verwendet, die von den Funktionen „ beginMap()“ und „ beginArray()“ zurückgegeben werden.

void QDBusArgument::beginArray() const

Durchsucht das D-Bus-Array rekursiv, um die Extraktion der Array-Elemente zu ermöglichen.

Diese Funktion wird üblicherweise in Streaming-Operatoren von „ operator>> “ verwendet, wie im folgenden Beispiel gezeigt:

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

Wenn der Typ, den Sie demarshallen möchten, ein ` QList ` oder eine der Qt-Containerklassen ist, die einen Template-Parameter akzeptieren, müssen Sie keine ` operator>> `-Funktion dafür deklarieren, da ` Qt D-Bus ` generische Templates bereitstellt, die das Demarshalling der Daten übernehmen. Dasselbe gilt für die Sequenzcontainer der STL, wie z. B. ` std::list`, ` std::vector` usw.

Siehe auch atEnd(), beginStructure() und beginMap().

void QDBusArgument::beginArray(QMetaType id)

Öffnet ein neues D-Bus-Array, das zum Anhängen von Elementen des Metatyps „ id “ geeignet ist.

Diese Funktion wird üblicherweise in Streaming-Operatoren für ` operator<< ` verwendet, wie im folgenden Beispiel gezeigt:

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

Wenn der Typ, den Sie marshallen möchten, ein ` QList ` oder eine der Qt-Containerklassen ist, die einen Template-Parameter akzeptieren, müssen Sie keine ` operator<< `-Funktion dafür deklarieren, da ` Qt D-Bus ` generische Templates bereitstellt, die das Marshalling der Daten übernehmen. Dasselbe gilt für die Sequenzcontainer der STL, wie z. B. ` std::list`, ` std::vector` usw.

Siehe auch endArray(), beginStructure() und beginMap().

void QDBusArgument::beginMap() const

Greift rekursiv auf die D-Bus-Map zu, um die Elemente der Map zu extrahieren.

Diese Funktion wird üblicherweise in Streaming-Operatoren von „ operator>> “ verwendet, wie im folgenden Beispiel gezeigt:

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

Wenn der Typ, den Sie demarshallen möchten, ein ` QMap ` oder ` QHash` ist, müssen Sie keine ` operator>> `-Funktion dafür deklarieren, da ` Qt D-Bus ` generische Vorlagen bereitstellt, die das Demarshalling der Daten übernehmen.

Siehe auch endMap(), beginStructure(), beginArray() und beginMapEntry().

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

Öffnet eine neue Qt D-Bus-Map, die zum Hinzufügen von Elementen geeignet ist. Maps sind Container, die einen Eintrag (den Schlüssel) mit einem anderen (dem Wert) verknüpfen, wie beispielsweise Qt’s „ QMap “ oder „ QHash “. Die IDs der Meta-Typen für Schlüssel und Wert der Map müssen jeweils in „ keyMetaType “ und „ valueMetaType “ übergeben werden.

Diese Funktion wird üblicherweise in Streaming-Operatoren von operator<< verwendet, wie im folgenden Beispiel gezeigt:

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

Für assoziative Container wie QHash oder std::map müssen Sie in der Regel keine operator<< - oder operator>> -Funktion bereitstellen, da Qt D-Bus generische Vorlagen bereitstellt, die das Marshalling der Daten übernehmen.

Siehe auch ` endMap()`, ` beginStructure()`, ` beginArray()` und ` beginMapEntry()`.

void QDBusArgument::beginMapEntry()

Öffnet einen D-Bus-Map-Eintrag, in den Schlüssel- und Wert-Einträge hinzugefügt werden können. Diese Funktion ist nur gültig, wenn zuvor eine Map mit beginMap() geöffnet wurde.

Ein Anwendungsbeispiel für diese Funktion finden Sie unter ` beginMap()`.

Siehe auch „ endMapEntry()“ und „ beginMap()“.

void QDBusArgument::beginMapEntry() const

Greift rekursiv auf den D-Bus-Map-Eintrag zu, um das Schlüssel-Wert-Paar zu extrahieren.

Ein Beispiel für die übliche Verwendung dieser Funktion finden Sie unter beginMap().

Siehe auch endMapEntry() und beginMap().

void QDBusArgument::beginStructure()

Öffnet eine neue D-Bus-Struktur, an die neue Argumente angehängt werden können.

Diese Funktion wird üblicherweise in Streaming-Operatoren von „ operator<< “ verwendet, wie im folgenden Beispiel:

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

Strukturen können andere Strukturen enthalten, daher ist auch der folgende Code gültig:

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

Siehe auch „ endStructure()“, „ beginArray()“ und „ beginMap()“.

void QDBusArgument::beginStructure() const

Öffnet eine D-Bus-Struktur, aus der Elemente extrahiert werden können.

Diese Funktion wird üblicherweise in Streaming-Operatoren von „ operator>> “ verwendet, wie im folgenden Beispiel:

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

Siehe auch endStructure(), beginArray() und beginMap().

QDBusArgument::ElementType QDBusArgument::currentType() const

Gibt die Klassifizierung des aktuellen Elementtyps zurück. Tritt beim Dekodieren des Typs ein Fehler auf oder ist das Argument am Ende angelangt, gibt diese Funktion „ QDBusArgument::UnknownType “ zurück.

Diese Funktion ist nur beim Demarshalling von Argumenten sinnvoll. Wird sie beim Marshalling verwendet, gibt sie immer „ UnknownType “ zurück.

void QDBusArgument::endArray()

Schließt ein D-Bus-Array, das mit ` beginArray()` geöffnet wurde. Diese Funktion muss genauso oft aufgerufen werden wie ` beginArray()`.

Siehe auch „ beginArray()“, „ endStructure()“ und „ endMap()“.

void QDBusArgument::endArray() const

Schließt das D-Bus-Array und ermöglicht das Abrufen des nächsten Elements nach dem Array.

Siehe auch beginArray().

void QDBusArgument::endMap()

Schließt eine mit ` beginMap()` geöffnete D-Bus-Zuordnung. Diese Funktion muss genauso oft aufgerufen werden, wie ` beginMap()` aufgerufen wurde.

Siehe auch „ beginMap()“, „ endStructure()“ und „ endArray()“.

void QDBusArgument::endMap() const

Schließt die D-Bus-Map und ermöglicht das Extrahieren des nächsten Elements nach der Map.

Siehe auch beginMap().

void QDBusArgument::endMapEntry()

Schließt einen D-Bus-Map-Eintrag, der mit ` beginMapEntry()` geöffnet wurde. Diese Funktion muss genauso oft aufgerufen werden, wie ` beginMapEntry()` aufgerufen wurde.

Siehe auch beginMapEntry().

void QDBusArgument::endMapEntry() const

Schließt den D-Bus-Map-Eintrag und ermöglicht das Extrahieren des nächsten Elements in der Map.

Siehe auch beginMapEntry().

void QDBusArgument::endStructure()

Schließt eine mit ` beginStructure()` geöffnete D-Bus-Struktur. Diese Funktion muss genauso oft aufgerufen werden, wie ` beginStructure()` aufgerufen wurde.

Siehe auch „ beginStructure()“, „ endArray()“ und „ endMap()“.

void QDBusArgument::endStructure() const

Schließt die D-Bus-Struktur und ermöglicht das Extrahieren des nächsten Elements nach der Struktur.

Siehe auch beginStructure().

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

Tauscht dieses Argument mit „ other “ aus. Dieser Vorgang ist sehr schnell und schlägt niemals fehl.

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

Fügt den Primitivwert „ arg “ vom Typ „ BYTE “ an den D-Bus-Stream an.

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

Fügt den primitiven Wert „ arg “ vom Typ „ BOOLEAN “ an den D-Bus-Stream an.

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

Fügt den unter arg als ARRAY of BYTE angegebenen Typ „ QByteArray “ an den D-Bus-Stream an.

QStringList und QByteArray sind die einzigen beiden nicht-primitiven Typen, die von QDBusArgument direkt unterstützt werden, da sie in Qt-Anwendungen weit verbreitet sind.

Andere Arrays werden über zusammengesetzte Typen in Qt D-Bus unterstützt.

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

Fügt den primitiven Wert „ arg “ vom Typ „ VARIANT “ an den D-Bus-Stream an.

Ein D-Bus-Variantentyp kann jeden beliebigen Typ enthalten, einschließlich anderer Varianten. Er ähnelt dem Qt XML-Typ „ QVariant “.

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

Fügt den Primitivwert „ arg “ vom Typ „ STRING “ (Unicode-Zeichenkette) an den D-Bus-Stream an.

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

Fügt den unter arg als ARRAY of STRING angegebenen „ QStringList “ an den D-Bus-Stream an.

QStringList und QByteArray sind die einzigen beiden nicht-primitiven Typen, die von QDBusArgument direkt unterstützt werden, da sie in Qt-Anwendungen weit verbreitet sind.

Andere Arrays werden über zusammengesetzte Typen in Qt D-Bus unterstützt.

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

Fügt den primitiven Wert „ arg “ vom Typ „ DOUBLE “ (Gleitkomma mit doppelter Genauigkeit) an den D-Bus-Stream an.

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

Fügt den primitiven Wert „ arg “ vom Typ „ INT32 “ an den D-Bus-Stream an.

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

Fügt den primitiven Wert „ arg “ vom Typ „ INT64 “ an den D-Bus-Stream an.

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

Fügt den primitiven Wert „ arg “ vom Typ „ UINT64 “ an den D-Bus-Stream an.

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

Fügt den primitiven Wert „ arg “ vom Typ „ INT16 “ an den D-Bus-Stream an.

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

Fügt den primitiven Wert „ arg “ vom Typ „ UINT32 “ an den D-Bus-Stream an.

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

Fügt den primitiven Wert „ arg “ vom Typ „ UINT16 “ an den D-Bus-Stream an.

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

Kopiert das Objekt „ other “ QDBusArgument in dieses Objekt.

Beide Objekte weisen daher ab diesem Zeitpunkt denselben Zustand auf. QDBusArguments werden explizit gemeinsam genutzt, sodass sich jede Änderung an einer der beiden Kopien auch auf die andere auswirkt.

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

Extrahiert ein D-Bus-Primitiv-Argument vom Typ „ BYTE “ aus dem D-Bus-Stream und speichert es in „ arg “.

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

Extrahiert ein Byte-Array aus dem D-Bus-Stream und gibt es als ` QByteArray` zurück.

QStringList und ` QByteArray ` sind die einzigen beiden nicht-primitiven Typen, die von ` QDBusArgument ` direkt unterstützt werden, da sie in Qt-Anwendungen weit verbreitet sind.

Andere Arrays werden über zusammengesetzte Typen in ` Qt D-Bus` unterstützt.

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

Extrahiert ein D-Bus-Primitivargument vom Typ „ VARIANT “ aus dem D-Bus-Stream.

Ein D-Bus-Variantentyp kann jeden beliebigen Typ enthalten, einschließlich anderer Varianten. Er ähnelt dem Qt XML-Typ ` QVariant `.

Falls die Variante einen Typ enthält, der von ` QDBusArgument` nicht direkt unterstützt wird, enthält der Wert des zurückgegebenen ` QDBusVariant ` ein weiteres ` QDBusArgument`. Es liegt in Ihrer Verantwortung, dieses weiter in einen anderen Typ zu demarshallen.

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

Extrahiert ein D-Bus-Primitivargument vom Typ „ STRING “ (Unicode-Zeichenkette) aus dem D-Bus-Stream.

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

Extrahiert ein Array von Zeichenketten aus dem D-Bus-Stream und gibt es als ` QStringList` zurück.

QStringList und ` QByteArray ` sind die einzigen beiden nicht-primitiven Typen, die von ` QDBusArgument ` direkt unterstützt werden, da sie in Qt-Anwendungen weit verbreitet sind.

Andere Arrays werden über zusammengesetzte Typen in ` Qt D-Bus` unterstützt.

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

Extrahiert ein D-Bus-Primitivargument vom Typ „ BOOLEAN “ aus dem D-Bus-Stream.

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

Extrahiert ein D-Bus-Primitiv-Argument vom Typ „ DOUBLE “ (Gleitkommazahl mit doppelter Genauigkeit) aus dem D-Bus-Stream.

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

Extrahiert ein D-Bus-Primitivargument vom Typ „ INT32 “ aus dem D-Bus-Stream.

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

Extrahiert ein D-Bus-Primitivargument vom Typ „ INT64 “ aus dem D-Bus-Stream.

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

Extrahiert ein D-Bus-Primitiv-Argument vom Typ „ UINT64 “ aus dem D-Bus-Stream.

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

Extrahiert ein D-Bus-Primitiv-Argument vom Typ „ INT16 “ aus dem D-Bus-Stream.

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

Extrahiert ein D-Bus-Primitivargument vom Typ „ UINT32 “ aus dem D-Bus-Stream.

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

Extrahiert ein D-Bus-Primitivargument vom Typ „ UINT16 “ aus dem D-Bus-Stream.