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

 #ifndef LEINPUT_H
 #define LEINPUT_H
 
 #include <QtCore/QtEndian>
 #include <QtCore/QByteArray>
 #include <QtCore/QDebug>
 
 template <typename T>
 const T*
 toPtr(const T& t) {
     return (t.isValid()) ?&t :0;
 }
 
 class FixedSizeParsedObject {
 private:
     const char* _data;
 protected:
     explicit FixedSizeParsedObject() :_data(0) {}
     inline void init(const char* data) {
         _data = data;
     }
 public:
     inline const char* getData() const { return _data; }
     inline bool isValid() const { return _data; }
     inline bool operator==(const FixedSizeParsedObject& o) {
         return _data && o._data && _data == o._data;
     }
 };
 
 class ParsedObject : public FixedSizeParsedObject {
 private:
     quint32 _size;
 protected:
     explicit ParsedObject() :FixedSizeParsedObject(), _size(0) {}
     inline void init(const char* data, quint32 size) {
         FixedSizeParsedObject::init(data);
         _size = size;
     }
 public:
     inline quint32 getSize() const { return _size; }
 };
 
 template <typename T>
 class MSOCastArray {
 private:
     const T* _data;
     quint32 _count;
 public:
     explicit MSOCastArray() :_data(0), _count(0) {}
     explicit MSOCastArray(const T* data, qint32 count) :_data(data), _count(count) {}
     inline const T* getData() const { return _data; }
     QByteArray mid(int pos, int len = -1) const {
         if (pos > _count) return QByteArray();
         if (len < 0 || len > _count - pos) {
             len = _count - pos;
         }
         return QByteArray(_data + pos, len);
     }
     inline int getCount() const { return _count; }
     inline T operator[](int pos) const { return _data[pos]; }
     inline bool operator!=(const QByteArray& b) {
         return QByteArray::fromRawData(_data, _count) != b;
     }
     inline operator QByteArray() const { return QByteArray(_data, _count); }
 };
 template <typename T> class MSOArray;
 template <typename T>
 class MSOconst_iterator {
 private:
     T currentItem;
     const MSOArray<T>& c;
     quint32 offset;
 public:
     explicit MSOconst_iterator(const MSOArray<T>& c_, int o) :c(c_), offset(o) {
         currentItem = T(c.getData(), c.getSize());
     }
     inline bool operator!=(const MSOconst_iterator &o) const {
         return offset != o.offset;
     }
     inline void operator++() {
         offset += currentItem.getSize();
         currentItem = T(c.getData() + offset, c.getSize() - offset);
     }
     inline const T& operator*() const {
         return currentItem;
     }
 };
 template <typename T>
 class MSONullable {
 private:
     T t;
 public:
     MSONullable() {}
     MSONullable(const T& data) :t(data) {}
     inline bool isPresent() const { return t.isValid(); }
     inline quint32 getSize() const { return t.getSize(); }
     inline const T& operator * () const { return t; }
 };
 template <typename T>
 class MSOBasicNullable {
 private:
     T _value;
     bool _set;
 public:
     explicit MSOBasicNullable() :_value(0), _set(false) {}
     MSOBasicNullable(T value) :_value(value), _set(true) {}
     inline bool isPresent() const { return _set; }
     inline T operator * () const { return _value; }
 };
 template <typename T>
 class MSOArray : public ParsedObject {
 friend class MSOconst_iterator<T>;
 private:
     quint32 _count;
 public:
     typedef MSOconst_iterator<T> const_iterator;
     MSOArray() :_count(0) {}
     MSOArray(const char* d, quint32 maxsize) :_count(0) {
         quint32 msize = 0;
         quint32 mcount = 0;
         while (msize < maxsize) {
             T v(d + msize, maxsize - msize);
             if (!v.isValid()) {
                 break;
             }
             msize += v.getSize();
             mcount++;
         }
         ParsedObject::init(d, msize);
         _count = mcount;
     }
     MSOArray(const char* d, quint32 maxsize, quint32 mcount) :_count(0) {
         quint32 msize = 0;
         for (quint32 i = 0; i < mcount; ++i) {
             T v(d + msize, maxsize - msize);
             if (!v.isValid()) {
                 return;
             }
             msize += v.getSize();
             if (msize > maxsize) {
                 return;
             }
         }
         ParsedObject::init(d, msize);
         _count = mcount;
     }
     inline quint32 getCount() const {
         return _count;
     }
     inline MSOconst_iterator<T> begin() const {
         return MSOconst_iterator<T>(*this, 0);
     }
     inline MSOconst_iterator<T> end() const {
         return MSOconst_iterator<T>(*this, getSize());
     }
     T operator[](quint32 pos) const {
         T t(ParsedObject::getData(), ParsedObject::getSize());
         quint32 i = 0;
         quint32 offset = 0;
         while (i < pos && t.isValid()) {
             offset += t.getSize();
             t = T(ParsedObject::getData() + offset,
                   ParsedObject::getSize() - offset);
             ++i;
         }
         return t;
     }
 };
 
 inline quint8 readuint8(const char* d) {
     return *d;
 }
 inline quint16 readuint16(const char* d) {
     return qFromLittleEndian<quint16>((const unsigned char*)d);
 }
 inline qint16 readint16(const char* d) {
     return qFromLittleEndian<qint16>((const unsigned char*)d);
 }
 inline quint32 readuint32(const char* d) {
     return qFromLittleEndian<quint32>((const unsigned char*)d);
 }
 inline qint32 readint32(const char* d) {
     return qFromLittleEndian<qint32>((const unsigned char*)d);
 }
 
 inline bool readbit(const char* d) {
     return *d & 0x01;
 }
 inline bool readbit_1(const char* d) {
     return *d >> 1 & 0x01;
 }
 inline bool readbit_2(const char* d) {
     return *d >> 2 & 0x01;
 }
 inline bool readbit_3(const char* d) {
     return *d >> 3 & 0x01;
 }
 inline bool readbit_4(const char* d) {
     return *d >> 4 & 0x01;
 }
 inline bool readbit_5(const char* d) {
     return *d >> 5 & 0x01;
 }
 inline bool readbit_6(const char* d) {
     return *d >> 6 & 0x01;
 }
 inline bool readbit_7(const char* d) {
     return *d >> 7 & 0x01;
 }
 inline quint8 readuint2(const char* d) {
     return *d & 0x03;
 }
 inline quint8 readuint2_2(const char* d) {
     return *d >> 2 & 0x03;
 }
 inline quint8 readuint2_4(const char* d) {
     return *d >> 4 & 0x03;
 }
 inline quint8 readuint2_6(const char* d) {
     return *d >> 6 & 0x03;
 }
 inline quint8 readuint3(const char* d) {
     return *d & 0x07;
 }
 inline quint8 readuint3_2(const char* d) {
     return *d >> 2 & 0x07;
 }
 inline quint8 readuint3_5(const char* d) {
     return *d >> 5 & 0x07;
 }
 inline quint8 readuint4(const char* d) {
     return *d & 0x0F;
 }
 inline quint8 readuint4_2(const char* d) {
     return *d >> 2 & 0x0F;
 }
 inline quint8 readuint4_4(const char* d) {
     return *d >> 4 & 0x0F;
 }
 inline quint8 readuint5(const char* d) {
     return *d & 0x1F;
 }
 inline quint8 readuint5_3(const char* d) {
     return *d >> 3 & 0x1F;
 }
 inline quint8 readuint6(const char* d) {
     return *d & 0x3F;
 }
 inline quint8 readuint6_2(const char* d) {
     return *d >> 2 & 0x3F;
 }
 inline quint8 readuint7(const char* d) {
     return *d & 0x7F;
 }
 inline quint8 readuint7_1(const char* d) {
     return *d >> 1 & 0x7F;
 }
 inline quint16 readuint9(const char* d) {
     return readuint16(d) & 0x01FF;
 }
 inline quint16 readuint12_4(const char* d) {
     return readuint16(d) >> 4 & 0x0FFF;
 }
 inline quint16 readuint13_3(const char* d) {
     return readuint16(d) >> 3 & 0x1FFF;
 }
 inline quint16 readuint14(const char* d) {
     return readuint16(d) & 0x3FFF;
 }
 inline quint16 readuint14_2(const char* d) {
     return readuint16(d) >> 2 & 0x3FFF;
 }
 inline quint16 readuint15_1(const char* d) {
     return readuint16(d) >> 1 & 0x7FFF;
 }
 inline quint32 readuint20(const char* d) {
     return readuint32(d) & 0x0FFFFF;
 }
 inline quint32 readuint20_4(const char* d) {
     return readuint32(d) >> 4 & 0x0FFFFF;
 }
 inline quint32 readuint30(const char* d) {
     return readuint32(d) & 0x3FFFFFFF;
 }
 
 #endif