QIODevice Class

Documentation des fonctions membres

QIODevice::QIODevice()

Crée un objet QIODevice.

[explicit] QIODevice::QIODevice(QObject *parent)

Crée un objet QIODevice à partir de l'parent.

[virtual noexcept] QIODevice::~QIODevice()

Le destructeur est virtuel, et ` QIODevice ` est une classe de base abstraite. Ce destructeur n'appelle pas ` close()`, mais le destructeur de la sous-classe pourrait le faire. En cas de doute, appelez ` close()` avant de détruire ` QIODevice`.

[signal] void QIODevice::aboutToClose()

Ce signal est émis lorsque le périphérique est sur le point de se fermer. Connectez ce signal si vous avez des opérations à effectuer avant la fermeture du périphérique (par exemple, si vous disposez de données dans un tampon distinct qui doivent être écrites sur le périphérique).

[virtual] bool QIODevice::atEnd() const

Renvoie « true » si la position actuelle de lecture et d'écriture se trouve à la fin du périphérique (c'est-à-dire qu'il n'y a plus de données disponibles à lire sur le périphérique) ; sinon, renvoie « false ».

Pour certains périphériques, la fonction `atEnd()` peut renvoyer `true` même s’il reste des données à lire. Ce cas particulier ne s’applique qu’aux périphériques qui génèrent des données en réponse directe à l’appel de la fonction ` read()` (par exemple, les fichiers ` /dev ` ou ` /proc ` sous Unix et macOS, ou les entrées/ stdin s de la console sur toutes les plateformes).

Voir également bytesAvailable(), read() et isSequential().

[virtual] qint64 QIODevice::bytesAvailable() const

Renvoie le nombre d'octets disponibles pour la lecture. Cette fonction est couramment utilisée avec des périphériques séquentiels pour déterminer le nombre d'octets à allouer dans un tampon avant la lecture.

Les sous-classes qui réimplémentent cette fonction doivent appeler l’implémentation de base afin d’inclure la taille du tampon de ` QIODevice`. Exemple :

qint64 CustomDevice::bytesAvailable() const
{
    return buffer.size() + QIODevice::bytesAvailable();
}

Voir également bytesToWrite(), readyRead() et isSequential().

[virtual] qint64 QIODevice::bytesToWrite() const

Pour les périphériques dotés d'un tampon, cette fonction renvoie le nombre d'octets en attente d'écriture. Pour les périphériques sans tampon, cette fonction renvoie 0.

Les sous-classes qui réimplémentent cette fonction doivent appeler l’implémentation de base afin d’inclure la taille du tampon de ` QIODevice`.

Voir également bytesAvailable(), bytesWritten() et isSequential().

[signal] void QIODevice::bytesWritten(qint64 bytes)

Ce signal est émis chaque fois qu'une charge utile de données a été écrite sur le canal d'écriture actuel du périphérique. L'argument ` bytes ` est défini sur le nombre d'octets qui ont été écrits dans cette charge utile.

bytesWritten() n’est pas émis de manière récursive ; si vous réintégrez la boucle d’événements ou appelez waitForBytesWritten() à l’intérieur d’un slot connecté au signal bytesWritten(), le signal ne sera pas réémis (même si waitForBytesWritten() peut toujours renvoyer true).

Voir également ` readyRead()`.

[virtual] bool QIODevice::canReadLine() const

Renvoie « true » si une ligne complète de données peut être lue à partir du périphérique ; sinon, renvoie « false ».

Notez que les périphériques sans tampon, qui ne permettent pas de déterminer ce qui peut être lu, renvoient toujours « false ».

Cette fonction est souvent appelée en conjonction avec le signal ` readyRead()`.

Les sous-classes qui réimplémentent cette fonction doivent appeler l’implémentation de base afin d’inclure le contenu du tampon de QIODevice. Exemple :

bool CustomDevice::canReadLine() const
{
    return buffer.contains('\n') || QIODevice::canReadLine();
}

Voir également ` readyRead()` et ` readLine()`.

[signal] void QIODevice::channelBytesWritten(int channel, qint64 bytes)

