Russian Qt Forum

C++ (Qt)
struct A {
  int a; // 2 bits
  int b; // 15
};
 
struct B {
  A a;
  int b; // 26
  int c; // 1
  int d; // 53
};
 
struct C {
  int a; // 42
  B b[];
  int c; // 12
};

C++ (Qt)
template<N, S>
struct Field {
  bool v // if N == 1
  int8_t v // if N <= 8 && S=signed
  uint8_t v // if N <= 8 && S=unsigned
  ...
};

C++ (Qt)
// Схемы пакетов
auto ShemaPacket1 = std::make_tuple( 3, 3, 10, 52 );
auto ShemaPacket2 = std::make_tuple( 9, 11, 37, 60, 1, 1 );
 
// Возвращает упакованный bit_array
auto bits1 = pack( ShemaPacket1, 1, 2, 8, 1024 );
auto bits2 = pack( ShemaPacket1, data.val1, data.val2, data.val3, data.val4 );
auto bits3 = pack( ShemaPacket2, 15, 0, 0, 1024, 1, 0 );
 
// Возвращает кортеж значений по указанной схеме или exception
auto result1 = unpack( bits1, ShemaPacket1 )
auto [val1, val2, val3, val4] = unpack( bits1, ShemaPacket1 )
auto result3 = unpack( bits3, ShemaPacket2 )
 
 

C++ (Qt)
static const unsigned int BitsInByte = 8;
 
unsigned long readBits(unsigned char bits, unsigned char *buf, unsigned int *pBufPos)
{
    unsigned int bufPos = *pBufPos, newBufPos = bufPos + bits;
    unsigned int bufIndexOfFirstByte = bufPos / BitsInByte;
    unsigned int ignoreBitsInFirstByte = bufPos % BitsInByte;
    unsigned int fullByteStart = bufPos + (BitsInByte - ignoreBitsInFirstByte);
    unsigned int additionalBits = newBufPos - fullByteStart;
    unsigned int bitsInLastByte = additionalBits - (additionalBits / BitsInByte) * BitsInByte;
    unsigned int bufIndexOfLastByte = (newBufPos - 1) / BitsInByte + (bitsInLastByte ? 0 : 1);
 
    // start with remainder bits of the first byte
    unsigned long value = buf[bufIndexOfFirstByte] >> ignoreBitsInFirstByte;
    // add "full" bytes in between
    for (unsigned int fullByteIndex = fullByteStart / BitsInByte, lshiftBits = BitsInByte - ignoreBitsInFirstByte; fullByteIndex < bufIndexOfLastByte; ++fullByteIndex, lshiftBits += BitsInByte)
        value |= buf[fullByteIndex] << lshiftBits;
    // end with a piece of the last byte
    if (bitsInLastByte)
        value |= (buf[bufIndexOfLastByte] & ((1 << bitsInLastByte) - 1)) << (bits - bitsInLastByte);
 
    *pBufPos = newBufPos;
    return value;
}
 
int main()
{
  unsigned char buf[] = {0, 0x1E, 0x40};
  unsigned int pos = 0;
  std::cout << readBits(9, buf, &pos) << ' ' << readBits(13, buf, &pos) << '\n'; // 0 15
  return 0;
}

C++ (Qt)
int main()
{
  std::array c = {std::byte{0}, std::byte{0x78}, std::byte{0x2}}; // swapped
  auto u = bitpacker::unpack(BP_STRING("<u9u13"), c); // < означает LSB
  std::cout << std::get<0>(u) << ' ' << std::get<1>(u) << '\n';
  return 0;
}

C++ (Qt)
// C++17
#include <type_traits>
#include <iostream>
 
struct I
{
  virtual int64_t value() const = 0;
  virtual void print() const = 0;
};
 
template<int N>
struct A : public I
{
  static constexpr auto size = N;
 
  std::conditional_t<size == 1, bool,
    std::conditional_t<size <= 8, char, int>
  > v;
 
  A(decltype(v) vv) : v(vv) {}
 
  int64_t value() const override { return v; }
  void print() const override { std::cout << size << ' ' << std::boolalpha << v << '\n'; }
};
 
