Lire à partir de QTcpSocket à l'aide de QDataStream

J'ai besoin d'envoyer des données binaires par le biais d'un QTcpSocket. Je pensais à l'aide de QDataStream, mais j'ai rencontré un problème - il silencieusement échoue si aucune donnée n'est arrivé à l'heure j'essaie de lire.

Par exemple si j'ai ce code:

QString str;
stream >> str;

Il échoue silencieusement si aucune donnée n'est actuellement là-bas dans le support. Est-il un moyen de le dire à bloc à la place?

OriginalL'auteur sashoalm | 2013-10-30

  1. 14

    Le problème est un peu plus sérieux. Socket peut recevoir des données en blocs, de sorte que même si vous attendez pour waitForReadyRead il peut échouer car il n'y a pas assez de données pour lire immédiatement certains objets.

    Pour résoudre ce problème, vous devez envoyer une taille de données d'abord, puis des données réelles.
    Envoyer code:

    QByteArray block;
QDataStream sendStream(&block, QIODevice::ReadWrite);
sendStream << quint16(0) << str;

sendStream.device()->seek(0);
sendStream << (quint16)(block.size() - sizeof(quint16));

tcpSocket->write(block);

    Sur le récepteur, vous devez attendre jusqu'à ce que la taille des données disponibles est satisfait à l'exigence. Récepteur code ressemble plus ou moins comme ça:

    void SomeClass::slotReadClient() { //slot connected to readyRead signal of QTcpSocket
    QTcpSocket *tcpSocket = (QTcpSocket*)sender();
    QDataStream clientReadStream(tcpSocket);

    while(true) {
        if (!next_block_size) {
            if (tcpSocket->bytesAvailable() < sizeof(quint16)) { //are size data available
                break;
            }
            clientReadStream >> next_block_size;
        }

        if (tcpSocket->bytesAvailable() < next_block_size) {
            break;
        }
        QString str;
        clientReadStream >> str;

        next_block_size = 0;
    }
}

    petite mise à jour, basée sur la documentation il est possible de lire QString sans l'ajout des informations de taille, depuis QString passé à QDataStream contient des informations sur la taille. La taille peut être vérifiée comme suit:

    void SomeClass::slotReadClient() { //slot connected to readyRead signal of QTcpSocket
    QTcpSocket *tcpSocket = (QTcpSocket*)sender();
    while(true) {
        if (tcpSocket->bytesAvailable() < 4) {
           break;
        }
        char buffer[4]
        quint32 peekedSize;
        tcpSocket->peek(buffer, 4);
        peekedSize = qFromBigEndian<quint32>(buffer); //default endian in QDataStream
        if (peekedSize==0xffffffffu) //null string
           peekedSize = 0;
        peekedSize += 4;
        if (tcpSocket->bytesAvailable() < peekedSize) {
           break;
        }
        //here all required for QString  data are available
        QString str;
        QDataStream(tcpSocket) >> str;
        emit stringHasBeenRead(str);
     }
}
    Merci, cela semble être la bonne façon. Je suis en train de retravailler le code pour faire une classe Block, qui permet d'automatiser l'écriture de la taille du bloc dans son constructeur/destructeur, et affichera le code de peu de temps.
    OK, j'ai fini d'écrire le cours, j'ai posté une réponse.

    OriginalL'auteur Marek R

  2. 9

    J'ai retravaillé le code de @Marek idée et créé 2 classes - BlockReader et BlockWriter:

    Exemple d'utilisation:

    //Write block to the socket.
BlockWriter(socket).stream() << QDir("C:/Windows").entryList() << QString("Hello World!");

....

//Now read the block from the socket.
QStringList infoList;
QString s;
BlockReader(socket).stream() >> infoList >> s;
qDebug() << infoList << s;

    BlockReader:

    class BlockReader
{
public:
    BlockReader(QIODevice *io)
    {
        buffer.open(QIODevice::ReadWrite);
        _stream.setVersion(QDataStream::Qt_4_8);
        _stream.setDevice(&buffer);

        quint64 blockSize;

        //Read the size.
        readMax(io, sizeof(blockSize));
        buffer.seek(0);
        _stream >> blockSize;

        //Read the rest of the data.
        readMax(io, blockSize);
        buffer.seek(sizeof(blockSize));
    }

    QDataStream& stream()
    {
        return _stream;
    }

private:
    //Blocking reads data from socket until buffer size becomes exactly n. No
    //additional data is read from the socket.
    void readMax(QIODevice *io, int n)
    {
        while (buffer.size() < n) {
            if (!io->bytesAvailable()) {
                io->waitForReadyRead(30000);
            }
            buffer.write(io->read(n - buffer.size()));
        }
    }
    QBuffer buffer;
    QDataStream _stream;
};

    BlockWriter:

    class BlockWriter
{
public:
    BlockWriter(QIODevice *io)
    {
        buffer.open(QIODevice::WriteOnly);
        this->io = io;
        _stream.setVersion(QDataStream::Qt_4_8);
        _stream.setDevice(&buffer);

        //Placeholder for the size. We will get the value
        //at the end.
        _stream << quint64(0);
    }

    ~BlockWriter()
    {
        //Write the real size.
        _stream.device()->seek(0);
        _stream << (quint64) buffer.size();

        //Flush to the device.
        io->write(buffer.buffer());
    }

    QDataStream &stream()
    {
        return _stream;
    }

private:
    QBuffer buffer;
    QDataStream _stream;
    QIODevice *io;
};
    J'aime le fait que, bien que j'avais probablement surcharger le flux des opérateurs de la classe, plutôt que de retourner à l'intérieur _stream de l'utilisateur, juste pour le rendre un peu plus élégant dans son utilisation.
    Cela peut par hasard être utilisé pour transmettre des fichiers VOLUMINEUX?
    J'avais pense que oui. Aussi longtemps que vous divisez votre gros fichier(s) dans les blocs. Mais tout à la fois... probablement pas.

    OriginalL'auteur sashoalm

  3. 3

    Vous pouvez appeler le QTCPSocket::waitForReadyRead fonction, ce qui permet de bloquer jusqu'à ce que les données sont disponibles, ou connectez-vous à la readyRead() du signal et lorsque votre logement est appelé, puis lu à partir du flux.

    Oui, mais je ne peux pas savoir combien d'octets dont j'ai besoin. Supposons que j'ai sérialisé un QString, comment puis-je savoir combien d'octets j'ai besoin de disponible? Quelle est la durée de la QString? QDataStream prend soin de ces détails. Cela va à l'encontre de l'objectif de l'aide de QDataStream en premier lieu. Btw, j'ai eu un paragraphe expliquant pourquoi ce n'est pas une bonne solution à ma question, mais a décidé de l'enlever pour garder ma question brève - je n'aime pas à énumérer toutes les idées qui ne sont pas bonnes.
    me battre pour elle; ajoutant la taille des paquets et de vérification pour la taille de la douille de réception est certainement la bonne façon de faire.

    OriginalL'auteur TheDarkKnight