Ce signal est émis chaque fois qu’une charge utile de données a été écrite sur le périphérique. L’argument ` bytes ` correspond au nombre d’octets écrits dans cette charge utile, tandis que ` channel ` correspond au canal sur lequel ils ont été écrits. Contrairement à ` bytesWritten()`, ce signal est émis quelle que soit la valeur de ` current write channel`.

La fonction `channelBytesWritten()` peut être émise de manière récursive, même pour un même canal.

Voir également bytesWritten() et channelReadyRead().

[signal] void QIODevice::channelReadyRead(int channel)

Ce signal est émis lorsque de nouvelles données sont disponibles pour être lues depuis le périphérique. L'argument ` channel ` est défini sur l'index du canal de lecture sur lequel les données sont arrivées. Contrairement à ` readyRead()`, il est émis indépendamment de la valeur de ` current read channel`.

channelReadyRead() peut être émis de manière récursive, même pour un même canal.

Voir également readyRead() et channelBytesWritten().

[virtual] void QIODevice::close()

Elle envoie d'abord la commande « aboutToClose » (), puis ferme le périphérique et définit son OpenMode sur NotOpen. La chaîne d'erreur est également réinitialisée.

Voir aussi setOpenMode() et QIODeviceBase::OpenMode.

void QIODevice::commitTransaction()

Termine une transaction de lecture.

Pour les périphériques séquentiels, toutes les données enregistrées dans la mémoire tampon interne pendant la transaction seront supprimées.

Voir également startTransaction() et rollbackTransaction().

int QIODevice::currentReadChannel() const

Renvoie l'index du canal de lecture actuel.

Voir également setCurrentReadChannel(), readChannelCount() et QProcess.

int QIODevice::currentWriteChannel() const

Renvoie l'index du canal d'écriture actuel.

Voir également setCurrentWriteChannel() et writeChannelCount().

QString QIODevice::errorString() const

Renvoie une description lisible par l'utilisateur de la dernière erreur de périphérique survenue.

Voir également setErrorString().

bool QIODevice::getChar(char *c)

Lit un caractère depuis le périphérique et le stocke dans ` c`. Si ` c ` vaut ` nullptr`, le caractère est ignoré. Renvoie ` true ` en cas de succès ; sinon, renvoie ` false`.

Voir également read(), putChar() et ungetChar().

bool QIODevice::isOpen() const

Renvoie « true » si le périphérique est ouvert ; sinon, renvoie « false ». Un périphérique est considéré comme ouvert s’il est possible d’y lire et/ou d’y écrire. Par défaut, cette fonction renvoie « false » si la fonction « openMode() » renvoie « NotOpen ».

Voir également openMode() et QIODeviceBase::OpenMode.

bool QIODevice::isReadable() const

Renvoie « true » si les données peuvent être lues à partir du périphérique ; sinon, renvoie « false ». Utilisez la fonction « bytesAvailable() » pour déterminer le nombre d'octets pouvant être lus.

Il s'agit d'une fonction pratique qui vérifie si le mode d'ouverture (OpenMode) du périphérique contient l'indicateur ReadOnly.

Voir également openMode() et OpenMode.

[virtual] bool QIODevice::isSequential() const

Renvoie « true » si ce périphérique est séquentiel ; sinon, renvoie « false ».

Les périphériques séquentiels, contrairement aux périphériques à accès aléatoire, n'ont pas de notion de début, de fin, de taille ou de position courante, et ils ne prennent pas en charge la recherche. Vous ne pouvez lire sur le périphérique que lorsqu’il signale que des données sont disponibles. L’exemple le plus courant de périphérique séquentiel est une socket réseau. Sous Unix, les fichiers spéciaux tels que /dev/zero et les tubes FIFO sont séquentiels.

Les fichiers ordinaires, en revanche, prennent en charge l’accès aléatoire. Ils possèdent à la fois une taille et une position courante, et permettent également la recherche vers l’avant et vers l’arrière dans le flux de données. Les fichiers ordinaires sont non séquentiels.

Voir également bytesAvailable().

