Buffer.cpp

Go to the documentation of this file.

 
#include "rogue/interfaces/stream/Buffer.h"
 
#include <inttypes.h>
 
#include <cstdio>
#include <memory>
 
#include "rogue/GeneralError.h"
#include "rogue/interfaces/stream/Frame.h"
#include "rogue/interfaces/stream/Pool.h"
 
namespace ris = rogue::interfaces::stream;
 
/*
 * Pass owner, raw data buffer, and meta data
 */
ris::BufferPtr ris::Buffer::create(ris::PoolPtr source, void* data, uint32_t meta, uint32_t size, uint32_t alloc) {
    ris::BufferPtr buff = std::make_shared<ris::Buffer>(source, data, meta, size, alloc);
    return (buff);
}
 
/*
 * Pass owner, raw data buffer, and meta data
 */
ris::Buffer::Buffer(ris::PoolPtr source, void* data, uint32_t meta, uint32_t size, uint32_t alloc) {
    source_    = source;
    data_      = reinterpret_cast<uint8_t*>(data);
    meta_      = meta;
    rawSize_   = size;
    allocSize_ = alloc;
    headRoom_  = 0;
    tailRoom_  = 0;
    payload_   = 0;
}
 
/*
 * Owner return buffer method is called
 */
ris::Buffer::~Buffer() {
    source_->retBuffer(data_, meta_, allocSize_);
}
 
void ris::Buffer::setFrame(ris::FramePtr frame) {
    frame_ = frame;
}
 
uint32_t ris::Buffer::getMeta() {
    return (meta_);
}
 
void ris::Buffer::setMeta(uint32_t meta) {
    meta_ = meta;
}
 
void ris::Buffer::adjustHeader(int32_t value) {
    // Decreasing header size
    if (value < 0 && static_cast<uint32_t>(abs(value)) > headRoom_)
        throw(rogue::GeneralError::create("Buffer::adjustHeader",
                                          "Attempt to reduce header with size %" PRIu32 " by %" PRIi32,
                                          headRoom_,
                                          value));
 
    // Increasing header size
    if (value > 0 && static_cast<uint32_t>(value) > (rawSize_ - (headRoom_ + tailRoom_)))
        throw(rogue::GeneralError::create("Buffer::adjustHeader",
                                          "Attempt to increase header by %" PRIi32 " in buffer with size %" PRIu32,
                                          value,
                                          (rawSize_ - (headRoom_ + tailRoom_))));
 
    // Make adjustment
    headRoom_ += value;
 
    // Payload can never be less than headroom
    if (payload_ < headRoom_) payload_ = headRoom_;
 
    ris::FramePtr tmpPtr;
    if ((tmpPtr = frame_.lock())) tmpPtr->setSizeDirty();
}
 
void ris::Buffer::zeroHeader() {
    headRoom_ = 0;
 
    ris::FramePtr tmpPtr;
    if ((tmpPtr = frame_.lock())) tmpPtr->setSizeDirty();
}
 
void ris::Buffer::adjustTail(int32_t value) {
    // Decreasing tail size
    if (value < 0 && static_cast<uint32_t>(abs(value)) > tailRoom_)
        throw(rogue::GeneralError::create("Buffer::adjustTail",
                                          "Attempt to reduce tail with size %" PRIu32 " by %" PRIi32,
                                          tailRoom_,
                                          value));
 
    // Increasing tail size
    if (value > 0 && static_cast<uint32_t>(value) > (rawSize_ - (headRoom_ + tailRoom_)))
        throw(rogue::GeneralError::create("Buffer::adjustTail",
                                          "Attempt to increase header by %" PRIi32 " in buffer with size %" PRIu32,
                                          value,
                                          (rawSize_ - (headRoom_ + tailRoom_))));
 
    // Make adjustment
    tailRoom_ += value;
 
    ris::FramePtr tmpPtr;
    if ((tmpPtr = frame_.lock())) tmpPtr->setSizeDirty();
}
 
void ris::Buffer::zeroTail() {
    tailRoom_ = 0;
 
    ris::FramePtr tmpPtr;
    if ((tmpPtr = frame_.lock())) tmpPtr->setSizeDirty();
}
 
/*
 * Get data pointer (begin iterator)
 * Returns base + header size
 */
uint8_t* ris::Buffer::begin() {
    return (data_ + headRoom_);
}
 
/*
 * Get end data pointer (end iterator)
 * This is the end of raw data buffer
 */
uint8_t* ris::Buffer::end() {
    return (data_ + (rawSize_ - tailRoom_));
}
 
/*
 * Get end payload pointer (end iterator)
 * This is the end of payload data
 */
uint8_t* ris::Buffer::endPayload() {
    return (data_ + payload_);
}
 
/*
 * Get size of buffer that can hold
 * payload data. This function
 * returns the full buffer size minus
 * the head and tail reservation.
 */
uint32_t ris::Buffer::getSize() {
    return (rawSize_ - (headRoom_ + tailRoom_));
}
 
/*
 * Get available size for payload
 * This is the space remaining for payload
 * minus the space reserved for the tail
 */
uint32_t ris::Buffer::getAvailable() {
    uint32_t ret;
 
    ret = rawSize_ - payload_;
 
    // Subtract tail space, avoid overflow
    if (ret < tailRoom_)
        ret = 0;
    else
        ret -= tailRoom_;
 
    return (ret);
}
 
/*
 * Get real payload size without header
 * This is the count of real data in the
 * packet, minus the portion reserved for
 * the head.
 */
uint32_t ris::Buffer::getPayload() {
    return (payload_ - headRoom_);
}
 
void ris::Buffer::setPayload(uint32_t size) {
    if (size > (rawSize_ - (headRoom_ + tailRoom_)))
        throw(rogue::GeneralError::create("Buffer::setPayload",
                                          "Attempt to set payload to size %" PRIu32 " in buffer with size %" PRIu32,
                                          size,
                                          (rawSize_ - (headRoom_ + tailRoom_))));
 
    payload_ = size + headRoom_;
 
    ris::FramePtr tmpPtr;
    if ((tmpPtr = frame_.lock())) tmpPtr->setSizeDirty();
}
 
/*
 * Set min payload size (not including header)
 * Payload size is updated only if size > current size
 */
void ris::Buffer::minPayload(uint32_t size) {
    if (size > getPayload()) setPayload(size);
}
 
void ris::Buffer::adjustPayload(int32_t value) {
    if (value < 0 && static_cast<uint32_t>(abs(value)) > getPayload())
        throw(rogue::GeneralError::create("Buffer::adjustPayload",
                                          "Attempt to decrease payload by %" PRIi32 " in buffer with size %" PRIu32,
                                          value,
                                          getPayload()));
 
    setPayload(getPayload() + value);
}
 
void ris::Buffer::setPayloadFull() {
    payload_ = rawSize_ - tailRoom_;
 
    ris::FramePtr tmpPtr;
    if ((tmpPtr = frame_.lock())) tmpPtr->setSizeDirty();
}
 
void ris::Buffer::setPayloadEmpty() {
    payload_ = headRoom_;
 
    ris::FramePtr tmpPtr;
    if ((tmpPtr = frame_.lock())) tmpPtr->setSizeDirty();
}
 
void ris::Buffer::debug(uint32_t idx) {
    printf("    Buffer: %" PRIu32 ", AllocSize: %" PRIu32 ", RawSize: %" PRIu32 ", HeadRoom: %" PRIu32
           ", TailRoom: %" PRIu32 ", Payload: %" PRIu32 "\n",
           idx,
           allocSize_,
           rawSize_,
           headRoom_,
           tailRoom_,
           payload_);
}