QIODevice Class

Documentación de las funciones miembro

QIODevice::QIODevice()

Construye un objeto QIODevice.

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

Construye un objeto QIODevice con la dirección parent.

[virtual noexcept] QIODevice::~QIODevice()

El destructor es virtual, y QIODevice es una clase base abstracta. Este destructor no llama a close(), pero el destructor de la subclase podría hacerlo. Si tiene dudas, llame a close() antes de destruir QIODevice.

[signal] void QIODevice::aboutToClose()

Esta señal se emite cuando el dispositivo está a punto de cerrarse. Conecte esta señal si tiene operaciones que deben realizarse antes de que el dispositivo se cierre (por ejemplo, si tiene datos en un búfer independiente que deben escribirse en el dispositivo).

[virtual] bool QIODevice::atEnd() const

Devuelve true si la posición actual de lectura y escritura está al final del dispositivo (es decir, no hay más datos disponibles para leer en el dispositivo); en caso contrario devuelve false.

Para algunos dispositivos, atEnd() puede devolver true aunque haya más datos para leer. Este caso especial sólo se aplica a dispositivos que generan datos en respuesta directa a la llamada a read() (por ejemplo, archivos /dev o /proc en Unix y macOS, o entrada de consola / stdin en todas las plataformas).

Véase también bytesAvailable(), read() y isSequential().

[virtual] qint64 QIODevice::bytesAvailable() const

Devuelve el número de bytes que están disponibles para la lectura. Esta función se utiliza comúnmente con dispositivos secuenciales para determinar el número de bytes a asignar en un buffer antes de la lectura.

Las subclases que reimplementen esta función deben llamar a la implementación base para incluir el tamaño del buffer de QIODevice. Ejemplo:

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

Véase también bytesToWrite(), readyRead(), y isSequential().

[virtual] qint64 QIODevice::bytesToWrite() const

Para dispositivos con buffer, esta función devuelve el número de bytes que esperan ser escritos. Para dispositivos sin buffer, esta función devuelve 0.

Las subclases que reimplementen esta función deben llamar a la implementación base para incluir el tamaño del buffer de QIODevice.

Véase también bytesAvailable(), bytesWritten(), y isSequential().

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

Esta señal se emite cada vez que se ha escrito una carga de datos en el canal de escritura actual del dispositivo. El argumento bytes se establece en el número de bytes que se escribieron en esta carga útil.

bytesWritten() no se emite recursivamente; si vuelve a entrar en el bucle de eventos o llama a waitForBytesWritten() dentro de una ranura conectada a la señal bytesWritten(), la señal no se volverá a emitir (aunque waitForBytesWritten() puede seguir devolviendo true).

Véase también readyRead().

[virtual] bool QIODevice::canReadLine() const

Devuelve true si se puede leer una línea completa de datos del dispositivo; en caso contrario devuelve false.

Tenga en cuenta que los dispositivos sin búfer, que no tienen forma de determinar lo que se puede leer, siempre devuelven false.

Esta función se llama a menudo junto con la señal readyRead().

Las subclases que reimplementen esta función deben llamar a la implementación base para incluir el contenido del búfer de QIODevice. Ejemplo:

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

Véase también readyRead() y readLine().

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

Esta señal se emite cada vez que se ha escrito una carga de datos en el dispositivo. El argumento bytes se establece en el número de bytes que se escribieron en esta carga útil, mientras que channel es el canal en el que se escribieron. A diferencia de bytesWritten(), se emite independientemente de current write channel.

channelBytesWritten() puede emitirse recursivamente - incluso para el mismo canal.

Véase también bytesWritten() y channelReadyRead().

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

Esta señal se emite cuando hay nuevos datos disponibles para su lectura desde el dispositivo. El argumento channel se establece en el índice del canal de lectura en el que han llegado los datos. A diferencia de readyRead(), se emite independientemente de current read channel.

channelReadyRead() puede ser emitido recursivamente - incluso para el mismo canal.

Véase también readyRead() y channelBytesWritten().

[virtual] void QIODevice::close()

Primero emite aboutToClose(), luego cierra el dispositivo y establece su OpenMode a NotOpen. También se restablece la cadena de error.

Véase también setOpenMode() y QIODeviceBase::OpenMode.

void QIODevice::commitTransaction()

Finaliza una transacción de lectura.

