PayLoadCont.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 ALICEO2_ITSMFT_PAYLOADCONT_H
#define ALICEO2_ITSMFT_PAYLOADCONT_H
 
#include <cstring>
#include <vector>
#include <functional>
#include <Rtypes.h>
 
 
namespace o2
{
namespace itsmft
{
 
class PayLoadCont
{
  // continous buffer for the payload, just a preallocated vector with current position and end pointer.
  // Big endian is used.
 
 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; }
 
  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 itsmft
} // namespace o2
 
#endif