bool QIODevice::isTextModeEnabled() const

Renvoie ` true ` si le drapeau ` Text ` est activé ; sinon, renvoie ` false`.

Voir aussi setTextModeEnabled().

bool QIODevice::isTransactionStarted() const

Renvoie « true » si une transaction est en cours sur l'appareil, sinon « false ».

Voir également startTransaction().

bool QIODevice::isWritable() const

Renvoie « true » si des données peuvent être écrites sur le périphérique ; sinon, renvoie « false ».

Il s'agit d'une fonction pratique qui vérifie si le mode d'ouverture (OpenMode) du périphérique contient l'indicateur WriteOnly.

Voir également openMode() et OpenMode.

[virtual] bool QIODevice::open(QIODeviceBase::OpenMode mode)

Ouvre le périphérique et définit son OpenMode sur « mode ». Renvoie « true » en cas de succès ; sinon, renvoie « false ». Cette fonction doit être appelée depuis toute réimplémentation de la fonction open() ou d’autres fonctions ouvrant le périphérique.

Voir également openMode() et QIODeviceBase::OpenMode.

QIODeviceBase::OpenMode QIODevice::openMode() const

Renvoie le mode dans lequel le périphérique a été ouvert, c'est-à-dire « ReadOnly » ou « WriteOnly ».

Voir également setOpenMode() et OpenMode.

qint64 QIODevice::peek(char *data, qint64 maxSize)

