buffer.cpp

Go to the documentation of this file.

 
#include <common/buffer.h>
 
using namespace MaxOS;
using namespace MaxOS::common;
 
Buffer::Buffer(size_t size, bool update_offset)
        : m_capacity(size),
          update_offset(update_offset) {
 
    // Create the buffer
    m_bytes = new uint8_t[size];
 
}
 
Buffer::Buffer(void* source, size_t size, bool update_offset)
        : update_offset(update_offset) {
 
    m_bytes = (uint8_t*) source;
    m_capacity = size;
    m_dont_delete = true;
 
}
 
Buffer::~Buffer() {
    if (!m_dont_delete && m_bytes)
        delete[] m_bytes;
}
 
uint8_t* Buffer::raw() const {
 
    return m_bytes;
}
 
void Buffer::clear() {
 
    m_offset = 0;
    memset(m_bytes, 0, m_capacity);
}
 
void Buffer::full(uint8_t byte, size_t offset, size_t amount) {
 
    // Prevent writing past the buffer bounds
    size_t start = m_offset + offset;
    ASSERT(start <= m_capacity, "Offset past buffer end");
 
    if (amount == 0) amount = m_capacity - start;
    ASSERT(start + amount <= m_capacity, "Buffer overflow");
 
    memset(m_bytes + start, byte, amount);
 
}
 
size_t Buffer::capacity() const {
    return m_capacity;
}
 
void Buffer::resize(size_t size) {
 
    // Create the new buffer
    auto* new_buffer = new uint8_t[size];
 
    // Copy the old buffer
    if (m_bytes)
        memcpy(new_buffer, m_bytes, m_capacity);
 
    // Store the new buffer
    if (!m_dont_delete && m_bytes)
        delete[] m_bytes;
 
    m_bytes = new_buffer;
    m_capacity = size;
    m_dont_delete = true;
 
}
 
void Buffer::set_offset(size_t offset) {
 
    if (update_offset)
        m_offset = offset;
 
}
 
void Buffer::write(uint8_t byte) {
    m_bytes[m_offset] = byte;
    set_offset(m_offset + 1);
}
 
 
void Buffer::write(size_t offset, uint8_t byte) {
 
    // Prevent writing past the buffer bounds
    ASSERT(m_offset + offset < capacity(), "Buffer overflow");
 
    // Set the byte
    m_bytes[m_offset + offset] = byte;
    set_offset(m_offset + 1);
 
}
 
uint8_t Buffer::read() {
    set_offset(m_offset + 1);
    return m_bytes[m_offset - 1];
}
 
uint8_t Buffer::read(size_t offset) {
 
    // Prevent writing past the buffer bounds
    ASSERT(m_offset + offset < capacity(), "Buffer overflow");
 
    // Set the byte
    set_offset(m_offset + 1);
    return m_bytes[(m_offset - 1) + offset];
}
 
void Buffer::copy_from(const Buffer* buffer) {
 
    // Copy the buffer
    ASSERT(buffer->capacity() <= capacity(), "Copy exceeds buffer capacity");
    copy_from(buffer->raw(), buffer->capacity());
 
}
 
void Buffer::copy_from(const Buffer* buffer, size_t length) {
 
    // Copy the buffer
    ASSERT(length <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_from(buffer->raw(), length);
 
}
 
void Buffer::copy_from(const Buffer* buffer, size_t length, size_t offset) {
 
    // Copy the buffer
    ASSERT(length <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_from(buffer->raw(), length, offset);
 
}
 
void Buffer::copy_from(const Buffer* buffer, size_t length, size_t offset, size_t offset_other) {
 
    // Copy the buffer
    ASSERT(length + offset_other <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_from(buffer->raw() + offset_other, length, offset);
 
}
 
void Buffer::copy_from(void const* source, size_t length) {
 
    // Copy the bytes
    ASSERT(length + m_offset <= m_capacity, "Copy exceeds buffer capacity");
    memcpy(m_bytes + m_offset, source, length);
    set_offset(m_offset + length);
}
 
void Buffer::copy_from(void const* source, size_t length, size_t offset) {
 
    // Copy the bytes
    ASSERT((length + offset + m_offset) <= m_capacity, "Copy exceeds buffer capacity");
    memcpy(m_bytes + offset + m_offset, source, length);
    set_offset(m_offset + length);
 
}
 
void Buffer::copy_to(Buffer* buffer) {
 
    // Copy the buffer
    ASSERT(capacity() <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_to(buffer->raw(), capacity());
 
}
 
void Buffer::copy_to(Buffer* buffer, size_t length) {
 
    // Copy the buffer
    ASSERT(length <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_to(buffer->raw(), length);
 
}
 
void Buffer::copy_to(Buffer* buffer, size_t length, size_t offset) {
 
    // Copy the bytes
    ASSERT((length + offset) <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_to(buffer->raw(), length, offset);
 
}
 
void Buffer::copy_to(Buffer* buffer, size_t length, size_t offset, size_t offset_other) {
 
    // Copy the bytes
    ASSERT((length + offset) <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_to(buffer->raw() + offset_other, length, offset);
 
}
 
 
void Buffer::copy_to(void* destination, size_t length) {
 
    // Copy the bytes
    ASSERT(length + m_offset <= (m_capacity), "Copy exceeds buffer capacity");
    memcpy(destination, m_bytes + m_offset, length);
    set_offset(m_offset + length);
 
}
 
void Buffer::copy_to(void* destination, size_t length, size_t offset) {
 
    // Copy the bytes
    ASSERT((length + offset + m_offset) <= m_capacity, "Copy exceeds buffer capacity");
    memcpy(destination, m_bytes + offset + m_offset, length);
    set_offset(m_offset + length);
 
}