BitstreamReader.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#ifndef BITSTREAMREADER_H
#define BITSTREAMREADER_H
 
 
#include <type_traits>
#include <bitset>
 
namespace o2
{
namespace algorithm
{
 
template <typename BufferType>
class BitstreamReader
{
 public:
  using self_type = BitstreamReader<BufferType>;
  // for the moment we simply use pointers, but with some traits this can be extended to
  // containers
  using value_type = BufferType;
  using iterator = const value_type*;
  static constexpr size_t value_size = sizeof(value_type) * 8;
  BitstreamReader() = delete;
  BitstreamReader(iterator start, iterator end)
    : mStart(start), mEnd(end), mCurrent(mStart), mBitPosition(value_size)
  {
  }
  ~BitstreamReader() = default;
 
  bool good() const
  {
    return mBitPosition > 0;
  }
 
  bool eof() const
  {
    return mCurrent == mEnd && mBitPosition > 0;
  }
 
  void reset()
  {
    mCurrent = mStart;
    mBitPosition = value_size;
  }
 
  template <typename T, size_t N = sizeof(T) * 8>
  size_t peek(T& v)
  {
    static_assert(N <= sizeof(T) * 8);
    return peek<T, false>(v, N);
  }
 
  template <typename T>
  size_t peek(T& v, size_t bitlength)
  {
    return peek<T, true>(v, bitlength);
  }
 
  void seek(size_t bitlength)
  {
    while (good() && bitlength > 0 && mCurrent != mEnd) {
      if (bitlength >= mBitPosition) {
        bitlength -= mBitPosition;
        mBitPosition = 0;
      } else {
        mBitPosition -= bitlength;
        bitlength = 0;
      }
      if (mBitPosition == 0) {
        mCurrent++;
        mBitPosition = value_size;
      }
    }
 
    if (bitlength > 0) {
      mBitPosition = 0;
    }
  }
 
  template <typename T, size_t N = sizeof(T) * 8>
  T get()
  {
    T result;
    peek<T, N>(result);
    seek(N);
    return result;
  }
 
  template <typename T>
  T get(size_t bitlength = sizeof(T) * 8)
  {
    T result;
    peek<T>(result, bitlength);
    seek(bitlength);
    return result;
  }
 
  template <typename FieldType, size_t N = sizeof(FieldType) * 8, typename ParentType = self_type>
  class Bits
  {
   public:
    using field_type = FieldType;
    static_assert(N <= sizeof(FieldType) * 8);
    Bits()
      : mParent(nullptr), mData(0), mLength(0)
    {
    }
    Bits(ParentType* parent, FieldType&& data)
      : mParent(parent), mData(std::move(data)), mLength(N)
    {
    }
    Bits(Bits&& other)
      : mParent(other.mParent), mData(std::move(other.mData)), mLength(other.mLength)
    {
      other.mParent = nullptr;
      other.mLength = 0;
    }
 
    ~Bits()
    {
      if (mParent) {
        mParent->seek(mLength);
      }
    }
 
    auto& operator=(Bits<FieldType, N, ParentType>&& other)
    {
      mParent = other.mParent;
      mData = std::move(other.mData);
      mLength = other.mLength;
      other.mParent = nullptr;
      other.mLength = 0;
 
      return *this;
    }
 
    FieldType& operator*()
    {
      return mData;
    }
 
    void markUsed(size_t length)
    {
      mLength = length;
    }
 
   private:
    ParentType* mParent;
    FieldType mData;
    size_t mLength;
  };
 
  template <typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
  self_type& operator>>(T& target)
  {
    target = get<T>();
    return *this;
  }
 
  template <size_t N>
  self_type& operator>>(std::bitset<N>& target)
  {
    target = get<std::bitset<N>, N>();
    return *this;
  }
 
  template <typename T>
  self_type& operator>>(Bits<T>& target)
  {
    T bitfield;
    peek<T>(bitfield);
    target = std::move(Bits<T>(this, std::move(bitfield)));
    return *this;
  }
 
 private:
  template <typename T, bool RuntimeCheck>
  size_t peek(T& result, size_t bitlength)
  {
    if constexpr (RuntimeCheck) {
      // the runtime check is disabled if bitlength is derived at compile time
      if (bitlength > sizeof(T) * 8) {
        throw std::length_error(std::string("requested bit length ") + std::to_string(bitlength) + " does not fit size of result data type " + std::to_string(sizeof(T) * 8));
      }
    }
    result = 0;
    size_t bitsToWrite = bitlength;
    auto current = mCurrent;
    auto bitsAvailable = mBitPosition;
    while (bitsToWrite > 0 && current != mEnd) {
      // extract available bits
      value_type mask = ~value_type(0) >> (value_size - bitsAvailable);
      if (bitsToWrite >= bitsAvailable) {
        T value = (*current & mask) << (bitsToWrite - bitsAvailable);
        result |= value;
        bitsToWrite -= bitsAvailable;
        bitsAvailable = 0;
      } else {
        value_type value = (*current & mask) >> (bitsAvailable - bitsToWrite);
        result |= value;
        bitsAvailable -= bitsToWrite;
        bitsToWrite = 0;
      }
      if (bitsAvailable == 0) {
        current++;
        bitsAvailable = value_size;
      }
    }
 
    return bitlength - bitsToWrite;
  }
 
  iterator mStart;
  iterator mEnd;
  iterator mCurrent;
  size_t mBitPosition;
};
} // namespace algorithm
} // namespace o2
#endif