Para dispositivos secuenciales, todos los datos registrados en el buffer interno durante la transacción serán descartados.

Véase también startTransaction() y rollbackTransaction().

int QIODevice::currentReadChannel() const

Devuelve el índice del canal de lectura actual.

Véase también setCurrentReadChannel(), readChannelCount() y QProcess.

int QIODevice::currentWriteChannel() const

Devuelve el índice del canal de escritura actual.

Véase también setCurrentWriteChannel() y writeChannelCount().

QString QIODevice::errorString() const

Devuelve una descripción legible por humanos del último error de dispositivo que se ha producido.

Véase también setErrorString().

bool QIODevice::getChar(char *c)

Lee un carácter del dispositivo y lo almacena en c. Si c es nullptr, el carácter se descarta. Devuelve true en caso de éxito; en caso contrario devuelve false.

Véase también read(), putChar(), y ungetChar().

bool QIODevice::isOpen() const

Devuelve true si el dispositivo está abierto; en caso contrario devuelve false. Un dispositivo está abierto si se puede leer y/o escribir en él. Por defecto, esta función devuelve false si openMode() devuelve NotOpen.

Véase también openMode() y QIODeviceBase::OpenMode.

bool QIODevice::isReadable() const

Devuelve true si se pueden leer datos del dispositivo; en caso contrario devuelve false. Utilice bytesAvailable() para determinar cuántos bytes se pueden leer.

Esta es una función de conveniencia que comprueba si el OpenMode del dispositivo contiene la bandera ReadOnly.

Véase también openMode() y OpenMode.

[virtual] bool QIODevice::isSequential() const

Devuelve true si este dispositivo es secuencial; en caso contrario devuelve false.

Los dispositivos secuenciales, a diferencia de los dispositivos de acceso aleatorio, no tienen el concepto de inicio, fin, tamaño o posición actual, y no admiten la búsqueda. Sólo se puede leer del dispositivo cuando éste informa de que hay datos disponibles. El ejemplo más común de dispositivo secuencial es un socket de red. En Unix, los ficheros especiales como /dev/zero y las tuberías fifo son secuenciales.

Los ficheros normales, por otro lado, soportan el acceso aleatorio. Tienen tanto un tamaño como una posición actual, y también soportan la búsqueda hacia adelante y hacia atrás en el flujo de datos. Los ficheros regulares no son secuenciales.

Véase también bytesAvailable().

bool QIODevice::isTextModeEnabled() const

Devuelve true si la bandera Text está activada; en caso contrario devuelve false.

Véase también setTextModeEnabled().

bool QIODevice::isTransactionStarted() const

Devuelve true si hay una transacción en curso en el dispositivo, en caso contrario false.

Véase también startTransaction().

bool QIODevice::isWritable() const

Devuelve true si se pueden escribir datos en el dispositivo; en caso contrario devuelve false.

Esta es una función de conveniencia que comprueba si el OpenMode del dispositivo contiene la bandera WriteOnly.

Véase también openMode() y OpenMode.

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

Abre el dispositivo y establece su OpenMode en mode. Devuelve true si tiene éxito; en caso contrario devuelve false. Esta función debe ser llamada desde cualquier reimplementación de open() u otras funciones que abran el dispositivo.

Véase también openMode() y QIODeviceBase::OpenMode.

QIODeviceBase::OpenMode QIODevice::openMode() const

Devuelve el modo en que se ha abierto el dispositivo; es decir, ReadOnly o WriteOnly.

Véase también setOpenMode() y OpenMode.

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

Lee como máximo maxSize bytes del dispositivo en data, sin efectos secundarios (es decir, si se llama a read() después de peek(), se obtendrán los mismos datos). Devuelve el número de bytes leídos. Si se produce un error, como cuando se intenta echar un vistazo a un dispositivo abierto en modo WriteOnly, esta función devuelve -1.

0 se devuelve cuando no hay más datos disponibles para leer.

Ejemplo:

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

Véase también read().

QByteArray QIODevice::peek(qint64 maxSize)

Consulta como máximo maxSize bytes del dispositivo y devuelve los datos consultados como QByteArray.

Ejemplo:

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

Esta función no tiene forma de informar de errores; devolver un QByteArray vacío puede significar que no hay datos disponibles para consultar o que se ha producido un error.

Véase también read().

[virtual] qint64 QIODevice::pos() const