Lit au maximum maxSize octets depuis le périphérique dans data, sans effet secondaire (c'est-à-dire que si vous appelez read() après peek(), vous obtiendrez les mêmes données). Renvoie le nombre d'octets lus. Si une erreur se produit, par exemple en essayant d'utiliser peek() sur un périphérique ouvert en mode WriteOnly, cette fonction renvoie -1.

La valeur 0 est renvoyée lorsqu’il n’y a plus de données disponibles à lire.

Exemple :

bool isExeFile(QFile *file)
{
    char buf[2];
    if (file->peek(buf, sizeof(buf)) == sizeof(buf))
        return (buf[0] == 'M' && buf[1] == 'Z');
    return false;
}

Voir également read().

QByteArray QIODevice::peek(qint64 maxSize)

Extrait au maximum maxSize octets de la périphérie, puis renvoie les données extraites sous la forme d'un objet ` QByteArray`.

Exemple :

bool isExeFile(QFile *file)
{
    return file->peek(2) == "MZ";
}

Cette fonction ne dispose d’aucun moyen de signaler les erreurs ; le fait de renvoyer un objet ` QByteArray ` vide peut signifier soit qu’aucune donnée n’était disponible pour le moment, soit qu’une erreur s’est produite.

Voir aussi read().

[virtual] qint64 QIODevice::pos() const

Pour les périphériques à accès aléatoire, cette fonction renvoie la position à laquelle les données sont écrites ou lues. Pour les périphériques séquentiels ou fermés, où la notion de « position courante » n’existe pas, la valeur 0 est renvoyée.

La position actuelle de lecture/écriture du périphérique est gérée en interne par ` QIODevice`, il n’est donc pas nécessaire de réimplémenter cette fonction. Lorsque vous créez une sous-classe de ` QIODevice`, utilisez ` QIODevice::seek()` pour signaler à ` QIODevice ` les changements de position du périphérique.

Voir également isSequential() et seek().

bool QIODevice::putChar(char c)

Écrit le caractère c sur le périphérique. Renvoie true en cas de succès ; sinon, renvoie false.

Voir également write(), getChar() et ungetChar().

qint64 QIODevice::read(char *data, qint64 maxSize)

Lit au maximum maxSize octets depuis le périphérique dans data, et renvoie le nombre d’octets lus. Si une erreur se produit, par exemple lors d’une tentative de lecture à partir d’un périphérique ouvert en mode « WriteOnly », cette fonction renvoie -1.

La valeur 0 est renvoyée lorsqu’il n’y a plus de données disponibles à lire. Cependant, la lecture au-delà de la fin du flux est considérée comme une erreur ; cette fonction renvoie donc -1 dans ces cas-là (c’est-à-dire lors de la lecture sur un socket fermé ou après la fin d’un processus).

Voir également readData(), readLine() et write().

QByteArray QIODevice::read(qint64 maxSize)

Lit au maximum maxSize octets à partir du périphérique et renvoie les données lues sous la forme d'un objet ` QByteArray`.

Cette fonction ne dispose d'aucun moyen de signaler les erreurs ; le retour d'un objet ` QByteArray ` vide peut signifier soit qu'aucune donnée n'était disponible pour la lecture, soit qu'une erreur s'est produite.

QByteArray QIODevice::readAll()

Lit toutes les données restantes du périphérique et les renvoie sous forme de tableau d'octets.

Cette fonction ne dispose d'aucun moyen de signaler les erreurs ; le fait de renvoyer un tableau vide ( QByteArray ) peut signifier soit qu'aucune donnée n'était disponible à la lecture, soit qu'une erreur s'est produite. Cette fonction ne dispose pas non plus de moyen d'indiquer que d'autres données auraient pu être disponibles mais n'ont pas pu être lues.

int QIODevice::readChannelCount() const

Renvoie le nombre de canaux de lecture disponibles si le périphérique est ouvert ; sinon, renvoie 0.

Voir également writeChannelCount() et QProcess.

[signal] void QIODevice::readChannelFinished()

Ce signal est émis lorsque le flux d'entrée (lecture) est fermé sur ce périphérique. Il est émis dès que la fermeture est détectée, ce qui signifie qu'il peut encore y avoir des données disponibles pour la lecture via la fonction read().

Voir également atEnd() et read().

[pure virtual protected] qint64 QIODevice::readData(char *data, qint64 maxSize)

Lit jusqu’à maxSize octets depuis le périphérique dans data, et renvoie le nombre d’octets lus ou -1 si une erreur s’est produite.

S'il n'y a pas d'octets à lire et qu'il ne pourra jamais y en avoir davantage (par exemple, si le socket est fermé, si le tuyau est fermé ou si le sous-processus est terminé), cette fonction renvoie -1.

Cette fonction est appelée par ` QIODevice`. Réimplémentez cette fonction lorsque vous créez une sous-classe de ` QIODevice`.

Lors de la réimplémentation de cette fonction, il est important qu’elle lise toutes les données requises avant de renvoyer une valeur. Cela est nécessaire pour que ` QDataStream ` puisse opérer sur la classe. ` QDataStream ` part du principe que toutes les informations demandées ont été lues et ne tente donc pas de relire les données en cas de problème.

Cette fonction peut être appelée avec une valeur maxSize égale à 0, ce qui permet d’effectuer des opérations après la lecture.

Voir également read(), readLine() et writeData().

qint64 QIODevice::readLine(char *data, qint64 maxSize)

Cette fonction lit une ligne de caractères ASCII à partir du périphérique, jusqu’à un maximum de maxSize - 1 octets, stocke les caractères dans data et renvoie le nombre d’octets lus. Si une ligne n'a pas pu être lue mais qu'aucune erreur ne s'est produite, cette fonction renvoie 0. Si une erreur se produit, cette fonction renvoie la longueur de ce qui a pu être lu, ou -1 si rien n'a été lu.

Un octet de fin «\0 » est toujours ajouté à la fin de data; par conséquent, maxSize doit être supérieur à 1.

La lecture des données se poursuit jusqu’à ce que l’une des conditions suivantes soit remplie :

• Le premier caractère «\n » est lu.
• maxSize - 1 octet est lu.
• La fin des données du périphérique est détectée.

Par exemple, le code suivant lit une ligne de caractères à partir d’un fichier :

QFile file("box.txt");
if (file.open(QFile::ReadOnly)) {
    char buf[1024];
    qint64 lineLength = file.readLine(buf, sizeof(buf));
    if (lineLength != -1) {
        // the line is available in buf
    }
}

Le caractère de nouvelle ligne («\n ») est inclus dans le tampon. Si aucun caractère de nouvelle ligne n’est rencontré avant la lecture de maxSize - 1 octets, aucun caractère de nouvelle ligne ne sera inséré dans le tampon.

Notez que sur les périphériques séquentiels, les données peuvent ne pas être immédiatement disponibles, ce qui peut entraîner le renvoi d’une ligne partielle. En appelant la fonction canReadLine() avant la lecture, vous pouvez vérifier si une ligne complète (y compris le caractère de saut de ligne) peut être lue.

Cette fonction appelle ` readLineData()`, qui est implémentée à l’aide d’appels répétés à ` getChar()`. Vous pouvez fournir une implémentation plus efficace en réimplémentant ` readLineData()` dans votre propre sous-classe.

Voir également getChar(), read(), canReadLine() et write().

QByteArray QIODevice::readLine(qint64 maxSize = 0)

Lit une ligne depuis le périphérique, dans la limite de maxSize caractères, et renvoie le résultat sous forme de tableau d'octets.

Si maxSize est égal à 0 ou n'est pas spécifié, la ligne peut être de n'importe quelle longueur, ce qui permet une lecture illimitée.

La ligne obtenue peut comporter des caractères de fin de ligne («\n » ou «\r\n »), il peut donc être nécessaire d’appeler QByteArray::trimmed().

Cette fonction ne dispose d’aucun moyen de signaler les erreurs ; le retour d’un ` QByteArray ` vide peut signifier soit qu’aucune donnée n’était disponible pour la lecture, soit qu’une erreur s’est produite.

[virtual protected] qint64 QIODevice::readLineData(char *data, qint64 maxSize)

Lit jusqu’à maxSize caractères dans data et renvoie le nombre de caractères lus.

Cette fonction est appelée par ` readLine()` et fournit son implémentation de base, en utilisant ` getChar()`. Les périphériques tamponnés peuvent améliorer les performances de ` readLine()` en réimplémentant cette fonction.

readLine() ajoute un octet «\0 » à data; readLineData() n’a pas besoin de le faire.

Si vous réimplémentez cette fonction, veillez à renvoyer la valeur correcte : elle doit renvoyer le nombre d'octets lus dans cette ligne, y compris le caractère de fin de ligne, ou 0 s'il n'y a pas de ligne à lire à cet endroit. En cas d'erreur, elle doit renvoyer -1 si et seulement si aucun octet n'a été lu. La lecture au-delà de la fin de fichier (EOF) est considérée comme une erreur.

Lit une ligne à partir de ce périphérique dans ` buffer` et renvoie le sous-ensemble de ` buffer ` contenant les données lues.

Si la taille de buffer est inférieure à la longueur de la ligne, seuls les caractères qui tiennent dans buffer sont lus et renvoyés. Dans ce cas, un nouvel appel à readLineInto() permettra de récupérer le reste de la ligne. Pour déterminer si la ligne entière a été lue, vérifiez d’abord si le périphérique est de type atEnd(), au cas où la dernière ligne ne se terminerait pas par un saut de ligne. Si ce n’est pas le cas atEnd(), vérifiez si la vue renvoyée se termine par «\n ». Sinon, un autre appel à readLineInto() est nécessaire.

La ligne obtenue peut comporter des caractères de fin de ligne en fin de ligne («\n » ou «\r\n »), il peut donc être nécessaire d'appeler QByteArrayView::trimmed().

En cas d’erreur, cette fonction renvoie un QByteArrayView nul. Sinon, il s’agit d’un sous-segment de buffer. Si aucune donnée n’est actuellement disponible pour la lecture ou si le périphérique est atEnd(), cette fonction renvoie un QByteArrayView vide.

Notez que la valeur renvoyée n’est pas terminée par un caractère null. Si vous souhaitez une terminaison par null, vous pouvez passer buffer.chopped(1) puis insérer «\0 » à l’adresse buffer[result.size()].

Ces fonctions ont été introduites dans Qt 6.9.

Voir également readLine().

[since 6.9] bool QIODevice::readLineInto(QByteArray *line, qint64 maxSize = 0)

Lit une ligne à partir du périphérique, sans dépasser maxSize caractères, et la stocke sous forme de tableau d'octets dans line.

Si maxSize est égal à 0 ou n’est pas spécifié, la ligne peut être de n’importe quelle longueur, ce qui permet une lecture illimitée.

La ligne obtenue peut comporter des caractères de fin de ligne en fin de ligne («\n » ou «\r\n »), il peut donc être nécessaire d’appeler QByteArray::trimmed().

Si aucune donnée n’était disponible pour la lecture, ou en cas d’erreur, cette fonction renvoie ` false ` et définit ` line ` sur ` empty`. Sinon, elle renvoie ` true`.

Notez que le contenu de ` line ` avant l’appel est ignoré dans tous les cas, mais que sa valeur renvoyée par ` capacity()` n’est jamais réduite.

Cette fonction a été introduite dans Qt 6.9.

Voir également readAll(), readLine() et QTextStream::readLineInto().

[signal] void QIODevice::readyRead()

Ce signal est émis une fois chaque fois que de nouvelles données sont disponibles pour être lues à partir du canal de lecture actuel du périphérique. Il ne sera émis à nouveau que lorsque de nouvelles données seront disponibles, par exemple lorsqu’une nouvelle charge utile de données réseau est arrivée sur votre socket réseau, ou lorsqu’un nouveau bloc de données a été ajouté à votre périphérique.

readyRead() n’est pas émis de manière récursive ; si vous réintégrez la boucle d’événements ou appelez waitForReadyRead() à l’intérieur d’un slot connecté au signal readyRead(), le signal ne sera pas réémis (même si waitForReadyRead() peut toujours renvoyer true).

Remarque à l’attention des développeurs implémentant des classes dérivées de ` QIODevice` : vous devez toujours émettre `readyRead()` lorsque de nouvelles données sont arrivées (ne l’émettez pas uniquement parce qu’il reste des données à lire dans vos tampons). N’émettez pas `readyRead()` dans d’autres conditions.

Voir également bytesWritten().

[virtual] bool QIODevice::reset()

Cherche le début du flux d'entrée pour les périphériques à accès aléatoire. Renvoie « true » en cas de succès ; sinon, renvoie « false » (par exemple, si le périphérique n'est pas ouvert).