int main()
{
  A<1> a{true};
  A<8> b{'!'};
  A<10> c{42};
 
  static_assert(a.size == 1);
  static_assert(std::is_same_v<decltype(a.v), bool>);
  static_assert(std::is_same_v<decltype(b.v), char>);
  static_assert(std::is_same_v<decltype(c.v), int>);
 
  for (auto const i : std::initializer_list<I const *>{&a, &b, &c})
  {
    std::cout << i->value() << '\t';
    i->print();
  }
 
  return 0;
}

C++ (Qt)
        /// finds the smallest fixed width unsigned integer that can fit NumBits bits
        template <size_type NumBits>
        using unsigned_type = std::conditional_t<NumBits <= 8, uint8_t,
                std::conditional_t<NumBits <= 16, uint16_t,
                        std::conditional_t<NumBits <= 32, uint32_t,
                                std::conditional_t<NumBits <= 64, uint64_t,
                                        void >>>>;
 
        /// finds the smallest fixed width signed integer that can fit NumBits bits
        template <size_type NumBits>
        using signed_type = std::conditional_t<NumBits <= 8, int8_t,
                std::conditional_t<NumBits <= 16, int16_t,
                        std::conditional_t<NumBits <= 32, int32_t,
                                std::conditional_t<NumBits <= 64, int64_t,
                                        void >>>>;

C++ (Qt)
std::array c = {std::byte{0}, std::byte{0x78}, std::byte{0x2}};

C++ (Qt)
struct A {
  int m_B;
  int m_C;
  ...
  qint64 m_bits;
}

C++ (Qt)
struct A {
  int m_B;
  short m_C;
  ...
  char m_Z;
};

C++ (Qt)
void A::ReadWrite( CBitStream & stream, TMode mode ) 
{
  stream.ReadWriteInt(&m_B, 4, mode);    
  stream.ReadWriteShort(&m_C, 12, mode);
  ...
  stream.ReadWriteChar(&m_Z, 7, mode);
}

C++ (Qt)
  struct record
  {
    bit_field<1> flag;
    bit_field<4> mode;
    bit_field<9> address;
 
    bit_array pack() const
    {
      return ::pack( flag, mode, address );
    }
 
    static record  unpack( const bit_array &src )
    {
      record result;
      ::unpack( src, result.flag, result.mode, result.address );
      return result;
    }
  };
 

