PayLoadCont.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file PayLoadCont.h

// @file PayLoadCont.h
// @brief Declaration of class for continuos buffer of ALPIDE data
// @author ruben.shahoyan@cern.ch
// @sa <O2/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/PayLoadCont.h>
//     <03608ff89>

#ifndef MVTXDECODER_PAYLOADCONT_H
#define MVTXDECODER_PAYLOADCONT_H

#include <cstring>
#include <vector>
#include <functional>
#include <cstdint>

namespace mvtx
{

class PayLoadCont
{

  public:
  static constexpr size_t MinCapacity = 16;

  PayLoadCont() = default;
  PayLoadCont(size_t sz) { expand(sz); }
  ~PayLoadCont() = default;

  PayLoadCont(const PayLoadCont& src);

  PayLoadCont& operator=(const PayLoadCont& src);

  const uint8_t* data() const { return mBuffer.data(); }

  void expand(size_t sz);

  bool isEmpty() const { return mPtr >= mEnd; }

  void clear()
  {
    mPtr = mBuffer.data();
    mEnd = mPtr;
  }

  size_t getUnusedSize() const { return mEnd > mPtr ? mEnd - mPtr : 0; }

  size_t getSize() const { return mEnd - mBuffer.data(); }

  size_t getOffset() const { return mPtr - mBuffer.data(); }

  size_t getCapacity() const { return mBuffer.size(); }

  size_t getFreeCapacity() const { return mBuffer.size() - getSize(); }

  void ensureFreeCapacity(size_t n)
  {
    if (getFreeCapacity() < n) {
      expand(getCapacity() + 2 * n);
    }
  }

  void fillFast(const uint8_t c, size_t n)
  {
    std::memset(mEnd, c, n);
    mEnd += n;
  }

  void addFast(const uint8_t* ptr, size_t n)
  {
    std::memcpy(mEnd, ptr, n);
    mEnd += n;
  }

  void addFast(uint8_t val) { *mEnd++ = val; }

  void addFast(uint16_t val)
  {
    *mEnd++ = val >> 8;
    *mEnd++ = 0xff & val;
  }

  void eraseFast(size_t n) { mEnd -= n; }

  void erase(size_t n)
  {
    if (n > getSize()) {
      clear();
    } else {
      eraseFast(n);
    }
  }

  void fill(const uint8_t c, size_t n)
  {
    ensureFreeCapacity(n);
    fillFast(c, n);
  }

  void add(const uint8_t* ptr, size_t n)
  {
    ensureFreeCapacity(n);
    addFast(ptr, n);
  }

  void add(uint8_t val)
  {
    ensureFreeCapacity(sizeof(val));
    addFast(val);
  }

  void add(uint16_t val)
  {
    ensureFreeCapacity(sizeof(val));
    addFast(val);
  }

  void shrinkToSize(size_t sz)
  {
    mEnd = mPtr + sz;
  }

  uint8_t operator[](size_t i) const { return mBuffer[i]; }

  uint8_t& operator[](size_t i) { return mBuffer[i]; }

  bool current(uint8_t& v) const
  {
    if (mPtr < mEnd) {
      v = *mPtr;
      return true;
    }
    return false;
  }

  bool next(uint8_t& v)
  {
    if (mPtr < mEnd) {
      v = *mPtr++;
      return true;
    }
    return false;
  }

  bool next(uint16_t& v)
  {
    if (mPtr < mEnd - (sizeof(uint16_t) - 1)) {
      v = (*mPtr++) << 8;
      v |= (*mPtr++);
      return true;
    }
    return false;
  }

  void rewind() { mPtr = mBuffer.data(); }

  void moveUnusedToHead()
  {
    auto left = getUnusedSize();
    if (left < getOffset()) {
      std::memcpy(mBuffer.data(), mPtr, left); // there is no overlap
    } else {
      std::memmove(mBuffer.data(), mPtr, left); // there is an overlap
    }
    mPtr = mBuffer.data();
    mEnd = mPtr + left;
  }

  // (attemtint to use all free capacity) using the method provided via getNext
  size_t append(std::function<size_t(uint8_t*, size_t)> getNext)
  {
    moveUnusedToHead();
    auto nRead = getNext(mEnd, getFreeCapacity());
    mEnd += nRead;
    return nRead;
  }

  uint8_t* getPtr() { return mPtr; }
  void setPtr(uint8_t* ptr) { mPtr = ptr; }
  void movePtr(size_t step) { mPtr += step; }

  uint8_t* getEnd() { return mEnd; }
  void setEnd(uint8_t* ptr) { mEnd = ptr; }

 private:
  std::vector<uint8_t> mBuffer; 
  uint8_t* mPtr = nullptr;      
  uint8_t* mEnd = nullptr;      

//  ClassDefNV(PayLoadCont, 1);
};

} // namespace mvtx

#endif