sPhenix code displayed by LXR master/​online_distribution/​newbasic/​mvtx_decoder/​PayLoadCont.h	Source navigation Diff markup Identifier search General search
	Version: master Revert   Change

File indexing completed on 2025-08-05 08:20:06

 // @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 <cstdint>
 #include <cstring>
 #include <functional>
 #include <vector>
 
 namespace mvtx
 {
 
   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;
 
     ///< allocate buffer
     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(); }
 
     ///< increase the buffer size
     void expand(size_t sz);
 
     bool isEmpty() const { return mPtr >= mEnd; }
 
     ///< make buffer empty w/o deallocating it
     void clear(uint32_t maxCapacity = 0)
     {
       mPtr = mBuffer.data();
       mEnd = mPtr;
       if (maxCapacity && mBuffer.capacity() > (5 * maxCapacity))
       {
         std::vector<uint8_t>().swap(mBuffer);
         expand(maxCapacity);
       }
     }
 
     ///< get unused size
     size_t getUnusedSize() const { return mEnd > mPtr ? mEnd - mPtr : 0; }
 
     ///< get filled size
     size_t getSize() const { return mEnd - mBuffer.data(); }
 
     ///< get offset of the current ptr from the head
     size_t getOffset() const { return mPtr - mBuffer.data(); }
 
     ///< booked capacity
     size_t getCapacity() const { return mBuffer.size(); }
 
     ///< number of bytes still can accept w/o expanding the buffer
     size_t getFreeCapacity() const { return mBuffer.size() - getSize(); }
 
     ///< make sure buffer may accept at least n bytes
     void ensureFreeCapacity(size_t n)
     {
       if (getFreeCapacity() < n)
       {
         expand(getCapacity() + 2 * n);
       }
     }
 
     ///< fill n bytes with given symbol w/o checking for the size
     void fillFast(const uint8_t c, size_t n)
     {
       std::memset(mEnd, c, n);
       mEnd += n;
     }
 
     ///< add n bytes to the buffer w/o checking for the size
     void addFast(const uint8_t *ptr, size_t n)
     {
       std::memcpy(mEnd, ptr, n);
       mEnd += n;
     }
 
     ///< add new byte to the buffer w/o checking for the size
     void addFast(uint8_t val) { *mEnd++ = val; }
 
     ///< add new short to the buffer w/o checking for the size
     void addFast(uint16_t val)
     {
       *mEnd++ = val >> 8;
       *mEnd++ = 0xff & val;
     }
 
     ///< erase n bytes w/o checking for the underflow
     void eraseFast(size_t n) { mEnd -= n; }
 
     ///< erase n bytes
     void erase(size_t n)
     {
       if (n > getSize())
       {
         clear();
       }
       else
       {
         eraseFast(n);
       }
     }
 
     ///< fill n bytes with given symbol
     void fill(const uint8_t c, size_t n)
     {
       ensureFreeCapacity(n);
       fillFast(c, n);
     }
 
     ///< add n bytes to the buffer, expand if needed. no check for overlap
     void add(const uint8_t *ptr, size_t n)
     {
       ensureFreeCapacity(n);
       addFast(ptr, n);
     }
 
     ///< add new byte to the buffer
     void add(uint8_t val)
     {
       ensureFreeCapacity(sizeof(val));
       addFast(val);
     }
 
     ///< add new short to the buffer
     void add(uint16_t val)
     {
       ensureFreeCapacity(sizeof(val));
       addFast(val);
     }
 
     ///< shrink buffer to requested size, no check on over/under flow
     void shrinkToSize(size_t sz) { mEnd = mPtr + sz; }
 
     ///< direct const access to value at a given slot, w/o checking for overflow
     uint8_t operator[](size_t i) const { return mBuffer[i]; }
 
     ///< direct access to value at a given slot, w/o checking for overflow
     uint8_t &operator[](size_t i) { return mBuffer[i]; }
 
     ///< read current character value from buffer w/o stepping forward
     bool current(uint8_t &v) const
     {
       if (mPtr < mEnd)
       {
         v = *mPtr;
         return true;
       }
       return false;
     }
 
     ///< read character value from buffer
     bool next(uint8_t &v)
     {
       if (mPtr < mEnd)
       {
         v = *mPtr++;
         return true;
       }
       return false;
     }
 
     ///< read short value from buffer
     bool next(uint16_t &v)
     {
       if (mPtr < mEnd - (sizeof(uint16_t) - 1))
       {
         v = (*mPtr++) << 8;
         v |= (*mPtr++);
         return true;
       }
       return false;
     }
 
     ///< move current pointer to the head
     void rewind() { mPtr = mBuffer.data(); }
 
     ///< move all data between the mPtr and mEnd to the head of the buffer
     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;
     }
 
     ///< move unused data to the head and upload new chunk of data
     // (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;
     }
 
     /// direct write access
     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;  //! continuons data buffer
     uint8_t *mPtr = nullptr;       ///! pointer on the position in the buffer
     uint8_t *mEnd = nullptr;       ///! pointer on the last+1 valid entry in the buffer
 
     //  ClassDefNV(PayLoadCont, 1);
   };
 
 }  // namespace mvtx
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team