XML
    <DataItem id="020">
        <DataItemName>Target Report Descriptor</DataItemName>
        <DataItemDefinition>Type and characteristics of the radar data as transmitted by a radar station.</DataItemDefinition>
        <DataItemFormat desc="Variable length Data Item comprising a first part of oneoctet, followed by one-octet extents as necessary.">
            <Variable>
                <Fixed length="1">
                    <Bits bit="8">
                        <BitsShortName>TYP</BitsShortName>
                        <BitsValue val="0">Plot</BitsValue>
                        <BitsValue val="1">Track</BitsValue>
                    </Bits>
                    <Bits bit="7">
                        <BitsShortName>SIM</BitsShortName>
                        <BitsValue val="0">Actual plot or track</BitsValue>
                        <BitsValue val="1">Simulated plot or track</BitsValue>
                    </Bits>
                    <Bits from="6" to="5">
                        <BitsShortName>SSRPSR</BitsShortName>
                        <BitsValue val="0">No detection</BitsValue>
                        <BitsValue val="1">Sole primary detection</BitsValue>
                        <BitsValue val="2">Sole secondary detection</BitsValue>
                        <BitsValue val="3">Combined primary and secondary detection</BitsValue>
                    </Bits>
                    <Bits bit="4">
                        <BitsShortName>ANT</BitsShortName>
                        <BitsValue val="0">Target report from antenna 1</BitsValue>
                        <BitsValue val="1">Target report from antenna 2</BitsValue>
                    </Bits>
                    <Bits bit="3">
                        <BitsShortName>SPI</BitsShortName>
                        <BitsValue val="0">Default</BitsValue>
                        <BitsValue val="1">Special Position Identification</BitsValue>
                    </Bits>
                    <Bits bit="2">
                        <BitsShortName>RAB</BitsShortName>
                        <BitsValue val="0">Default</BitsValue>
                        <BitsValue val="1">Plot or track from a fixed transponder</BitsValue>
                    </Bits>
                    <Bits bit="1" fx="1">
                        <BitsShortName>FX</BitsShortName>
                        <BitsValue val="0">End of Data Item</BitsValue>
                        <BitsValue val="1">Extension into first extent</BitsValue>
                    </Bits>
                </Fixed>
                <Fixed length="1">
                    <Bits bit="8">
                        <BitsShortName>TST</BitsShortName>
                        <BitsValue val="0">Default</BitsValue>
                        <BitsValue val="1">Test target indicator</BitsValue>
                    </Bits>
                    <Bits from="7" to="6">
                        <BitsShortName>DS1DS2</BitsShortName>
                        <BitsValue val="0">Default</BitsValue>
                        <BitsValue val="1">Unlawful interference (code 7500)</BitsValue>
                        <BitsValue val="2">Radio-communication failure (code 7600)</BitsValue>
                        <BitsValue val="3">Emergency (code 7700)</BitsValue>
                    </Bits>
                    <Bits bit="5">
                        <BitsShortName>ME</BitsShortName>
                        <BitsValue val="0">Default</BitsValue>
                        <BitsValue val="1">Military emergency</BitsValue>
                    </Bits>
                    <Bits bit="4">
                        <BitsShortName>MI</BitsShortName>
                        <BitsValue val="0">Default</BitsValue>
                        <BitsValue val="1">Military identification</BitsValue>
                    </Bits>
                    <Bits from="3" to="2">
                        <BitsShortName>spare</BitsShortName>
                        <BitsName>spare bits set to 0</BitsName>
                        <BitsConst>0</BitsConst>
                    </Bits>
                    <Bits bit="1" fx="1">
                        <BitsShortName>FX</BitsShortName>
                        <BitsValue val="0">End of Data Item</BitsValue>
                        <BitsValue val="1">Extension into next extent</BitsValue>
                    </Bits>
                </Fixed>
            </Variable>
        </DataItemFormat>
    </DataItem>
 
    <DataItem id="040">
        <DataItemName>Measured Position in Polar Coordinates</DataItemName>
        <DataItemDefinition>Measured position of an aircraft in local polar coordinates.</DataItemDefinition>
        <DataItemFormat desc="Four-octet fixed length Data Item.">
            <Fixed length="4">
                <Bits from="32" to="17">
                    <BitsShortName>RHO</BitsShortName>
                    <BitsUnit max="512" scale="0.0078125">NM</BitsUnit>
                </Bits>
                <Bits from="16" to="1">
                    <BitsShortName>THETA</BitsShortName>
                    <BitsUnit scale="0.0054931640625">deg</BitsUnit>
                </Bits>
            </Fixed>
        </DataItemFormat>            
    </DataItem>
 
 

C++ (Qt)
record.item( "040" ).field( "RHO" );
 

C++ (Qt)
 
struct Record
{
    Bytes m_bytes;
 
    // BitField< Byte number,  First bit, Last bit >
    BitField<0, 0, 1> flag;
    BitField<0, 1, 5> mode;
    BitField<0, 5, 14> address;
 
    Record () : flag( m_bytes ), mode( m_bytes ), address( m_bytes ) {}
};
 