Para los dispositivos de acceso aleatorio, esta función devuelve la posición en la que se escriben o desde la que se leen los datos. Para dispositivos secuenciales o cerrados, donde no existe el concepto de "posición actual", se devuelve 0.

La posición actual de lectura/escritura del dispositivo se mantiene internamente en QIODevice, por lo que no es necesario reimplementar esta función. Al subclasificar QIODevice, utilice QIODevice::seek() para notificar a QIODevice los cambios en la posición del dispositivo.

Véase también isSequential() y seek().

bool QIODevice::putChar(char c)

Escribe el carácter c en el dispositivo. Devuelve true en caso de éxito; en caso contrario devuelve false.

Véase también write(), getChar() y ungetChar().

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

Lee como máximo maxSize bytes del dispositivo en data, y devuelve el número de bytes leídos. Si se produce un error, como cuando se intenta leer desde un dispositivo abierto en modo WriteOnly, esta función devuelve -1.

Se devuelve 0 cuando no hay más datos disponibles para leer. Sin embargo, leer más allá del final del flujo se considera un error, por lo que esta función devuelve -1 en esos casos (es decir, leer en un socket cerrado o después de que un proceso haya muerto).

Véase también readData(), readLine(), y write().

QByteArray QIODevice::read(qint64 maxSize)

Lee como máximo maxSize bytes del dispositivo y devuelve los datos leídos como QByteArray.

Esta función no tiene forma de informar de errores; devolver un QByteArray vacío puede significar que no hay datos disponibles para leer o que se ha producido un error.

QByteArray QIODevice::readAll()

Lee todos los datos restantes del dispositivo y los devuelve como una matriz de bytes.

Esta función no tiene forma de informar de errores; devolver un QByteArray vacío puede significar que no hay datos disponibles para leer o que se ha producido un error. Esta función tampoco tiene forma de indicar que puede haber más datos disponibles y que no se han podido leer.

int QIODevice::readChannelCount() const

Devuelve el número de canales de lectura disponibles si el dispositivo está abierto; en caso contrario devuelve 0.

Véase también writeChannelCount() y QProcess.

[signal] void QIODevice::readChannelFinished()

Esta señal se emite cuando el flujo de entrada (lectura) se cierra en este dispositivo. Se emite tan pronto como se detecta el cierre, lo que significa que todavía puede haber datos disponibles para leer con read().

Véase también atEnd() y read().

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

Lee hasta maxSize bytes del dispositivo en data, y devuelve el número de bytes leídos o -1 si se ha producido un error.

Si no hay bytes para leer y nunca puede haber más bytes disponibles (ejemplos incluyen socket cerrado, tubería cerrada, subproceso terminado), esta función devuelve -1.

Esta función es llamada por QIODevice. Reimplemente esta función cuando cree una subclase de QIODevice.

Al reimplementar esta función es importante que esta función lea todos los datos requeridos antes de devolver. Esto es necesario para que QDataStream pueda operar en la clase. QDataStream asume que toda la información solicitada fue leída y por lo tanto no reintenta la lectura si hubo algún problema.

Esta función puede ser llamada con un maxSize de 0, que puede ser utilizado para realizar operaciones posteriores a la lectura.

Véase también read(), readLine(), y writeData().

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

Esta función lee una línea de caracteres ASCII del dispositivo, hasta un máximo de maxSize - 1 bytes, almacena los caracteres en data, y devuelve el número de bytes leídos. Si no se pudo leer una línea pero no se produjo ningún error, esta función devuelve 0. Si se produjo un error, esta función devuelve la longitud de lo que se pudo leer, o -1 si no se leyó nada.

Siempre se añade un byte de terminación '\0' a data, por lo que maxSize debe ser mayor que 1.

Los datos se leen hasta que se cumple una de las siguientes condiciones:

• Se lee el primer carácter '\n'.
• maxSize - Se lee 1 byte.
• Se detecta el final de los datos del dispositivo.

Por ejemplo, el siguiente código lee una línea de caracteres de un fichero:

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
    }
}

El carácter de nueva línea ('\n') se incluye en el búfer. Si no se encuentra una nueva línea antes de que se lea maxSize - 1 bytes, no se insertará una nueva línea en el búfer.

