ByteBuffer.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_BYTEBUFFER_HXX_
#define _UTILS_BYTEBUFFER_HXX_
 
#include "utils/Buffer.hxx"
 
static constexpr unsigned RAWBUFFER_SIZE = 1024;
 
extern Pool *rawBufferPool;
 
struct RawData
{
    uint8_t payload[RAWBUFFER_SIZE];
    static constexpr size_t MAX_SIZE = RAWBUFFER_SIZE;
};
 
using RawBuffer = Buffer<RawData>;
 
using RawBufferPtr = BufferPtr<RawData>;
 
struct ByteChunk
{
    RawBufferPtr ownedData_;
 
    uint8_t *data_ {nullptr};
 
    size_t size_ {0};
 
    size_t size() const
    {
        return size_;
    }
 
    void advance(size_t num_bytes)
    {
        HASSERT(num_bytes <= size_);
        data_ += num_bytes;
        size_ -= num_bytes;
    }
 
    void set_from(RawBufferPtr buf, size_t len, size_t ofs = 0)
    {
        ownedData_ = std::move(buf);
        size_ = len;
        data_ = ownedData_->data()->payload + ofs;
    }
 
    void set_from(const string *data)
    {
        ownedData_.reset(); // no need for this anymore
        size_ = data->size();
        data_ = (uint8_t *)data->data();
    }
 
    void set_from(const void *data, size_t len)
    {
        ownedData_.reset(); // no need for this anymore
        data_ = (uint8_t *)data;
        size_ = len;
    }
 
    size_t append(const void *data, size_t len)
    {
        HASSERT(ownedData_.get());
        uint8_t *end = data_ + size_;
        uint8_t *max_end = ownedData_->data()->payload + RawData::MAX_SIZE;
        size_t max_len = max_end - end;
        if (max_len < len)
        {
            len = max_len;
        }
        memcpy(end, data, len);
        size_ += len;
        return len;
    }
 
    uint8_t *append_ptr()
    {
        HASSERT(ownedData_.get());
        uint8_t *end = data_ + size_;
        return end;
    }
 
    void append_complete(size_t len)
    {
        size_ += len;
    }
 
    size_t free_space()
    {
        if (!ownedData_)
        {
            return 0;
        }
        uint8_t *end = data_ + size_;
        uint8_t *max_end = ownedData_->data()->payload + RawData::MAX_SIZE;
        size_t max_len = max_end - end;
        return max_len;
    }
};
 
using ByteBuffer = Buffer<ByteChunk>;
using ByteBufferPtr = BufferPtr<ByteChunk>;
 
template <class T> class FlowInterface;
 
using ByteSink = FlowInterface<ByteBuffer>;
 
#endif // _UTILS_BYTEBUFFER_HXX_