C++ (Qt)
void A::Read( Stream & strem )
{
  int version = stream.ReadInt();
 
  m_A = stream.ReadInt();
  m_B = stream.ReadInt();
 
  if (version > 1) {
   ...
 

C++ (Qt)
 
struct Record
{
    Bytes m_bytes;
 
    // BitField< Byte number,  First bit, Last bit >
    BitField<0, 0, 1> flag;
    BitField<0, 1, 5> mode;
    BitField<0, 5, 14> address;
 
    Record () : flag( m_bytes ), mode( m_bytes ), address( m_bytes ) {}
};
 

for field in mystruct.orderedFields
  stream.write(field.size, field.value);

C++ (Qt)
class bit_field_base;
 
class bit_record
{
public:
  void reg_field( bit_field_base *field ) { assert( field ); m_orderedFields.push_back( field ); }
 
private:
  std::list<bit_field_base*>  m_orderedFields;
};
 
class bit_field_base
{
public:
  bit_field_base( bit_record &record ) { record.reg_field( this ); }
}
 
 
// =================================================
 
class DataRecord : public bit_record
{
public:
  DataRecord() : m_fld1( *this ), m_fld2( *this ), m_fld3( *this ) {}
 
private:
  bit_field<1> m_fld1;
  bit_field<2> m_fld2;
  bit_field<3> m_fld3;
};
 

C++ (Qt)
using BitFieldSizeType = uint8_t;
 
template<typename T>
T parseNumber(gsl::span<uint8_t> const& sp, uint64_t& offset, BitFieldSizeType size)
{
  /*
  auto value = bitpacker::extract<T>(sp, offset, size);
  offset += size;
  return value;
  */
  return readBits(size, sp.data(), &offset); // own impl
}
 
template<BitFieldSizeType Bits>
struct BitField
{
  static constexpr auto size = Bits;
 
  std::conditional_t<size == 1, bool,
    std::conditional_t<size <= 8, uint8_t,
      std::conditional_t<size <= 16, uint16_t,
        std::conditional_t<size <= 32, uint32_t, uint64_t>
      >
    >
  > v;
 
  BitField()
  {
    static_assert(size <= 64);
  }
 
  auto parse(gsl::span<uint8_t> const& sp, uint64_t& offset)
  {
    v = parseNumber<decltype(v)>(sp, offset, size);
    return v;
  }
 
   operator auto() const { return v; }
};
 
template<std::size_t Size, BitFieldSizeType Bits>
struct BitArray
{
  std::array<BitField<Bits>, Size> arr;
 
  auto parse(gsl::span<uint8_t> const& sp, uint64_t& offset)
  {
    for (auto& el : arr)
      el.parse(sp, offset);
    return arr;
  }
};
 
// helper types
using BitFieldBool1 = BitField<1>;
 
template<std::size_t Size, BitFieldSizeType Bits = 8>
using BitString = BitArray<Size, Bits>;

C++ (Qt)
// helper types
struct NarrowString
{
  std::string string;
  uint8_t maxCharacters;
 
  NarrowString(uint8_t maxCharacters_) : maxCharacters{maxCharacters_}
  {
    assert(maxCharacters > 0);
    string.reserve(maxCharacters - 1);
  }
 
  auto parse(gsl::span<uint8_t> const& sp, uint64_t& offset)
  {
    for (decltype(maxCharacters) j = 0; j < maxCharacters; ++j)
    {
      auto c = BitField<7>{}.parse(sp, offset);
      if (c == 0)
        break;
      string += c;
    }
    return string;
  }
 
  operator auto() const { return string; }
};
 
template<BitFieldSizeType N>
struct ConditionalBitField
{
  BitField<N> _value;
  std::optional<bool> condition;
 
  ConditionalBitField(decltype(condition) condition_ = std::nullopt) : condition{condition_} {}
 
  std::optional<decltype(_value.v)> parse(gsl::span<uint8_t> const& sp, uint64_t& offset)
  {
    bool shouldReadField = condition ? *condition : BitFieldBool1{}.parse(sp, offset);
    if (!shouldReadField)
      return std::nullopt;
    return _value.parse(sp, offset);
  }
};
 
 
// bit structs
struct BasicBitItem
{
  BitField<16> header;
  BitFieldBool1 isQuest;
  BitField<3> _1;
  BitFieldBool1 isIdentified;
  BitField<5+1> _2;
  BitFieldBool1 isSocketed;
  BitField<2+1+1> _3;
  BitFieldBool1 isEar;
  BitFieldBool1 isStarter;
  BitField<2+1> _4;
  BitFieldBool1 isSimple;
  BitFieldBool1 isEthereal;
  BitFieldBool1 _5;
  BitFieldBool1 isPersonalized;
  BitFieldBool1 _6;
  BitFieldBool1 isRW;
  BitField<5+8+2> _7;
  BitField<3> location;
  BitField<4> whereEquipped;
  BitField<4> column;
  BitField<4> row;
  BitField<3> storage;
};
 
struct ExtendedBitItem
{
  BitField<3> socketablesNumber;
  BitField<32> guid;
  BitField<7> ilvl;
  BitField<4> quality;
  ConditionalBitField<3> variableGraphics;
  ConditionalBitField<11> autoprefix;
};
 
 
template <typename F>
void parseField(F& field, gsl::span<uint8_t> const& sp, uint64_t& i)
{
  field.parse(sp, i);
}
 
template <typename T>
T parse(gsl::span<uint8_t> const& sp, uint64_t& i)
{
  T t;
  boost::pfr::for_each_field(t, [&sp, &i](auto& f) {
    parseField(f, sp, i);
  });
  return t;
}
 
 
int main()
{
  // read file...
  gsl::span sp{buf, fileSize};
  uint64_t offset = 0;
  auto base = parse<BasicBitItem>(sp, offset);
  if (base.isSimple)
    return 0;
 
  auto extended = parse<ExtendedBitItem>(sp, offset);
 
  auto someField = ConditionalBitField<16>{base.isRW}.parse(sp, offset);
  if (base.isPersonalized)
    auto inscribedName = NarrowString{16}.parse(sp, offset);
  // further conditions...
 
  return 0;
}

C++ (Qt)
void A::ReadWrite( CBitStream & stream, TMode mode ) 
{
  stream.ReadWriteInt(&m_B, 4, mode);    
  ...
}

C++ (Qt)
usiing TBitKey = std::pair<const std::type_info *, size_t>;
 
template<class Owner, class Member>
int GetBitCount( const Owner & owner, const Member & member )
{
// offsetof ?
  char * base = (char *) &owner;
  char * addr = (char *) &member;
  assert(addr >= base);
  assert(adrr <= base + sizeof(base);
 
  auto it = theGlobalBitsMap.find(TBitKey(&std::typeid(Owner), addr - base));
  assert(it != theGlobalBitsMap.end());
  return it->second; 
}
 
// usage
void A::ReadWrite( CBitStream & stream, TMode mode ) 
{
  stream.ReadWriteBits(&m_B, GetBitCount(*this, m_B), mode);    
  ...
}

C++ (Qt)
A a;
auto t = std::type_index(std::typeid(A));
theGlobalBitsMap[{t, &a.m_B - &a}] = 6;

C++ (Qt)
stream.ReadWriteBits(&m_B, GetBitCount(*this, m_B), mode);

C++ (Qt)
template<class Owner, class Member>
void SetBitsCount( const Owner & owner, const Member & member, int bitsCount );

C++ (Qt)
const std::type_info& ti1 = typeid(A);
const std::type_info& ti2 = typeid(A);
 
assert(&ti1 == &ti2); // not guaranteed
assert(ti1.hash_code() == ti2.hash_code()); // guaranteed
assert(std::type_index(ti1) == std::type_index(ti2)); // guaranteed

C++ (Qt)
  boost::pfr::for_each_field(some_struct, [](auto const& f) {
    // делаем с полем f что хотим
    std::cout << f.size;
  });

C++ (Qt)
std::cout << boost::pfr::io(some_struct);

C++ (Qt)
  boost::pfr::for_each_field(some_struct, [](auto const& f) {
    // делаем с полем f что хотим
    std::cout << f.size;
  });

C++ (Qt)
union CFlag {
  uint32 m_value;
  struct {
    uint32 m_A : 1;
    uint32 m_B : 2;
    ...
  }; 
};

C++ (Qt)
bool СompareTypeInfo( const std::type_info * t0, const std::type_info * t1 )
{
  return t0->before(*t1);
}

C++ (Qt)
template<class CFlag>
int CalcFlagBits( void )
{
  static_assert(sizeof(CFlag) == sizeof(unit32));
  CFlag flag;
  flag.m_value = (uint32) -1;
  flag.m_padding = 0;
  return ffs(flag.m_value);   // по-моему эта ф-ция считает число единичек, могу путать
}

C++ (Qt)
template<std::size_t Size, BitFieldSizeType Bits>
struct BitArray
{
  std::array<BitField<Bits>, Size> arr;
 
  auto parse(gsl::span<uint8_t> const& sp, uint64_t& offset)
  {
    for (auto& el : arr)
      el.parse(sp, offset);
    return arr;
  }
};