Tenga en cuenta que en dispositivos secuenciales, los datos pueden no estar disponibles inmediatamente, lo que puede dar lugar a que se devuelva una línea parcial. Llamando a la función canReadLine() antes de leer, se puede comprobar si se puede leer una línea completa (incluyendo el carácter de nueva línea).

Esta función llama a readLineData(), que se implementa utilizando llamadas repetidas a getChar(). Puede proporcionar una implementación más eficiente reimplementando readLineData() en su propia subclase.

Véase también getChar(), read(), canReadLine(), y write().

QByteArray QIODevice::readLine(qint64 maxSize = 0)

Lee una línea del dispositivo, pero no más de maxSize caracteres, y devuelve el resultado como una matriz de bytes.

Si maxSize es 0 o no se especifica, la línea puede tener cualquier longitud, lo que permite una lectura ilimitada.

La línea resultante puede tener caracteres de fin de línea ("\n" o "\r\n "), por lo que puede ser necesario llamar a QByteArray::trimmed().

Esta función no tiene forma de informar de errores; devolver un QByteArray vacío puede significar que no hay datos disponibles para la lectura o que se ha producido un error.

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

Lee hasta maxSize caracteres en data y devuelve el número de caracteres leídos.

Esta función es llamada por readLine(), y proporciona su implementación base, utilizando getChar(). Los dispositivos con buffer pueden mejorar el rendimiento de readLine() reimplementando esta función.

readLine() añade un byte '\0' a data; readLineData() no necesita hacer esto.

Si reimplementa esta función, tenga cuidado de devolver el valor correcto: debería devolver el número de bytes leídos en esta línea, incluyendo la nueva línea de terminación, o 0 si no hay ninguna línea que leer en este punto. Si se produce un error, debe devolver -1 si y sólo si no se ha leído ningún byte. Leer más allá de EOF se considera un error.

Lee una línea de este dispositivo en buffer, y devuelve el subconjunto de buffer que contiene los datos leídos.

Si el tamaño de buffer es menor que la longitud de la línea, sólo se leen y devuelven los caracteres que caben en buffer. En este caso, si se vuelve a llamar a readLineInto() se recuperará el resto de la línea. Para determinar si se ha leído toda la línea, compruebe primero si el dispositivo es atEnd(), en caso de que la última línea no terminara con una nueva línea. Si no es atEnd(), verifique si la vista devuelta termina con '\n'. En caso contrario, se requiere otra llamada a readLineInto().

La línea resultante puede tener caracteres de final de línea ("\n" o "\r\n "), por lo que puede ser necesario llamar a QByteArrayView::trimmed().

En caso de error, esta función devuelve un valor nulo QByteArrayView. En caso contrario, devuelve un buffer. Si no hay datos disponibles para la lectura o el dispositivo es atEnd(), esta función devuelve un QByteArrayView vacío.

Tenga en cuenta que el valor devuelto no tiene terminación nula. Si desea terminación nula, puede pasar buffer.chopped(1) y luego insertar '\0' en buffer[result.size()].

Estas funciones se introdujeron en Qt 6.9.

Véase también readLine().

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

Lee una línea del dispositivo, pero no más de maxSize caracteres. y la almacena como una matriz de bytes en line.

Si maxSize es 0 o no se especifica, la línea puede tener cualquier longitud, lo que permite una lectura ilimitada.

La línea resultante puede tener caracteres de final de línea ("\n" o "\r\n "), por lo que puede ser necesario llamar a QByteArray::trimmed().

Si no hay datos disponibles para la lectura, o en caso de error, esta función devuelve false y pone line en empty. En caso contrario, devuelve true.

Nótese que el contenido de line antes de la llamada se descarta en cualquier caso pero su capacity() nunca se reduce.

Esta función se introdujo en Qt 6.9.

Véase también readAll(), readLine(), y QTextStream::readLineInto().

[signal] void QIODevice::readyRead()

Esta señal se emite una vez cada vez que hay nuevos datos disponibles para lectura desde el canal de lectura actual del dispositivo. Sólo se emitirá de nuevo cuando haya nuevos datos disponibles, como cuando una nueva carga de datos de red ha llegado a su socket de red, o cuando un nuevo bloque de datos ha sido añadido a su dispositivo.

readyRead() no se emite recursivamente; si vuelves a entrar en el bucle de eventos o llamas a waitForReadyRead() dentro de una ranura conectada a la señal readyRead(), la señal no se volverá a emitir (aunque waitForReadyRead() puede seguir devolviendo true).

