Entrée et sortie de données

Cette page présente un aperçu des différentes méthodes permettant de récupérer et d'enregistrer des données à l'aide de Qt.

Enregistrement et chargement de données

La classe ` QIODevice ` est la classe de base de tous les périphériques de stockage de fichiers et de données dans Qt Core. Toutes les classes utilisées pour la lecture et l’écriture de données en héritent.

Parmi ces périphériques, on peut citer notamment : ` QFile`, ` QBuffer`, ` QTcpSocket` et ` QProcess`. ` QFile ` est utilisé pour lire et écrire du texte, des fichiers binaires et des ressources, à l’aide de l’interface ` QIODevice `. Un ` QFile ` peut être utilisé tel quel ou, de manière plus pratique, avec un ` QTextStream ` ou un ` QDataStream`.

La classe ` QBuffer ` fournit une interface ` QIODevice ` pour un ` QByteArray`. ` QTcpSocket ` permet au développeur d’établir une connexion TCP et de transférer des flux de données. ` QProcess ` est utilisé pour lancer des programmes externes, ainsi que pour lire et écrire dans ce processus.

• Entrée/sortie et réseau (liste des classes liées aux E/S)
• Fonctions de fichiers et de flux de données

Données sérialisées

L'API Qt prend en charge la sérialisation des données pour plusieurs cas d'utilisation.

• La prise en charge deJSON dans Qt fournit une API C++ facile à utiliser pour analyser, modifier et enregistrer des données JSON
• QDataStream La classe permet la sérialisation de données binaires vers un QIODevice
• Qt XML C++ Classes fournit des implémentations C++ des normes XML Streaming et DOM pour XML

Base de données

Le Qt SQL module utilise des plugins de pilotes pour communiquer avec plusieurs API de bases de données. Qt dispose de pilotes pour SQLite, MySQL, DB2, Borland InterBase, Oracle, ODBC et PostgreSQL. Il est également possible de développer son propre pilote si Qt ne fournit pas celui dont on a besoin.

Les classes SQL de Qt peuvent être réparties en trois couches :

Avec tous les pilotes SQL, à l’exception de SQLite, vous pouvez vous connecter à un serveur hébergeant votre système de base de données. Si vous utilisez le serveur MySQL intégré, vous n’avez pas besoin d’un serveur MySQL pour utiliser ce système de base de données.

Pour savoir comment compiler les pilotes de base de données SQL, consultez la section Pilotes de base de données SQL.

Le plugin Qt SQLite est particulièrement adapté au stockage local. SQLite est un système de gestion de bases de données relationnelles contenu dans une petite bibliothèque C (~350 Ko). Contrairement à d’autres systèmes de gestion de bases de données, SQLite n’est pas un processus distinct accessible depuis l’application cliente, mais fait partie intégrante de celle-ci. SQLite fonctionne sur un seul fichier, qui doit être défini comme nom de la base de données lors de l’ouverture d’une connexion. Si le fichier n’existe pas, SQLite tentera de le créer.

SQLite présente certaines restrictions concernant les utilisateurs multiples et les transactions multiples. Si vous lisez ou écrivez dans un fichier à partir de transactions différentes, votre application risque de se bloquer jusqu’à ce qu’une transaction soit validée ou annulée.

Une fois le pilote configuré, les données sont accessibles via les classes QSqlQueryModel, QSqlTableModel et QSqlRelationalTableModel. Les classes QSqlTableModel et QSqlRelationalTableModel fournissent des modèles modifiables pouvant être utilisés avec les vues d’éléments de Qt. La classe QSqlTableModel dispose d’un accès en lecture/écriture à une seule table, tandis que la classe QSqlRelationalTableModel dispose d’un accès en lecture/écriture à la table principale (et non à la table comportant la clé étrangère).

Les pages suivantes contiennent des informations sur l'intégration de SQL dans les applications :

• Programmation SQL
  • Classes de base de données
  • Exécution d’instructions SQL
  • Utilisation des classes de modèle SQL
  • Présentation des données sous forme de tableau
  • Création de formulaires liés aux données

Prise en charge du format XML dans Qt

Qt fournit des API permettant de lire et d’analyser des flux XML, ainsi que d’écrire dans ces flux. Les classes clés suivantes facilitent ces opérations en fournissant l’infrastructure nécessaire :

• QDomDocument La classe représente l'intégralité du document XML sous la forme d'une arborescence et offre un accès principal aux données du document.
  • Elle dispose de plusieurs fonctions permettant de créer des données de document, par exemple : ` createElement()`, ` createTextNode()`, ` createComment()`, ` createCDATASection()`, ` createProcessingInstruction()`, ` createAttribute()` et ` createEntityReference()`.
