QUuid Class
La classe QUuid stocke un identifiant unique universel (UUID). En savoir plus...
| En-tête : | #include <QUuid> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake : | QT += core |
| Hérité par : |
Remarque : toutes les fonctions de cette classe sont réentrantes.
Comparaisons QUuid
| Catégorie | Types comparables | Description |
|---|---|---|
| strong | QUuid | |
| strong | GUID. | Remarque : la comparaison avec GUID est réservée à Windows. |
Types publics
(since 6.6) union | Id128Bytes |
| enum | StringFormat { WithBraces, WithoutBraces, Id128 } |
| enum | Variant { VarUnknown, NCS, DCE, Microsoft, Reserved } |
| enum | Version { VerUnknown, Time, EmbeddedPOSIX, Name, Md5, …, UnixEpoch } |
Fonctions publiques
| QUuid() | |
| QUuid(QAnyStringView text) | |
| QUuid(const GUID &guid) | |
(since 6.6) | QUuid(QUuid::Id128Bytes id128, QSysInfo::Endian order = QSysInfo::BigEndian) |
| QUuid(uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8) | |
| bool | isNull() const |
| QByteArray | toByteArray(QUuid::StringFormat mode = WithBraces) const |
(since 6.6) QUuid::Id128Bytes | toBytes(QSysInfo::Endian order = QSysInfo::BigEndian) const |
| CFUUIDRef | toCFUUID() const |
| NSUUID * | toNSUUID() const |
| QByteArray | toRfc4122() const |
| QString | toString(QUuid::StringFormat mode = WithBraces) const |
(since 6.6) quint128 | toUInt128(QSysInfo::Endian order = QSysInfo::BigEndian) const |
| QUuid::Variant | variant() const |
| QUuid::Version | version() const |
| operator GUID() const | |
| QUuid & | operator=(const GUID &guid) |
Membres publics statiques
| QUuid | createUuid() |
| QUuid | createUuidV3(QUuid ns, QByteArrayView baseData) |
| QUuid | createUuidV3(const QUuid &ns, const QString &baseData) |
| QUuid | createUuidV5(QUuid ns, QByteArrayView baseData) |
| QUuid | createUuidV5(const QUuid &ns, const QString &baseData) |
(since 6.9) QUuid | createUuidV7() |
(since 6.6) QUuid | fromBytes(const void *bytes, QSysInfo::Endian order = QSysInfo::BigEndian) |
| QUuid | fromCFUUID(CFUUIDRef uuid) |
| QUuid | fromNSUUID(const NSUUID *uuid) |
| QUuid | fromRfc4122(QByteArrayView bytes) |
| QUuid | fromString(QAnyStringView string) |
(since 6.6) QUuid | fromUInt128(quint128 uuid, QSysInfo::Endian order = QSysInfo::BigEndian) |
Éléments non membres associés
| size_t | qHash(const QUuid &key, size_t seed = 0) |
| bool | operator!=(const QUuid &lhs, const GUID &rhs) |
| bool | operator!=(const QUuid &lhs, const QUuid &rhs) |
| bool | operator<(const QUuid &lhs, const QUuid &rhs) |
| QDataStream & | operator<<(QDataStream &s, const QUuid &id) |
| QDebug | operator<<(QDebug dbg, const QUuid &id) |
| bool | operator<=(const QUuid &lhs, const QUuid &rhs) |
| bool | operator==(const QUuid &lhs, const GUID &rhs) |
| bool | operator==(const QUuid &lhs, const QUuid &rhs) |
| bool | operator>(const QUuid &lhs, const QUuid &rhs) |
| bool | operator>=(const QUuid &lhs, const QUuid &rhs) |
| QDataStream & | operator>>(QDataStream &s, QUuid &id) |
Description détaillée
L'utilisation d'identifiants universellement uniques(UUID) est une méthode standard permettant d'identifier de manière unique des entités dans un environnement informatique distribué. Un UUID est un nombre de 16 octets (128 bits) généré par un algorithme destiné à garantir que cet identifiant sera unique dans l'environnement informatique distribué où il est utilisé. L'acronyme GUID ( Globally Unique IDentifiers, identifiants globalement uniques) est souvent utilisé à la place, mais il désigne la même chose.
En réalité, le GUID est une variante de l’UUID. Plusieurs variantes sont utilisées. Chaque UUID contient un champ de bits qui spécifie de quel type (variante) d’UUID il s’agit. Appelez la méthode ` variant()` pour déterminer le type d’UUID contenu dans une instance de `QUuid`. Cette méthode extrait les trois bits les plus significatifs de l’octet 8 parmi les 16 octets. Dans QUuid, l’octet 8 est QUuid::data4[0]. Si vous créez des instances de QUuid à l’aide du constructeur qui accepte toutes les valeurs numériques en tant que paramètres, utilisez le tableau suivant pour définir les trois bits les plus significatifs du paramètre b1, qui devient QUuid::data4[0] et contient le champ de variante dans ses trois bits les plus significatifs. Dans le tableau, « x » signifie « indifférent ».
| msb0 | msb1 | msb2 | Variant |
|---|---|---|---|
| 0 | x | x | NCS (Network Computing System) |
| 1 | 0 | x | DCE (Distributed Computing Environment) |
| 1 | 1 | 0 | Microsoft (GUID) |
| 1 | 1 | 1 | Réservé pour une extension future |
Si la fonction ` variant()` renvoie ` QUuid::DCE`, l'UUID contient également un champ de version dans les quatre bits les plus significatifs de ` QUuid::data3`, et vous pouvez appeler ` version()` pour connaître la version contenue dans votre QUuid. Si vous créez des instances de QUuid à l’aide du constructeur qui accepte toutes les valeurs numériques comme paramètres, utilisez le tableau suivant pour définir les quatre bits les plus significatifs du paramètre w2, qui devient QUuid::data3 et contient le champ de version dans ses quatre bits les plus significatifs.
| msb0 | msb1 | msb2 | msb3 | Version |
|---|---|---|---|---|
| 0 | 0 | 0 | 1 | Heure |
| 0 | 0 | 1 | 0 | POSIX embarqué |
| 0 | 0 | 1 | 1 | Md5(Nom) |
| 0 | 1 | 0 | 0 | Aléatoire |
| 0 | 1 | 0 | 1 | Sha1 |
Les structures de champs des versions DCE répertoriées dans le tableau ci-dessus sont définies dans la spécification UUID du groupe de travail sur les réseaux.
La plupart des plateformes fournissent un outil permettant de générer de nouveaux UUID, par exemple uuidgen et guidgen. Vous pouvez également utiliser createUuid(). Les UUID générés par createUuid() sont de type aléatoire. Leurs bits d'QUuid::Version sont définis sur QUuid::Random, et leurs bits d'QUuid::Variant sur QUuid::DCE. Le reste de l'UUID est composé de nombres aléatoires. Théoriquement, cela signifie qu'il existe une faible probabilité qu'un UUID généré par createUuid() ne soit pas unique. Mais cette probabilité est très faible.
Les UUID peuvent être construits à partir de valeurs numériques ou de chaînes de caractères, ou à l’aide de la fonction statique createUuid(). Ils peuvent être convertis en chaîne de caractères avec toString(). Les UUID disposent d’une fonction variant() et d’une fonction version(), et les UUID nuls renvoient « true » lorsqu’on appelle isNull().
Documentation sur les types de membres
enum QUuid::StringFormat
Cette énumération est utilisée par la méthode ` toString` (StringFormat) pour contrôler le formatage de la représentation sous forme de chaîne. Les valeurs possibles sont les suivantes :
| Constante | Valeur | Description |
|---|---|---|
QUuid::WithBraces | 0 | Valeur par défaut : la méthode toString() renvoie cinq champs hexadécimaux, séparés par des tirets et entourés d'accolades. Exemple : {00000000-0000-0000-0000-000000000000}. |
QUuid::WithoutBraces | 1 | Uniquement les cinq champs séparés par des tirets, sans les accolades. Exemple : 00000000-0000-0000-0000-000000000000. |
QUuid::Id128 | 3 | Uniquement les chiffres hexadécimaux, sans accolades ni tirets. Notez que QUuid ne peut pas réinterpréter cette forme comme entrée. |
enum QUuid::Variant
Cette énumération définit les valeurs utilisées dans l'variant field ation de l'UUID. La valeur du champ « variant » détermine la structure de la valeur de 128 bits.
| Constante | Valeur | Description |
|---|---|---|
QUuid::VarUnknown | -1 | La variante est inconnue |
QUuid::NCS | 0 | Réservé à la rétrocompatibilité avec le NCS (Network Computing System) |
QUuid::DCE | 2 | Environnement informatique distribué, le schéma utilisé par QUuid |
QUuid::Microsoft | 6 | Réservé à la rétrocompatibilité Microsoft (GUID) |
QUuid::Reserved | 7 | Réservé pour une définition future |
enum QUuid::Version
Cette énumération définit les valeurs utilisées dans l'version field e de l'UUID. Le champ « version » n'a de sens que si la valeur du champ « variant field » est « QUuid::DCE ».
| Constante | Valeur | Description |
|---|---|---|
QUuid::VerUnknown | -1 | Version inconnue |
QUuid::Time | 1 | Basée sur le temps, en utilisant l’horodatage, la séquence d’horloge et l’adresse MAC de la carte réseau (si disponible) pour les sections de nœud |
QUuid::EmbeddedPOSIX | 2 | Version de sécurité DCE, avec UUID POSIX intégrés |
QUuid::Name | Md5 | Basée sur le nom, en utilisant les valeurs d’un nom pour toutes les sections |
QUuid::Md5 | 3 | Alias pour le nom |
QUuid::Random | 4 | Basée sur le hasard, en utilisant des nombres aléatoires pour toutes les sections |
QUuid::Sha1 | 5 | Version basée sur le nom utilisant le hachage SHA-1 |
QUuid::UnixEpoch | 7 | [depuis la version 6.9] UUID basé sur le temps, utilisant le nombre de millisecondes écoulées depuis l'époque UNIX |
Documentation des fonctions membres
[constexpr noexcept] QUuid::QUuid()
Crée un UUID nul. La fonction ` toString()` renvoie cet UUID nul sous la forme « {00000000-0000-0000-0000-000000000000} ».
[explicit noexcept] QUuid::QUuid(QAnyStringView text)
Crée un objet QUuid à partir de la chaîne « text », qui doit être formatée sous la forme de cinq champs hexadécimaux séparés par « - », par exemple « {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} », où chaque « x » correspond à un chiffre hexadécimal. Les accolades indiquées ici sont facultatives, mais il est courant de les inclure. Si la conversion échoue, un UUID nul est créé. Voir toString() pour une explication de la correspondance entre les cinq champs hexadécimaux et les membres de données publics de QUuid.
Remarque : dans les versions de Qt antérieures à la version 6.3, ce constructeur était un ensemble de surcharges comprenant QString, QByteArray et const char*, au lieu d’un seul constructeur prenant QAnyStringView.
Voir également toString() et QUuid().
[constexpr noexcept] QUuid::QUuid(const GUID &guid)
Convertit un identifiant Windows ( guid ) en un QUuid Qt.
Avertissement : cette fonction est réservée aux plateformes Windows.
[explicit noexcept, since 6.6] QUuid::QUuid(QUuid::Id128Bytes id128, QSysInfo::Endian order = QSysInfo::BigEndian)
Crée un QUuid à partir du paramètre entier ` id128 `. Le paramètre d'entrée ` id128 ` est considéré comme ayant l'ordre des octets ` order`.
Cette fonction a été introduite dans Qt 6.6.
Voir également fromBytes(), toBytes(), toRfc4122() et toUInt128().
[constexpr noexcept] QUuid::QUuid(uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8)
Crée un UUID dont la valeur est spécifiée par les paramètres suivants : l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8.
Exemple :
// {67C8770B-44F1-410A-AB9A-F9B5446F13EE}
QUuid IID_MyInterface(0x67c8770b, 0x44f1, 0x410a, 0xab, 0x9a, 0xf9, 0xb5, 0x44, 0x6f, 0x13, 0xee);[static] QUuid QUuid::createUuid()
Sur toute plateforme autre que Windows, cette fonction renvoie un nouvel UUID dont la variante est QUuid::DCE et la version QUuid::Random. Sous Windows, un GUID est généré à l'aide de l'API Windows et sera du type défini par l'API.
Voir également variant() et version().
[static noexcept] QUuid QUuid::createUuidV3(QUuid ns, QByteArrayView baseData)
Cette fonction renvoie un nouvel UUID dont la variante est QUuid::DCE et la version QUuid::Md5. ns correspond à l'espace de noms et baseData aux données de base, conformément à la norme RFC 4122.
Remarque : dans les versions de Qt antérieures à la version 6.8, cette fonction prenait en paramètre QByteArray et non QByteArrayView.
Voir également variant(), version(), createUuidV5() et createUuidV7().
[static] QUuid QUuid::createUuidV3(const QUuid &ns, const QString &baseData)
Cette fonction renvoie un nouvel UUID dont la variante est QUuid::DCE et la version QUuid::Md5. ns correspond à l'espace de noms et baseData aux données de base, conformément à la norme RFC 4122.
Voir également variant(), version(), createUuidV5() et createUuidV7().
[static noexcept] QUuid QUuid::createUuidV5(QUuid ns, QByteArrayView baseData)
Cette fonction renvoie un nouvel UUID dont la variante est QUuid::DCE et la version QUuid::Sha1. ns correspond à l'espace de noms et baseData aux données de base, conformément à la norme RFC 4122.
Remarque : dans les versions de Qt antérieures à la version 6.8, cette fonction prenait en paramètre QByteArray et non QByteArrayView.
Voir également variant(), version() et createUuidV3().
[static] QUuid QUuid::createUuidV5(const QUuid &ns, const QString &baseData)
Cette fonction renvoie un nouvel UUID dont la variante est QUuid::DCE et la version QUuid::Sha1. ns correspond à l'espace de noms et baseData aux données de base, conformément à la norme RFC 4122.
Voir également variant(), version() et createUuidV3().
[static, since 6.9] QUuid QUuid::createUuidV7()
Cette fonction renvoie un nouvel UUID dont la variante est QUuid::DCE et la version QUuid::UnixEpoch.
Elle utilise un champ de valeur ordonné dans le temps, dérivé du nombre de millisecondes écoulées depuis l'époque UNIX, comme décrit dans la RFC 9562.
Cette fonction a été introduite dans Qt 6.9.
Voir également variant(), version(), createUuidV3() et createUuidV5().
[static, since 6.6] QUuid QUuid::fromBytes(const void *bytes, QSysInfo::Endian order = QSysInfo::BigEndian)
Lit 128 bits (16 octets) à partir de ` bytes ` en utilisant l'ordre des octets ` order ` et renvoie la ` QUuid ` correspondant à ces octets. Cette fonction se comporte de la même manière que ` fromRfc4122()` si l'ordre des octets ` order ` est ` QSysInfo::BigEndian`.
Cette fonction a été introduite dans Qt 6.6.
Voir également fromRfc4122().
[static] QUuid QUuid::fromCFUUID(CFUUIDRef uuid)
Crée un nouvel objet ` QUuid ` contenant une copie du CFUUID ` uuid `.
Remarque : cette fonction n'est disponible que sur les plateformes Apple.
[static] QUuid QUuid::fromNSUUID(const NSUUID *uuid)
Crée un nouvel objet ` QUuid ` contenant une copie de l'identifiant NSUUID de ` uuid `.
Remarque : cette fonction n'est disponible que sur les plateformes Apple.
[static noexcept] QUuid QUuid::fromRfc4122(QByteArrayView bytes)
Crée un objet ` QUuid ` à partir de la représentation binaire de l'UUID, conformément à la section 4.1.2 de la RFC 4122. Voir ` toRfc4122()` pour plus d'explications sur l'ordre des ` bytes ` requis.
Le tableau d’octets accepté n’est PAS au format lisible par l’utilisateur.
Si la conversion échoue, un UUID nul est créé.
Remarque : dans les versions de Qt antérieures à la version 6.3, cette fonction prenait en paramètre ` QByteArray`, et non ` QByteArrayView`.
Voir également toRfc4122(), QUuid() et fromBytes().
[static noexcept] QUuid QUuid::fromString(QAnyStringView string)
Crée un objet ` QUuid ` à partir de la chaîne ` string`, qui doit être formatée sous la forme de cinq champs hexadécimaux séparés par un tiret « - », par exemple « {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} », où chaque « x » représente un chiffre hexadécimal. Les accolades indiquées ici sont facultatives, mais il est courant de les inclure. Si la conversion échoue, un UUID nul est renvoyé. Voir toString() pour une explication de la correspondance entre les cinq champs hexadécimaux et les membres de données publics de QUuid.
Remarque : dans les versions de Qt antérieures à la version 6.3, cette fonction était un ensemble de surcharges comprenant QStringView et QLatin1StringView, au lieu d'une seule fonction prenant QAnyStringView.
Voir également toString() et QUuid().
[static constexpr noexcept, since 6.6] QUuid QUuid::fromUInt128(quint128 uuid, QSysInfo::Endian order = QSysInfo::BigEndian)
Crée un objet de type ` QUuid ` à partir du paramètre entier ` uuid `. Le paramètre d'entrée ` uuid ` est considéré comme ayant l'ordre des octets ` order`.
Remarque : cette fonction n’est disponible que sur les plateformes proposant un type entier de 128 bits.
Cette fonction a été introduite dans Qt 6.6.
Voir également toUInt128(), fromBytes(), toBytes() et toRfc4122().
[constexpr noexcept] bool QUuid::isNull() const
Renvoie « true » s'il s'agit de l'UUID nul {00000000-0000-0000-0000-000000000000 } ; sinon, renvoie « false ».
QByteArray QUuid::toByteArray(QUuid::StringFormat mode = WithBraces) const
Renvoie la représentation sous forme de chaîne de caractères de cet objet ` QUuid`, dont le formatage est contrôlé par le paramètre ` mode `. De gauche à droite, les cinq champs hexadécimaux sont extraits des quatre membres de données publics de ` QUuid ` comme suit :
| Champ n° | Source |
|---|---|
| 1 | data1 |
| 2 | données2 |
| 3 | données3 |
| 4 | données4[0] .. données4[1] |
| 5 | data4[2] .. data4[7] |
[noexcept, since 6.6] QUuid::Id128Bytes QUuid::toBytes(QSysInfo::Endian order = QSysInfo::BigEndian) const
Renvoie un identifiant de 128 bits généré à partir de cette adresse QUuid selon l’ordre des octets spécifié par order. Le contenu binaire de cette fonction est identique à celui de toRfc4122() si l’ordre est QSysInfo::BigEndian. Reportez-vous à cette fonction pour plus de détails.
Cette fonction a été introduite dans Qt 6.6.
Voir également toRfc4122(), fromBytes() et QUuid().
CFUUIDRef QUuid::toCFUUID() const
Crée un CFUUID à partir d'un identifiant « QUuid ».
L'appelant est propriétaire du CFUUID et est chargé de le libérer.
Remarque : cette fonction n'est disponible que sur les plateformes Apple.
NSUUID *QUuid::toNSUUID() const
Crée un NSUUID à partir d'un « QUuid ».
Le NSUUID est libéré automatiquement.
Remarque : cette fonction n'est disponible que sur les plateformes Apple.
QByteArray QUuid::toRfc4122() const
Renvoie la représentation binaire de cet QUuid. Le tableau d'octets est au format « big-endian » et respecté la norme RFC 4122, section 4.1.2 — « Disposition et ordre des octets ».
L'ordre est le suivant :
| Champ n° | Source |
|---|---|
| 1 | data1 |
| 2 | données2 |
| 3 | données3 |
| 4 | data4[0] .. data4[7] |
Les octets du tableau d’octets renvoyé par cette fonction contiennent le même contenu binaire que la fonction toBytes().
Voir également toBytes().
QString QUuid::toString(QUuid::StringFormat mode = WithBraces) const
Renvoie la représentation sous forme de chaîne de caractères de cet objet ` QUuid`, dont le formatage est contrôlé par le paramètre ` mode `. De gauche à droite, les cinq champs hexadécimaux sont extraits des quatre membres de données publics de ` QUuid ` comme suit :
| Champ n° | Source |
|---|---|
| 1 | data1 |
| 2 | données2 |
| 3 | données3 |
| 4 | données4[0] .. données4[1] |
| 5 | data4[2] .. data4[7] |
[constexpr noexcept, since 6.6] quint128 QUuid::toUInt128(QSysInfo::Endian order = QSysInfo::BigEndian) const
Renvoie un entier de 128 bits créé à partir de cette QUuid selon l'ordre des octets spécifié par order. Le contenu binaire de cette fonction est identique à celui de toRfc4122() si l'ordre est QSysInfo::BigEndian. Voir cette fonction pour plus de détails.
Remarque : cette fonction n'est disponible que sur les plateformes proposant un type d'entier de 128 bits.
Cette fonction a été introduite dans Qt 6.6.
Voir également toRfc4122(), fromUInt128(), toBytes(), fromBytes() et QUuid().
[constexpr noexcept] QUuid::Variant QUuid::variant() const
Renvoie la valeur contenue dans la partie « variant field » de l'UUID. Si la valeur renvoyée est « QUuid::DCE », appelez la fonction version() pour déterminer la structure utilisée. Un UUID nul est considéré comme étant d'une variante inconnue.
Voir également version().
[constexpr noexcept] QUuid::Version QUuid::version() const
Renvoie la valeur « version field » de l'UUID si l'variant field de l'UUID est « QUuid::DCE ». Dans le cas contraire, elle renvoie « QUuid::VerUnknown ».
Voir aussi variant().
[constexpr noexcept] QUuid::operator GUID() const
Renvoie un GUID Windows à partir d'un objet ` QUuid`.
Avertissement : cette fonction est réservée aux plateformes Windows.
[constexpr noexcept] QUuid &QUuid::operator=(const GUID &guid)
Attribue guid Windows à QUuid Qt XML.
Avertissement : cette fonction est réservée aux plateformes Windows.
Éléments non membres associés
[noexcept] size_t qHash(const QUuid &key, size_t seed = 0)
Renvoie la valeur de hachage de key, en utilisant seed comme graine pour le calcul.
[constexpr noexcept] bool operator!=(const QUuid &lhs, const GUID &rhs)
Renvoie « true » si l'UUID lhs n'est pas égal au GUID Windows rhs; sinon, renvoie « false ».
[constexpr noexcept] bool operator!=(const QUuid &lhs, const QUuid &rhs)
Renvoie « true » si « lhs » QUuid et « rhs » QUuid sont différents ; sinon, renvoie « false ».
[constexpr noexcept] bool operator<(const QUuid &lhs, const QUuid &rhs)
[constexpr noexcept] bool operator<=(const QUuid &lhs, const QUuid &rhs)
[constexpr noexcept] bool operator>(const QUuid &lhs, const QUuid &rhs)
[constexpr noexcept] bool operator>=(const QUuid &lhs, const QUuid &rhs)
Effectue une comparaison entre lhs et rhs et renvoie true si l'ordre relatif de lhs et rhs est correct pour l'opération en question, false dans le cas contraire. Notez que l'ordre établi par cette fonction peut ne pas correspondre à celui des chaînes de caractères créées par toString(), ni à celui des entiers générés par toId128(), ni à celui du tableau d'octets renvoyé par toBytes() et toRfc4122().
Voir également variant().
QDataStream &operator<<(QDataStream &s, const QUuid &id)
Écrit l'UUID id dans le flux de données s.
QDebug operator<<(QDebug dbg, const QUuid &id)
Écrit l'UUID id dans le flux de sortie pour les informations de débogage dbg.
[constexpr noexcept] bool operator==(const QUuid &lhs, const GUID &rhs)
Renvoie « true » si l'UUID lhs est identique au GUID Windows rhs; sinon, renvoie « false ».
[constexpr noexcept] bool operator==(const QUuid &lhs, const QUuid &rhs)
Renvoie « true » si « lhs » QUuid et « rhs » QUuid sont identiques ; sinon, renvoie « false ».
QDataStream &operator>>(QDataStream &s, QUuid &id)
Lit un UUID à partir du flux s et l'enregistre dans id.
© 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.
