QIODevice Class

Documentation des fonctions membres

QIODevice::QIODevice()

Construit un objet QIODevice.

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

Construit un objet QIODevice avec l'adresse 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 peut le faire. En cas de doute, appelez close() avant de détruire la classe QIODevice.

[signal] void QIODevice::aboutToClose()

Ce signal est émis lorsque l'appareil est sur le point de se fermer. Connectez ce signal si vous avez des opérations qui doivent être effectuées avant la fermeture de l'appareil (par exemple, si vous avez des données dans un tampon séparé qui doivent être écrites sur l'appareil).

[virtual] bool QIODevice::atEnd() const

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

Pour certains appareils, atEnd() peut renvoyer vrai 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 read() (par exemple, les fichiers /dev ou /proc sous Unix et macOS, ou l'entrée de la console / stdin sur toutes les plateformes).

Voir aussi 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 les périphériques séquentiels pour déterminer le nombre d'octets à allouer dans une mémoire 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 appareils avec tampon, cette fonction renvoie le nombre d'octets en attente d'écriture. Pour les périphériques sans mémoire 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'un paquet de données a été écrit sur le canal d'écriture actuel de l'appareil. L'argument bytes est fixé au nombre d'octets qui ont été écrits dans cette charge utile.

bytesWritten() n'est pas émis de manière récursive ; si vous revenez dans 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 (bien que waitForBytesWritten() puisse toujours renvoyer vrai).

Voir aussi readyRead().

[virtual] bool QIODevice::canReadLine() const

Renvoie true si une ligne complète de données peut être lue sur le périphérique ; sinon, renvoie false.

Notez que les périphériques sans tampon, qui n'ont aucun moyen 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'un paquet de données a été écrit dans le dispositif. L'argument bytes est fixé au nombre d'octets qui ont été écrits dans cette charge utile, tandis que channel est le canal dans lequel ils ont été écrits. Contrairement à bytesWritten(), elle est émise indépendamment de l'argument current write channel.

channelBytesWritten() peut être émise de manière récursive - même pour le même canal.

Voir aussi bytesWritten() et channelReadyRead().

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

Ce signal est émis lorsque de nouvelles données sont disponibles en lecture sur le périphérique. L'argument channel est mis à l'index du canal de lecture sur lequel les données sont arrivées. Contrairement à readyRead(), ce signal est émis indépendamment de current read channel.

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

Voir également readyRead() et channelBytesWritten().

[virtual] void QIODevice::close()

émet d'abord aboutToClose(), puis ferme le dispositif et définit son OpenMode sur NotOpen. La chaîne d'erreur est également réinitialisée.

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

void QIODevice::commitTransaction()

Termine une transaction de lecture.

Pour les dispositifs 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 aussi setCurrentReadChannel(), readChannelCount() et QProcess.

int QIODevice::currentWriteChannel() const

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

Voir aussi setCurrentWriteChannel() et writeChannelCount().

QString QIODevice::errorString() const

Renvoie une description lisible par l'homme de la dernière erreur de périphérique qui s'est produite.

Voir aussi setErrorString().

bool QIODevice::getChar(char *c)

Lit un caractère à partir du périphérique et le stocke dans c. Si c est nullptr, le caractère est supprimé. Renvoie true en cas de succès, sinon false.

Voir aussi read(), putChar() et ungetChar().

bool QIODevice::isOpen() const

Renvoie true si le dispositif est ouvert, sinon renvoie false. Un périphérique est ouvert s'il est possible d'y lire et/ou d'y écrire. Par défaut, cette fonction renvoie false si openMode() renvoie NotOpen.

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

bool QIODevice::isReadable() const

Renvoie true si des données peuvent être lues sur le périphérique, sinon renvoie false. Utilisez bytesAvailable() pour déterminer combien d'octets peuvent être lus.

Il s'agit d'une fonction de commodité qui vérifie si l'OpenMode du périphérique contient le drapeau 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, par opposition aux périphériques à accès aléatoire, n'ont pas de notion de début, de fin, de taille ou de position actuelle, 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 la prise réseau. Sous Unix, les fichiers spéciaux tels que /dev/zero et les pipes fifo sont séquentiels.

Les fichiers ordinaires, en revanche, prennent en charge l'accès aléatoire. Ils ont à la fois une taille et une position courante, et ils prennent également en charge la recherche en avant et en arrière dans le flux de données. Les fichiers ordinaires ne sont pas séquentiels.

Voir également bytesAvailable().

bool QIODevice::isTextModeEnabled() const

Renvoie true si l'indicateur 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 aussi 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 de commodité qui vérifie si l'OpenMode du périphérique contient l'indicateur WriteOnly.

Voir aussi openMode() et OpenMode.

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

Ouvre le dispositif et règle son OpenMode sur mode. Renvoie true en cas de succès, sinon false. Cette fonction doit être appelée à partir de toute réimplémentation de open() ou d'autres fonctions qui ouvrent le périphérique.

Voir aussi openMode() et QIODeviceBase::OpenMode.

QIODeviceBase::OpenMode QIODevice::openMode() const

Renvoie le mode dans lequel le dispositif a été ouvert, c'est-à-dire ReadOnly (lecture seule) ou WriteOnly (écriture seule).

Voir aussi setOpenMode() et OpenMode.

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

Lit au maximum maxSize octets du périphérique dans data, sans effets de bord (c'est-à-dire que si vous appelez read() après peek(), vous obtiendrez les mêmes données). Renvoie le nombre d'octets lus. En cas d'erreur, par exemple lors d'une tentative de lecture d'un périphérique ouvert en mode WriteOnly, cette fonction renvoie -1.

0 est renvoyé lorsqu'il n'y a plus de données disponibles pour la lecture.

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

QByteArray QIODevice::peek(qint64 maxSize)

Interroge le périphérique sur un maximum de maxSize octets et renvoie les données interrogées sous la forme de QByteArray.

Exemple :

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

Cette fonction n'a aucun moyen de signaler les erreurs ; renvoyer un QByteArray vide peut signifier soit qu'aucune donnée n'était disponible pour l'interrogation, soit qu'une erreur s'est produite.

Voir aussi read().

[virtual] qint64 QIODevice::pos() const

Pour les dispositifs à accès aléatoire, cette fonction renvoie la position à laquelle les données sont écrites ou lues. Pour les dispositifs séquentiels ou fermés, où il n'existe pas de concept de "position courante", 0 est renvoyé.

La position actuelle de lecture/écriture du dispositif est maintenue en interne par QIODevice, il n'est donc pas nécessaire de réimplémenter cette fonction. Lors de la sous-classification de QIODevice, utilisez QIODevice::seek() pour informer QIODevice des changements de position du périphérique.

Voir aussi 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 false.

Voir aussi write(), getChar() et ungetChar().

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

Lit au maximum maxSize octets du périphérique dans data, et renvoie le nombre d'octets lus. En cas d'erreur, par exemple lors d'une tentative de lecture à partir d'un périphérique ouvert en mode WriteOnly, cette fonction renvoie -1.

0 est renvoyé lorsqu'il n'y a plus de données disponibles pour la lecture. Toutefois, la lecture au-delà de la fin du flux est considérée comme une erreur, de sorte que cette fonction renvoie -1 dans ces cas (c'est-à-dire la lecture sur une socket fermée ou après la mort d'un processus).

Voir aussi 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 QByteArray.

Cette fonction n'a aucun moyen de signaler les erreurs ; le fait de renvoyer un 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 de l'appareil et les renvoie sous la forme d'un tableau d'octets.

Cette fonction n'a aucun moyen de signaler les erreurs ; le fait de renvoyer une adresse QByteArray vide peut signifier soit qu'aucune donnée n'était disponible pour la lecture, soit qu'une erreur s'est produite. Cette fonction n'a pas non plus de moyen d'indiquer que d'autres données étaient peut-ê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 aussi writeChannelCount() et QProcess.

[signal] void QIODevice::readChannelFinished()

Ce signal est émis lorsque le flux d'entrée (de lecture) est fermé dans ce dispositif. 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 avec read().

Voir également atEnd() et read().

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

Lit jusqu'à maxSize octets du 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 avoir plus d'octets disponibles (exemples : socket fermé, pipe fermé, sous-processus 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 que cette fonction lise toutes les données requises avant de renvoyer. Cela est nécessaire pour que QDataStream puisse agir sur la classe. QDataStream suppose que toutes les informations demandées ont été lues et ne relance donc pas la lecture en cas de problème.

Cette fonction peut être appelée avec une maxSize de 0, qui peut être utilisée pour effectuer des opérations post-lecture.

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

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

Cette fonction lit une ligne de caractères ASCII à partir de l'appareil, 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é à data, de sorte que maxSize doit être supérieur à 1.

Les données sont lues 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 retour à la ligne ('\n') est inclus dans la mémoire tampon. Si une nouvelle ligne n'est pas rencontrée avant que maxSize - 1 octets soient lus, une nouvelle ligne ne sera pas insérée dans la mémoire 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 retour à la ligne) peut être lue.

Cette fonction appelle readLineData(), qui est implémentée en utilisant des 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 aussi getChar(), read(), canReadLine() et write().

QByteArray QIODevice::readLine(qint64 maxSize = 0)

Lit une ligne sur le périphérique, mais pas plus de maxSize caractères, et renvoie le résultat sous la forme d'un 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 résultante peut comporter des caractères de fin de ligne ("\n" ou "\r\n "), de sorte qu'il peut être nécessaire d'appeler QByteArray::trimmed().

Cette fonction n'a aucun moyen de signaler les erreurs ; le renvoi 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 à mémoire tampon 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 la nouvelle ligne de fin, ou 0 s'il n'y a pas de ligne à lire à ce stade. En cas d'erreur, il doit renvoyer -1 si et seulement si aucun octet n'a été lu. La lecture au-delà de EOF est considérée comme une erreur.

Lit une ligne de ce périphérique dans buffer, et renvoie le sous-ensemble de buffer qui contient 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, appeler à nouveau readLineInto() permet 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 atEnd(), au cas où la dernière ligne ne se serait pas terminée par une nouvelle ligne. S'il ne s'agit pas de atEnd(), vérifiez si la vue renvoyée se termine par "\n". Sinon, un autre appel à readLineInto() est nécessaire.

La ligne résultante peut contenir des caractères de fin de ligne ("\n" ou "\r\n "), de sorte qu'il peut être nécessaire d'appeler QByteArrayView::trimmed().

En cas d'erreur, cette fonction renvoie une valeur nulle QByteArrayView. Sinon, il s'agit d'une sous-span de buffer. Si aucune donnée n'était disponible pour la lecture ou si le périphérique est atEnd(), cette fonction renvoie une valeur vide QByteArrayView.

Notez que la valeur de retour n'est pas à terminaison nulle. Si vous voulez une terminaison nulle, vous pouvez passer buffer.chopped(1) et insérer '\0' à buffer[result.size()].

Ces fonctions ont été introduites dans Qt 6.9.

Voir aussi readLine().

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

Lit une ligne sur le périphérique, mais pas plus de 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 résultante peut comporter des caractères de fin de ligne ("\n" ou "\r\n "), de sorte qu'il peut être nécessaire d'appeler QByteArray::trimmed().

Si aucune donnée n'est disponible pour la lecture ou si une erreur s'est produite, cette fonction renvoie false et définit line comme empty. Sinon, elle renvoie true.

Notez que le contenu de line avant l'appel est supprimé dans tous les cas, mais que son contenu capacity() n'est jamais réduit.

Cette fonction a été introduite dans Qt 6.9.

Voir aussi 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 la lecture à partir du canal de lecture actuel de l'appareil. Il ne sera émis à nouveau que lorsque de nouvelles données seront disponibles, par exemple lorsqu'un nouveau paquet de données réseau est arrivé 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 revenez dans 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 (bien que waitForReadyRead() puisse toujours renvoyer vrai).

Note pour les développeurs qui mettent en œuvre 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 aussi bytesWritten().

[virtual] bool QIODevice::reset()

Recherche le début de l'entrée pour les périphériques à accès aléatoire. Retourne vrai en cas de succès ; sinon, il retourne false (par exemple, si le périphérique n'est pas ouvert).

Notez que lors de l'utilisation d'un QTextStream sur un QFile, l'appel à reset() sur le QFile n'aura pas le résultat escompté car QTextStream met le fichier en mémoire tampon. Utilisez plutôt la fonction QTextStream::seek().

Voir aussi seek().

void QIODevice::rollbackTransaction()

Reprend une transaction de lecture.

Restaure le flux d'entrée au point de l'appel à startTransaction(). Cette fonction est généralement 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 fixe la position actuelle à pos, en renvoyant true en cas de succès, ou false en cas d'erreur. Pour les périphériques séquentiels, le comportement par défaut est de produire un avertissement et de renvoyer false.

Lorsque vous sous-classez QIODevice, vous devez appeler QIODevice::seek() au début de votre fonction pour garantir l'intégrité avec le tampon intégré de QIODevice.

Voir aussi pos() et isSequential().

void QIODevice::setCurrentReadChannel(int channel)

Définit le canal de lecture actuel de l'adresse QIODevice à l'adresse channel. Le canal d'entrée actuel est utilisé par les fonctions read(), readAll(), readLine() et getChar(). Il détermine également le canal qui 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'adresse QIODevice à l'adresse channel. Le canal de sortie actuel est utilisé par les fonctions write(), putChar(). Il détermine également le canal qui déclenche l'émission de bytesWritten() par QIODevice.

Voir aussi currentWriteChannel() et writeChannelCount().

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

Définit la description lisible par l'homme de la dernière erreur de périphérique qui s'est produite à str.

Voir également errorString().

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

Définit le mode d'ouverture de l'appareil à openMode. Appelez cette fonction pour définir le mode d'ouverture si les drapeaux changent après l'ouverture de l'appareil.

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 ; sinon, l'indicateur Text est supprimé. Cette fonction est utile pour les classes qui fournissent une gestion personnalisée de la fin de ligne sur un QIODevice.

Le périphérique IO doit être ouvert avant d'appeler cette fonction.

Voir aussi isTextModeEnabled(), open() et setOpenMode().

[virtual] qint64 QIODevice::size() const

Pour les périphériques à accès aléatoire ouverts, cette fonction renvoie la taille du périphérique. Pour les périphériques séquentiels ouverts, la fonction renvoie 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)

Saute jusqu'à maxSize octets 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 rejette que les données qui sont déjà disponibles pour la lecture.

Si le périphérique est ouvert en mode texte, les terminaisons de fin de ligne sont traduites en symboles '\n' et comptent comme un seul octet, à l'instar des comportements read() et peek().

Cette fonction fonctionne pour tous les périphériques, y compris les périphériques séquentiels qui ne peuvent pas seek(). Elle est optimisée pour ignorer les données non désirées après un appel à peek().

Pour les périphériques à accès aléatoire, skip() peut être utilisé pour rechercher des données à partir de la position actuelle. Les valeurs négatives de maxSize ne sont pas autorisées.

Voir aussi skipData(), peek(), seek() et read().

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

Saute jusqu'à maxSize octets 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. Pensez à la réimplémenter lorsque vous créez une sous-classe de QIODevice.

L'implémentation de base rejette les données en les lisant dans un tampon fictif. Cette méthode est lente, mais fonctionne pour tous les types d'appareils. Les sous-classes peuvent réimplémenter cette fonction pour l'améliorer.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi skip(), peek(), seek(), et read().

void QIODevice::startTransaction()

Démarre une nouvelle transaction de lecture sur l'appareil.

Définit un point de restauration dans la séquence des opérations de lecture. Pour les dispositifs séquentiels, les données lues seront dupliquées en interne pour permettre une récupération en cas de lecture incomplète. 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)

Remet le caractère c dans le périphérique, et décrémente la position actuelle à moins que la position ne soit 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 à rebours.

Si c n'a pas été lu précédemment sur le périphérique, le comportement est indéfini.

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

Pour les appareils à mémoire tampon, cette fonction attend qu'une charge utile de données écrites en mémoire tampon ait été écrite sur l'appareil et que le signal bytesWritten() ait été émis, ou que msecs millisecondes se soient écoulées. Si msecs est égal à -1, cette fonction n'est pas interrompue. Pour les périphériques sans tampon, elle revient immédiatement.

Renvoie true si des données ont été écrites sur le périphérique, sinon renvoie false (c'est-à-dire si l'opération a été interrompue 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 à partir d'un slot connecté au signal bytesWritten(), bytesWritten() ne sera pas réémis.

Réimplémentez cette fonction pour fournir une API bloquante pour 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 est égal à -1, cette fonction n'est pas interrompue.

Renvoie true si de nouvelles données sont disponibles pour la lecture ; sinon, renvoie false (si l'opération a dépassé le temps imparti 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 à partir d'un slot connecté au signal readyRead(), readyRead() ne sera pas réémis.

Réimplémentez cette fonction pour fournir une API bloquante pour 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 qui ont été écrits, ou -1 si une erreur s'est produite.

Voir aussi read() et writeData().

qint64 QIODevice::write(const char *data)

Écrit les données d'une chaîne de caractères de 8 bits à terminaison nulle sur le périphérique. Renvoie le nombre d'octets qui ont été écrits, ou -1 si une erreur s'est produite. Cette fonction est équivalente à

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

Voir aussi 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 aussi readChannelCount().

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

Écrit jusqu'à maxSize octets de data vers le périphérique. Renvoie le nombre d'octets écrits ou -1 si une erreur s'est produite.

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 écrive toutes les données disponibles avant de retourner. Cela est nécessaire pour que QDataStream puisse opérer sur la classe. QDataStream suppose que toutes les informations ont été écrites et n'essaie donc pas d'écrire à nouveau s'il y a un problème.

Voir également read() et write().