QDBusArgument Class

Dokumentation der Mitgliedsfunktionen

QDBusArgument::QDBusArgument()

Konstruiert ein leeres QDBusArgument-Argument.

Ein leeres QDBusArgument-Objekt erlaubt weder das Lesen noch das Schreiben.

QDBusArgument::QDBusArgument(const QDBusArgument &other)

Konstruiert eine Kopie des other QDBusArgument-Objekts.

Beide Objekte enthalten daher ab diesem Zeitpunkt denselben Zustand. QDBusArguments werden explizit gemeinsam genutzt, daher wirkt sich jede Änderung an einer Kopie auch auf die andere aus.

[noexcept] QDBusArgument::~QDBusArgument()

Beseitigt die mit diesem QDBusArgument Objekt verbundenen Ressourcen.

QVariant QDBusArgument::asVariant() const

Gibt das aktuelle Argument in Form eines QVariant zurück. Grundtypen werden dekodiert und in QVariant zurückgegeben, aber für komplexe Typen gibt diese Funktion ein QDBusArgument Objekt in QVariant zurück. Es liegt in der Verantwortung des Aufrufers, das Argument zu dekodieren (z. B. durch Aufruf von asVariant()).

Wenn das aktuelle Argument beispielsweise ein INT32 ist, gibt diese Funktion ein QVariant mit einem Argument des Typs 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 gibt es keine weiteren Argumente mehr zu dekodieren (d.h. wir sind 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 es keine weiteren Elemente aus diesem QDBusArgument zu extrahieren gibt. Diese Funktion wird normalerweise in QDBusArgument Objekten verwendet, die von beginMap() und beginArray() zurückgegeben werden.

void QDBusArgument::beginArray() const

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

Diese Funktion wird normalerweise in operator>> Streaming Operatoren verwendet, wie im folgenden Beispiel:

// 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 demarshallieren wollen, ein QList oder eine der Qt-Containerklassen ist, die einen Template-Parameter annehmen, müssen Sie keine operator>> Funktion dafür deklarieren, da Qt D-Bus generische Templates bereitstellt, die die Aufgabe des Demarshallierens der Daten übernehmen. Das Gleiche gilt für die Sequenz-Container der STL, wie std::list, std::vector, usw.

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

void QDBusArgument::beginArray(QMetaType id)

Öffnet ein neues D-Bus-Array, das für das Anhängen von Elementen des Meta-Typs id geeignet ist.

Diese Funktion wird normalerweise in operator<< Streaming-Operatoren verwendet, wie im folgenden Beispiel:

// 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 marshallieren wollen, ein QList oder eine der Qt-Containerklassen ist, die einen Template-Parameter annehmen, brauchen Sie keine operator<< Funktion dafür zu deklarieren, da Qt D-Bus generische Templates zur Verfügung stellt, die die Aufgabe des Marshalling der Daten übernehmen. Dasselbe gilt für die Sequenz-Container der STL, wie std::list, std::vector, etc.

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

void QDBusArgument::beginMap() const

Rekursiert in die D-Bus-Map, um die Extraktion der Elemente der Map zu ermöglichen.

Diese Funktion wird normalerweise in operator>> Streaming-Operatoren verwendet, wie im folgenden Beispiel:

// 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 demarshallieren wollen, ein QMap oder QHash ist, brauchen Sie keine operator>> Funktion dafür zu deklarieren, da Qt D-Bus generische Templates zur Verfügung stellt, die die Aufgabe des Demarshallierens der Daten übernehmen.

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

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

Öffnet eine neue D-Bus-Map, die zum Anhängen von Elementen geeignet ist. Maps sind Container, die einen Eintrag (den Schlüssel) mit einem anderen (dem Wert) verknüpfen, wie z.B. Qt's QMap oder QHash. Die ids der Schlüssel- und Wert-Metatypen der Map müssen in keyMetaType bzw. valueMetaType übergeben werden.

Diese Funktion wird normalerweise in operator<< Streaming-Operatoren verwendet, wie im folgenden Beispiel:

// 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 Templates zur Verfügung stellt, die die Aufgabe des Marshalling der Daten übernehmen.

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

void QDBusArgument::beginMapEntry()

Öffnet einen D-Bus-Map-Eintrag, der zum Anhängen der Schlüssel- und Werteinträge geeignet ist. Diese Funktion ist nur gültig, wenn eine Map mit beginMap() geöffnet wurde.

Siehe beginMap() für ein Beispiel zur Verwendung dieser Funktion.

Siehe auch endMapEntry() und beginMap().

void QDBusArgument::beginMapEntry() const

Rekursiert in den D-Bus-Map-Eintrag, um die Extraktion des Schlüssel- und Wertepaares zu ermöglichen.

Siehe beginMap() für ein Beispiel, wie diese Funktion normalerweise verwendet wird.

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 normalerweise in operator<< Streaming-Operatoren 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, so dass der folgende Code ebenfalls gültig ist:

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, die für die Extraktion von Elementen geeignet ist.

Diese Funktion wird normalerweise in operator>> Streaming-Operatoren 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 ein Fehler bei der Dekodierung des Typs auf oder ist das Ende des Arguments erreicht, 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 mit beginArray() geöffnetes D-Bus-Array. Diese Funktion muss so oft aufgerufen werden, wie beginArray() aufgerufen wird.

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

void QDBusArgument::endArray() const

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

Siehe auch beginArray().

void QDBusArgument::endMap()

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

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 mit beginMapEntry() geöffneten D-Bus-Map-Eintrag. Diese Funktion muss so oft aufgerufen werden, wie beginMapEntry() aufgerufen wird.

Siehe auch beginMapEntry().

void QDBusArgument::endMapEntry() const

Schließt den D-Bus-Karteneintrag und ermöglicht das Extrahieren des nächsten Elements auf der Karte.

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().

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 nie fehl.

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

Hängt den primitiven Wert arg vom Typ BYTE an den D-Bus-Stream an.

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

Dies ist eine überladene Funktion.

Hängt den primitiven Wert arg vom Typ BOOLEAN an den D-Bus-Stream an.

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

Dies ist eine überladene Funktion.

Hängt die QByteArray von arg als ARRAY of BYTE an den D-Bus-Stream an.

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

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

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

Dies ist eine überladene Funktion.

Hängt den primitiven Wert arg vom Typ VARIANT an den D-Bus-Stream an.

Ein D-Bus-Variantentyp kann jeden Typ enthalten, einschließlich anderer Varianten. Er ist ähnlich wie der Typ Qt QVariant.

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

Dies ist eine überladene Funktion.

Hängt den primitiven Wert arg vom Typ STRING (Unicode-Zeichenfolge) an den D-Bus-Stream an.

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

Dies ist eine überladene Funktion.

Hängt die QStringList von arg als ARRAY of STRING an den D-Bus-Stream an.

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

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

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

Dies ist eine überladene Funktion.

Hängt den primitiven Wert arg vom Typ DOUBLE (double-precision floating-point) an den D-Bus-Stream an.

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

Dies ist eine überladene Funktion.

Hängt den primitiven Wert arg vom Typ INT32 an den D-Bus-Stream an.

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

Dies ist eine überladene Funktion.

Hängt den primitiven Wert arg vom Typ INT64 an den D-Bus-Stream an.

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

Dies ist eine überladene Funktion.

Hängt den primitiven Wert arg vom Typ UINT64 an den D-Bus-Stream an.

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

Dies ist eine überladene Funktion.

Hängt den primitiven Wert arg vom Typ INT16 an den D-Bus-Stream an.

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

Dies ist eine überladene Funktion.

Hängt den primitiven Wert arg vom Typ UINT32 an den D-Bus-Stream an.

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

Dies ist eine überladene Funktion.

Hängt 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 enthalten daher ab diesem Zeitpunkt denselben Zustand. QDBusArguments werden explizit gemeinsam genutzt, daher wirkt sich jede Änderung an einer Kopie auch auf die andere aus.

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

Extrahiert ein primitives D-Bus-Argument vom Typ BYTE aus dem D-Bus-Stream und stellt es in arg ein.

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

Dies ist eine überladene Funktion.

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

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

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

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

Dies ist eine überladene Funktion.

Extrahiert ein primitives D-Bus-Argument vom Typ VARIANT aus dem D-Bus-Stream.

Ein D-Bus-Variantentyp kann jeden Typ enthalten, einschließlich anderer Varianten. Er ist vergleichbar mit dem Typ Qt QVariant.

Falls die Variante einen Typ enthält, der nicht direkt von QDBusArgument unterstützt wird, enthält der Wert des zurückgegebenen QDBusVariant ein anderes QDBusArgument. Es liegt in Ihrer Verantwortung, ihn in einen anderen Typ umzuwandeln.

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

Dies ist eine überladene Funktion.

Extrahiert ein primitives D-Bus-Argument vom Typ STRING (Unicode-Zeichenfolge) aus dem D-Bus-Stream.

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

Dies ist eine überladene Funktion.

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

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

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

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

Dies ist eine überladene Funktion.

Extrahiert ein primitives D-Bus-Argument vom Typ BOOLEAN aus dem D-Bus-Stream.

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

Dies ist eine überladene Funktion.

Extrahiert ein primitives D-Bus-Argument vom Typ DOUBLE (double-precision floating point) aus dem D-Bus-Stream.

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

Dies ist eine überladene Funktion.

Extrahiert ein primitives D-Bus-Argument vom Typ INT32 aus dem D-Bus-Stream.

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

Dies ist eine überladene Funktion.

Extrahiert ein primitives D-Bus-Argument vom Typ INT64 aus dem D-Bus-Stream.

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

Dies ist eine überladene Funktion.

Extrahiert ein primitives D-Bus-Argument vom Typ UINT64 aus dem D-Bus-Stream.

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

Dies ist eine überladene Funktion.

Extrahiert ein primitives D-Bus-Argument vom Typ INT16 aus dem D-Bus-Stream.

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

Dies ist eine überladene Funktion.

Extrahiert ein primitives D-Bus-Argument vom Typ UINT32 aus dem D-Bus-Stream.

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

Dies ist eine überladene Funktion.

Extrahiert ein primitives D-Bus-Argument vom Typ UINT16 aus dem D-Bus-Stream.