Notez que lorsque vous utilisez un « QTextStream » sur un « QFile », l’appel de la fonction reset() sur le « QFile » ne donnera pas le résultat escompté, car « QTextStream » met le fichier en mémoire tampon. Utilisez plutôt la fonction « QTextStream::seek() ».

Voir également seek().

void QIODevice::rollbackTransaction()

Annule une transaction de lecture.

Rétablit le flux d'entrée à l'état où il se trouvait au moment de l'appel à la fonction startTransaction(). Cette fonction est couramment utilisée pour annuler la transaction lorsqu'une lecture incomplète a été détectée avant la validation de la transaction.

Voir également startTransaction() et commitTransaction().

[virtual] bool QIODevice::seek(qint64 pos)

Pour les périphériques à accès aléatoire, cette fonction définit la position courante sur pos; elle renvoie « true » en cas de succès, ou « false » si une erreur s'est produite. Pour les périphériques séquentiels, le comportement par défaut consiste à générer un avertissement et à renvoyer « false ».

Lorsque vous créez une sous-classe de ` QIODevice`, vous devez appeler `QIODevice::seek()` au début de votre fonction afin de garantir l’intégrité avec le tampon intégré de ` QIODevice`.

Voir également pos() et isSequential().

void QIODevice::setCurrentReadChannel(int channel)

