File indexing completed on 2024-04-28 04:40:01

 #ifndef LEOUTPUTSTREAM_H
 #define LEOUTPUTSTREAM_H
 
 #include "leinputstream.h"
 
 class LEOutputStream {
 private:
     QIODevice* output;
     QDataStream data;
 
     qint8 bitfieldpos;
     quint8 bitfield;
 
     void writeBits(quint8 n, quint8 v) {
         bitfield = v << bitfieldpos | bitfield;
         bitfieldpos += n;
         if (bitfieldpos == 8) {
             data << bitfield;
             bitfield = 0;
             bitfieldpos = 0;
         } else if (bitfieldpos > 8) {
             throw IOException("Bitfield does not have enough bits left.");
         }
     }
 
     void checkForLeftOverBits() const {
         if (bitfieldpos != 0) {
             throw IOException(
                 "Cannot read this type halfway through a bit operation.");
         }
     }
 
 public:
 
     LEOutputStream(QIODevice* out) :output(out), data(out) {
         bitfield = 0;
         bitfieldpos = 0;
         data.setByteOrder(QDataStream::LittleEndian);
     }
 
     void writebit(bool v) {
         writeBits(1, (v) ?1 :0);
     }
 
     void writeuint2(quint8 v) {
         writeBits(2, v);
     }
 
     void writeuint3(quint8 v) {
         writeBits(3, v);
     }
 
     void writeuint4(quint8 v) {
         writeBits(4, v);
     }
 
     void writeuint5(quint8 v) {
         writeBits(5, v);
     }
 
     void writeuint6(quint8 v) {
         writeBits(6, v);
     }
 
     void writeuint7(quint8 v) {
         writeBits(7, v);
     }
 
     void writeuint9(quint16 v) {
         data << (quint8) v;
         writeBits(1, v >> 8);
     }
 
     void writeuint12(quint16 v) {
         writeBits(4, v);
         data << (quint8)(v >> 4);
     }
 
     void writeuint13(quint16 v) {
         writeBits(5, v);
         data << (quint8)(v >> 5);
     }
 
     void writeuint14(quint16 v) {
         if (bitfieldpos == 0) {
             data << (quint8) v;
             writeBits(6, v >> 8);
         } else if (bitfieldpos == 2) {
             writeBits(6, v);
             data << (quint8)(v >> 6);
         } else {
             throw IOException(
                 "Cannot write this type halfway through a bit operation.");
         }
     }
 
     void writeuint15(quint16 v) {
         // we assume there are 7 bits left
         writeBits(7, v);
         data << (quint8)(v >> 7);
     }
 
     void writeuint20(quint32 v) {
         if (bitfieldpos == 0) {
             data << (quint8) v;
             data << (quint8)(v >> 8);
             writeBits(4, v >> 16);
         } else if (bitfieldpos == 4) {
             writeBits(4, v);
             data << (quint8)(v >> 4);
             data << (quint8)(v >> 12);
         } else {
             throw IOException(
                 "Cannot write this type halfway through a bit operation.");
         }
     }
 
     void writeuint30(quint32 v) {
         checkForLeftOverBits();
         data << (quint8) v;
         data << (quint8)(v >> 8);
         data << (quint8)(v >> 16);
         writeBits(6, v >> 24);
     }
 
     void writeuint8(quint8 v) {
         checkForLeftOverBits();
         data << v;
     }
 
     void writeint16(qint16 v) {
         checkForLeftOverBits();
         data << v;
     }
 
     void writeuint16(quint16 v) {
         checkForLeftOverBits();
         data << v;
     }
 
     void writeuint32(quint32 v) {
         checkForLeftOverBits();
         data << v;
     }
 
     void writeint32(qint32 v) {
         checkForLeftOverBits();
         data << v;
     }
 
     void writeBytes(const QByteArray& b) {
         int offset = 0;
         int todo = b.size();
         do {
             int nwritten = data.writeRawData(b.data() + offset, todo);
             if (nwritten == -1) return; //TODO report error
             todo -= nwritten;
             offset += nwritten;
         } while (todo > 0);
     }
 
     quint64 getPosition() const { return output->pos(); }
 };
 
 #endif