• QXmlStreamReader La classe fournit un analyseur permettant de lire du XML. Il s'agit d'un analyseur XML 1.0 bien formé qui n'inclut pas d'entités analysées externes.
  • Elle comprend et résout les espaces de noms XML. Par exemple, dans le cas d'un StartElement, la méthode namespaceUri() renvoie l'espace de noms dans lequel se trouve l'élément, et la méthode name() renvoie le nom local de l'élément. La combinaison de namespaceUri() et de name() identifie de manière unique un élément.
  • Elle ne sollicite pas excessivement le processeur, car elle ne stocke pas l’intégralité de l’arborescence du document XML en mémoire. Elle ne stocke que le token actuel au moment où il est signalé.
• La classe ` QXmlStreamWriter ` fournit à un générateur XML une API de streaming simple. Elle est l’équivalent de ` QXmlStreamReader ` pour l’écriture XML, et elle opère sur un périphérique d’écriture XML ( QIODevice ) spécifié via `setDevice()`.
  • Il s’agit d’une API simple qui fournit une fonction dédiée pour chaque token ou événement XML que vous souhaitez écrire.
  • Elle se charge d’ajouter les préfixes aux espaces de noms en fonction de l’URI d’espace de noms (namespaceUri) spécifié lors de l’écriture des éléments ou des attributs. Si vous devez utiliser certains préfixes normalisés, vous pouvez forcer le générateur à les utiliser en déclarant manuellement les espaces de noms à l’aide de writeNamespace() ou de writeDefaultNamespace().
  • Elle peut formater automatiquement les données XML générées en ajoutant des sauts de ligne et des indentations, ce qui les rend lisibles. Cette fonctionnalité peut être activée à l’aide de la propriété auto-formatting.

Les rubriques suivantes fournissent des informations complémentaires sur la prise en charge d’ Qt XML:

• Introduction aux espaces de noms
• Flux XML

JSON dans Qt

JSON est un standard ouvert basé sur du texte, destiné à l'échange de données, facile à lire et à analyser. Il est utilisé pour représenter des structures de données simples et des tableaux associatifs, appelés « objets ». Il est lié à JavaScript, mais constitue une notation indépendante du langage.

Un objet peut prendre deux formes :

{
          "last_name": "Routledge",
          "first_name": "Ronald",
          "birth_date": 1960
}

"colors": ["green", "blue", "yellow"]

• Prise en charge de JSON dans Qt
• Enregistrement et chargement d'une partie
• Convertisseur de sérialisation

Stockage local

L'API de stockage local permet d'accéder au stockage local hors ligne dans une base de données SQL depuis QML et JavaScript.

Ces bases de données sont spécifiques à l'utilisateur et à QML, mais accessibles à toutes les applications QML. Elles sont stockées dans le sous-répertoire « Databases » de QDeclarativeEngine::offlineStoragePath() sous forme de bases de données SQLite (pilotes de bases de données SQL).

L'API est conforme à l'API synchrone de l'API de base de données Web HTML5, projet de travail du W3C du 29 octobre 2009 (API de base de données Web HTML5).

Consultez la section « Exemples de l'API de base de données Web HTML5 » (Qt Quick ) - Stockage local pour une démonstration de base de l'utilisation de l'API de stockage local.

• Qt Quick Local Storage QML Types

Classe QSettings

La classe QSettings permet le stockage persistant des paramètres de l’application. Une application conserve généralement ses paramètres de la session précédente.

Les paramètres sont stockés différemment selon les plateformes. Par exemple, sous Windows, ils sont stockés dans le registre, tandis que sous macOS, ils sont stockés dans des fichiers XML.

QSettings vous permettent d’enregistrer et de restaurer les paramètres d’application de manière portable. La création et la destruction d’un objet QSettings sont légères et rapides. Lors de la création d’un objet QSettings, il est recommandé de spécifier non seulement le nom de l’application, mais également celui de votre organisation. Par exemple :

QSettings settings("MyCompany", "Accountancy");

Ressources

Le système de ressources Qt est un mécanisme indépendant de la plateforme permettant de stocker des fichiers binaires dans l'exécutable de l'application. Cela s'avère pratique si votre application a fréquemment besoin d'un fichier ou d'un ensemble de fichiers spécifiques. Cela permet également de se prémunir contre la perte de ce fichier particulier.

Les données de ressources peuvent soit être compilées dans le binaire et être immédiatement accessibles depuis le code de l’application, soit une ressource binaire peut être créée dynamiquement et enregistrée auprès du système de ressources par l’application.

Par défaut, les ressources sont accessibles depuis le code de l’application sous le même nom de fichier que celui utilisé dans l’arborescence des sources, avec le préfixe « :/ », ou via une URL utilisant le schéma « qrc ».

Connectivité

• Qt Serial Port
• Qt Modbus
• Qt CAN Bus
• Qt Bluetooth
• Qt NFC

Archivage de fichiers

Un fichier d'archive est un ensemble de fichiers ou de répertoires généralement compressés afin de réduire l'espace qu'ils occuperaient autrement sur un disque. Les fichiers d'archive ZIP, TAR, RAR et 7z en sont des exemples.

Qt prend en charge les archives générées par zlib (voir qCompress() et qUncompress()).