Définit le canal de lecture actuel de l'QIODevice sur l'channel spécifié. Le canal d'entrée actuel est utilisé par les fonctions read(), readAll(), readLine() et getChar(). Il détermine également quel canal déclenche l'émission de readyRead() par QIODevice.

Voir également currentReadChannel(), readChannelCount() et QProcess.

void QIODevice::setCurrentWriteChannel(int channel)

Définit le canal d'écriture actuel de l'QIODevice sur l'channel spécifié. Le canal de sortie actuel est utilisé par les fonctions write(), putChar(). Il détermine également quel canal déclenche l'QIODevice pour émettre bytesWritten().

Voir également currentWriteChannel() et writeChannelCount().

[protected] void QIODevice::setErrorString(const QString &str)

Définit la description lisible par l'utilisateur de la dernière erreur de périphérique survenue dans str.

Voir également errorString().

[protected] void QIODevice::setOpenMode(QIODeviceBase::OpenMode openMode)

Définit le mode d'ouverture (OpenMode) du périphérique sur « openMode ». Appelez cette fonction pour définir le mode d'ouverture si les indicateurs changent après l'ouverture du périphérique.

Voir également ` openMode()` et ` OpenMode`.

void QIODevice::setTextModeEnabled(bool enabled)

Si ` enabled ` est vrai, cette fonction active l'indicateur ` Text ` sur le périphérique ; dans le cas contraire, l'indicateur ` Text ` est désactivé. Cette fonctionnalité est utile pour les classes qui gèrent de manière personnalisée les fins de ligne sur un ` QIODevice`.

