Discussion :

[gassi64]

Bonjour,

Je ne trouve pas de solution au problème suivant, posé par mon chef.

Voici le contexte.

Ce que j'ai : une structure de données (typedef struct) contenant des uint8, des uint32, des char *, des int16 provenant d'une bibliothèque en C.

Ce que je veux : sérialiser une instance de cette structure en format Little Endian OU Big Endian, dans un fichier binaire avec 1) la taille requise de l'instance toujours en BigEndian 2) suivie de la valeur en LittleEndian ou BigEndian.

Actuellement j'y arrive presque via

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
dataStream.setDevice(m_binFile);
dataStream.setByteOrder(QDataStream::BigEndian /* ou LittleEndian*/);
 
/* length */
dataStream << quint32(7);
 
/* data (example for digital data without char * data) */
dataStream << qint16( QString(readBytesList.value(0)).toInt()) 
           << quint32(QString(readBytesList.value(1)).toUInt())
           << quint8( QString(readBytesList.value(2)).toUInt());

Le problème est le suivant :
La fonction setByteOrder() change tous les octets, or je voudrais toujours avoir le champs "taille" en BigEndian.

Comment faire ?

Merci pour les pistes que vous pourriez m'apporter !

[gbdivers]

Peut être tester pour forcer l'écriture (avec flush ? ça existe ?) après la taille et changer ensuite l'endian
Mais je crois pas que QDataStream soit fait pour ça

Sinon, le plus simple est probablement d'inverser les bits de la taille lorsque tu es en littleendian, ce qui reviendra à l'écrire en bigendian... mais j'ai du mal à comprendre l'intérêt d'une telle modification d'endian pendant la lecture/écriture

Une petite fonction pour inverser :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#ifdef OPENMS_BIG_ENDIAN
template <typename T>
T ByteReverse(const T in)
{
  T out;
  const char * pin = (const char *) &in;
  char * pout = (char *) (&out + 1) - 1;
 
  int i;
  for (i = sizeof(T); i > 0; --i)
  {
    *pout-- = *pin++;
  }
  return out;
}
 
#endif

[droggo]

Joa,

Je trouve bizarre d'envisager un mélange de big et little endian dans le même fichier, bonjour le mélange pour s'y retrouver.

À dire vrai, c'est même carrément une très mauvaise idée.

[gassi64]

Bonjour,

J'ai trouvé ma réponse en fouillant les fonctions proposées par Qt.

Voici la solution de mon problème :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
#include <QCoreApplication>
#include <QDataStream>
#include <QDebug>
#include <QFile>
#include <QtEndian>
 
int main(int argc, char *argv[])
{
    QCoreApplication application(argc, argv);
 
    /* Create binary output file */
    QFile * binFile = new QFile("D:/workspace/output.bin");
 
    if (!binFile->open(QIODevice::WriteOnly))
        return EXIT_FAILURE;
 
    QDataStream dataStream(binFile);
 
    /* switch according to target */
    dataStream.setByteOrder(QDataStream::LittleEndian);
    //dataStream.setByteOrder(QDataStream::BigEndian);
 
    /* an example with simple data */
 
    int length = 7; // = 1 (for uint8) + 2 (for uint16) + 4 (for uint32) 
 
    /* Item length */
    QByteArray lLengthBytesArray;
    lLengthBytesArray.resize(4);
    qToBigEndian(quint32(length), (uchar*) lLengthBytesArray.data());
    dataStream.writeRawData(lLengthBytesArray, 4);
 
    /* data */
    dataStream << quint8(5)
               << qint16(23)
               << qint32(4830);
 
    if (binFile) {
        binFile->close();
        delete binFile;
        binFile = 0;
    }
 
    //return application.exec();
    return EXIT_SUCCESS;
}

En switchant l'ordre des octets via dataStream.setByteOrder(xxxx), j'obtiens (en lisant avec l'éditeur de texte hexa WinHex) :

00 00 00 07 (length) 05 17 00 DE 12 00 00 en Little Endian (format Windows)

00 00 00 07 (length) 05 00 17 00 00 12 DE en Big Endian (format d'un machine cible type unix)

Je vous remercie pour les réponses qui m'ont permis d'avoir des pistes à explorer.