Nota para los desarrolladores que implementen clases derivadas de QIODevice: siempre debes emitir readyRead() cuando lleguen nuevos datos (no lo emitas sólo porque aún quedan datos por leer en tus buffers). No emitas readyRead() en otras condiciones.

Véase también bytesWritten().

[virtual] bool QIODevice::reset()

Busca el inicio de la entrada para dispositivos de acceso aleatorio. Devuelve true en caso de éxito; en caso contrario devuelve false (por ejemplo, si el dispositivo no está abierto).

Tenga en cuenta que cuando se utiliza un QTextStream en un QFile, llamar a reset() en el QFile no tendrá el resultado esperado porque QTextStream almacena el archivo. Utilice en su lugar la función QTextStream::seek().

Véase también seek().

void QIODevice::rollbackTransaction()

Retrocede una transacción de lectura.

Restaura el flujo de entrada al punto de la llamada a startTransaction(). Esta función se utiliza comúnmente para revertir la transacción cuando se detecta una lectura incompleta antes de confirmar la transacción.

Véase también startTransaction() y commitTransaction().

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

Para dispositivos de acceso aleatorio, esta función establece la posición actual en pos, devolviendo true en caso de éxito, o false si se ha producido un error. Para dispositivos secuenciales, el comportamiento por defecto es producir una advertencia y devolver false.

Cuando subclase QIODevice, debe llamar a QIODevice::seek() al comienzo de su función para asegurar la integridad con el buffer incorporado de QIODevice.

Véase también pos() y isSequential().

void QIODevice::setCurrentReadChannel(int channel)

Establece el canal de lectura actual de QIODevice en channel. El canal de entrada actual es utilizado por las funciones read(), readAll(), readLine(), y getChar(). También determina qué canal activa QIODevice para emitir readyRead().

Véase también currentReadChannel(), readChannelCount(), y QProcess.

void QIODevice::setCurrentWriteChannel(int channel)

Establece el canal de escritura actual de QIODevice en el channel dado. El canal de salida actual es utilizado por las funciones write(), putChar(). También determina qué canal activa QIODevice para emitir bytesWritten().

Véase también currentWriteChannel() y writeChannelCount().

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

Establece la descripción legible por humanos del último error de dispositivo que se ha producido en str.

Véase también errorString().

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

Establece el OpenMode del dispositivo en openMode. Llame a esta función para establecer el modo abierto si las banderas cambian después de abrir el dispositivo.

Véase también openMode() y OpenMode.

void QIODevice::setTextModeEnabled(bool enabled)

Si enabled es verdadero, esta función establece la bandera Text en el dispositivo; en caso contrario, se elimina la bandera Text. Esta función es útil para clases que proporcionan un manejo personalizado de fin de línea en un QIODevice.

El dispositivo IO debe abrirse antes de llamar a esta función.

Véase también isTextModeEnabled(), open(), y setOpenMode().

[virtual] qint64 QIODevice::size() const

Para dispositivos abiertos de acceso aleatorio, esta función devuelve el tamaño del dispositivo. Para dispositivos secuenciales abiertos, se devuelve bytesAvailable().

Si el dispositivo está cerrado, el tamaño devuelto no reflejará el tamaño real del dispositivo.

Véase también isSequential() y pos().

qint64 QIODevice::skip(qint64 maxSize)

Omite hasta maxSize bytes del dispositivo. Devuelve el número de bytes realmente omitidos, o -1 en caso de error.

Esta función no espera y sólo descarta los datos que ya están disponibles para su lectura.

Si el dispositivo se abre en modo texto, los finales de línea se traducen a símbolos '\n' y cuentan como un único byte de forma idéntica al comportamiento de read() y peek().

Esta función funciona para todos los dispositivos, incluidos los secuenciales que no pueden seek(). Está optimizada para omitir datos no deseados después de una llamada a peek().

Para dispositivos de acceso aleatorio, skip() puede utilizarse para buscar hacia adelante desde la posición actual. No se permiten valores negativos en maxSize.

Véase también skipData(), peek(), seek() y read().

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

Omite hasta maxSize bytes del dispositivo. Devuelve el número de bytes realmente omitidos, o -1 en caso de error.

Esta función es llamada por QIODevice. Considere reimplementarla cuando cree una subclase de QIODevice.