Le périphérique d’E/S doit être ouvert avant d’appeler cette fonction.

Voir également isTextModeEnabled(), open() et setOpenMode().

[virtual] qint64 QIODevice::size() const

Pour les périphériques ouverts en accès aléatoire, cette fonction renvoie la taille du périphérique. Pour les périphériques ouverts en accès séquentiel, elle renvoie la valeur « bytesAvailable() ».

Si le périphérique est fermé, la taille renvoyée ne correspondra pas à la taille réelle du périphérique.

Voir également ` isSequential()` et ` pos()`.

qint64 QIODevice::skip(qint64 maxSize)

Ignore jusqu'à maxSize octets provenant du périphérique. Renvoie le nombre d'octets effectivement ignorés, ou -1 en cas d'erreur.

Cette fonction n'attend pas et ne supprime que les données déjà disponibles en lecture.

Si le périphérique est ouvert en mode texte, les caractères de fin de ligne sont convertis en symboles «\n » et comptent pour un seul octet, à l’instar du comportement des fonctions read() et peek().

Cette fonction fonctionne pour tous les périphériques, y compris les périphériques séquentiels qui ne prennent pas en charge la fonction ` seek()`. Elle est optimisée pour ignorer les données indésirables après un appel à ` peek()`.

Pour les périphériques à accès aléatoire, skip() peut être utilisée pour effectuer un saut vers l’avant à partir de la position actuelle. Les valeurs négatives de maxSize ne sont pas autorisées.

Voir également skipData(), peek(), seek() et read().

[virtual protected, since 6.0] qint64 QIODevice::skipData(qint64 maxSize)

Saute jusqu'à maxSize octets à partir du périphérique. Renvoie le nombre d'octets effectivement sautés, ou -1 en cas d'erreur.

Cette fonction est appelée par ` QIODevice`. Envisagez de la réimplémenter lorsque vous créez une sous-classe de ` QIODevice`.

L’implémentation de base supprime les données en les lisant dans un tampon factice. Cette méthode est lente, mais fonctionne pour tous les types de périphériques. Les sous-classes peuvent réimplémenter cette fonction pour améliorer ses performances.

Cette fonction a été introduite dans Qt 6.0.

Voir également skip(), peek(), seek() et read().

void QIODevice::startTransaction()

Lance une nouvelle transaction de lecture sur le périphérique.

Définit un point de restauration au sein de la séquence d’opérations de lecture. Pour les périphériques séquentiels, les données lues sont dupliquées en interne afin de permettre la récupération en cas de lectures incomplètes. Pour les périphériques à accès aléatoire, cette fonction enregistre la position actuelle. Appelez commitTransaction() ou rollbackTransaction() pour terminer la transaction.

Voir également commitTransaction() et rollbackTransaction().

void QIODevice::ungetChar(char c)

Réintroduit le caractère c dans le périphérique et décrémente la position courante, sauf si celle-ci est égale à 0. Cette fonction est généralement appelée pour « annuler » une opération getChar(), par exemple lors de l'écriture d'un analyseur syntaxique à retour en arrière.

Si le caractère c n’a pas été lu auparavant à partir du périphérique, le comportement est indéfini.

[virtual] bool QIODevice::waitForBytesWritten(int msecs)

Pour les périphériques avec mémoire tampon, cette fonction attend qu’une charge utile de données mises en mémoire tampon ait été écrite sur le périphérique et que le signal bytesWritten() ait été émis, ou qu’ msecs millisecondes se soient écoulées. Si msecs vaut -1, cette fonction n’expire pas. Pour les périphériques sans mémoire tampon, elle renvoie immédiatement un résultat.

Renvoie « true » si une charge utile de données a été écrite sur le périphérique ; sinon, renvoie « false » (c'est-à-dire si l'opération a atteint le délai d'expiration ou si une erreur s'est produite).

Cette fonction peut fonctionner sans boucle d’événements. Elle est utile lors de l’écriture d’applications non-GUI et lors de l’exécution d’opérations d’E/S dans un thread non-GUI.

Si elle est appelée depuis un slot connecté au signal bytesWritten(), bytesWritten() ne sera pas réémis.

Réimplémentez cette fonction pour fournir une API bloquante à un périphérique personnalisé. L’implémentation par défaut ne fait rien et renvoie ` false`.

Voir également waitForReadyRead().

[virtual] bool QIODevice::waitForReadyRead(int msecs)

Bloque jusqu’à ce que de nouvelles données soient disponibles pour la lecture et que le signal readyRead() ait été émis, ou jusqu’à ce que msecs millisecondes se soient écoulées. Si msecs vaut -1, cette fonction n’expire pas.

Renvoie true si de nouvelles données sont disponibles en lecture ; sinon, renvoie false (si l’opération a atteint le délai d’expiration ou si une erreur s’est produite).

Cette fonction peut fonctionner sans boucle d’événements. Elle est utile lors de l’écriture d’applications non-GUI et lors de l’exécution d’opérations d’E/S dans un thread non-GUI.

Si elle est appelée depuis un slot connecté au signal ` readyRead()`, ` readyRead()` ne sera pas réémis.

Réimplémentez cette fonction pour fournir une API bloquante à un périphérique personnalisé. L’implémentation par défaut ne fait rien et renvoie ` false`.

Voir également waitForBytesWritten().

qint64 QIODevice::write(const char *data, qint64 maxSize)

Écrit au maximum maxSize octets de données depuis data vers le périphérique. Renvoie le nombre d'octets effectivement écrits, ou -1 en cas d'erreur.

Voir également read() et writeData().

qint64 QIODevice::write(const QByteArray &data)

Écrit le contenu de ` data ` sur le périphérique. Renvoie le nombre d'octets effectivement écrits, ou -1 en cas d'erreur.

Voir également read() et writeData().

qint64 QIODevice::write(const char *data)

Écrit les données d'une chaîne de caractères 8 bits terminée par un zéro sur le périphérique. Renvoie le nombre d'octets effectivement écrits, ou -1 en cas d'erreur. Cela équivaut à

...
QIODevice::write(data, qstrlen(data));
...

Voir également read() et writeData().

int QIODevice::writeChannelCount() const

Renvoie le nombre de canaux d'écriture disponibles si le périphérique est ouvert ; sinon, renvoie 0.

Voir également readChannelCount().

[pure virtual protected] qint64 QIODevice::writeData(const char *data, qint64 maxSize)

Écrit jusqu'à maxSize octets depuis data vers le périphérique. Renvoie le nombre d'octets écrits, ou -1 en cas d'erreur.

Cette fonction est appelée par ` QIODevice`. Réimplémentez cette fonction lorsque vous créez une sous-classe de ` QIODevice`.

Lors de la réimplémentation de cette fonction, il est important que celle-ci écrive toutes les données disponibles avant de retourner. Cela est nécessaire pour que ` QDataStream ` puisse opérer sur la classe. ` QDataStream ` part du principe que toutes les informations ont été écrites et ne tente donc pas à nouveau l’écriture en cas de problème.

Voir également read() et write().