La implementación base descarta los datos leyendo en un buffer ficticio. Esto es lento, pero funciona para todo tipo de dispositivos. Las subclases pueden reimplementar esta función para mejorarla.

Esta función se introdujo en Qt 6.0.

Ver también skip(), peek(), seek(), y read().

void QIODevice::startTransaction()

Inicia una nueva operación de lectura en el dispositivo.

Define un punto recuperable dentro de la secuencia de operaciones de lectura. Para dispositivos secuenciales, los datos de lectura se duplicarán internamente para permitir la recuperación en caso de lecturas incompletas. Para dispositivos de acceso aleatorio, esta función guarda la posición actual. Llame a commitTransaction() o rollbackTransaction() para finalizar la transacción.

Véase también commitTransaction() y rollbackTransaction().

void QIODevice::ungetChar(char c)

Devuelve el carácter c al dispositivo, y decrementa la posición actual a menos que la posición sea 0. Esta función se llama normalmente para "deshacer" una operación getChar(), como cuando se escribe un analizador de retroceso.

Si c no se ha leído previamente del dispositivo, el comportamiento es indefinido.

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

Para dispositivos con búfer, esta función espera hasta que se haya escrito en el dispositivo una carga útil de datos escritos en búfer y se haya emitido la señal bytesWritten(), o hasta que hayan transcurrido msecs milisegundos. Si msecs es -1, esta función no agotará el tiempo de espera. Para dispositivos sin búfer, devuelve inmediatamente.

Devuelve true si se ha escrito una carga de datos en el dispositivo; en caso contrario, devuelve false (es decir, si se ha agotado el tiempo de espera de la operación o se ha producido un error).

Esta función puede funcionar sin un bucle de eventos. Es útil cuando se escriben aplicaciones no-GUI y cuando se realizan operaciones de E/S en un hilo no-GUI.

Si se llama desde dentro de una ranura conectada a la señal bytesWritten(), bytesWritten() no se volverá a emitir.

Reimplemente esta función para proporcionar una API de bloqueo para un dispositivo personalizado. La implementación por defecto no hace nada, y devuelve false.

Véase también waitForReadyRead().

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

Se bloquea hasta que haya nuevos datos disponibles para su lectura y se haya emitido la señal readyRead(), o hasta que hayan transcurrido msecs milisegundos. Si msecs es -1, esta función no agotará el tiempo de espera.

Devuelve true si hay nuevos datos disponibles para su lectura; en caso contrario, devuelve false (si la operación ha expirado o si se ha producido un error).

Esta función puede operar sin un bucle de eventos. Es útil cuando se escriben aplicaciones no-GUI y cuando se realizan operaciones de E/S en un hilo no-GUI.

Si se llama desde dentro de una ranura conectada a la señal readyRead(), readyRead() no se volverá a emitir.

Reimplemente esta función para proporcionar una API de bloqueo para un dispositivo personalizado. La implementación por defecto no hace nada, y devuelve false.

Véase también waitForBytesWritten().

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

Escribe como máximo maxSize bytes de datos desde data al dispositivo. Devuelve el número de bytes que se escribieron realmente, o -1 si se produjo un error.

Véase también read() y writeData().

qint64 QIODevice::write(const QByteArray &data)

Escribe el contenido de data en el dispositivo. Devuelve el número de bytes que se escribieron realmente, o -1 si se produjo un error.

Véase también read() y writeData().

qint64 QIODevice::write(const char *data)

Escribe datos de una cadena de caracteres de 8 bits terminada en cero en el dispositivo. Devuelve el número de bytes que se escribieron realmente, o -1 si se produjo un error. Equivale a

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

Véase también read() y writeData().

int QIODevice::writeChannelCount() const

Devuelve el número de canales de escritura disponibles si el dispositivo está abierto; en caso contrario devuelve 0.

Véase también readChannelCount().

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

Escribe hasta maxSize bytes desde data al dispositivo. Devuelve el número de bytes escritos, o -1 si se ha producido un error.

Esta función es llamada por QIODevice. Reimplemente esta función cuando cree una subclase de QIODevice.

Al reimplementar esta función es importante que esta función escriba todos los datos disponibles antes de retornar. Esto es necesario para que QDataStream pueda operar sobre la clase. QDataStream asume que toda la información fue escrita y por lo tanto no reintenta la escritura si hubo algún problema.

Véase también read() y write().