Wrapper class for a region of bytes in memor in an attempt to add some memory safety. Automatically allocates the size specified and frees it once done, adds boundary to I/O. More...

#include <buffer.h>

Public Member Functions
	Buffer (size_t size, bool update_offset=true)
	Creates a buffer of the specified size.

	Buffer (void *source, size_t size, bool update_offset=true)
	Creates a buffer pointing to a source.

	~Buffer ()
	Destroy the buffer, freeing the memory.

uint8_t *	raw () const
	The raw pointer to the bytes stored in memory, use is not recommended.

void	clear ()
	Fulls the buffer with 0's and resets the offset.

void	full (uint8_t byte, size_t offset=0, size_t amount=0)
	Full the buffer with a specified byte at an offset.

void	set_offset (size_t offset)
	Set the offset for where operations should begin from.

size_t	capacity () const
	The max bytes the buffer can currently store.

void	resize (size_t size)
	Grow the buffer to fit a new size.

void	write (uint8_t byte)
	Safely writes a byte to the buffer at the current offset.

void	write (size_t offset, uint8_t byte)
	Safely writes a byte to the buffer at the specified offset.

uint8_t	read ()
	Safely reads a byte from the buffer at the current offset.

uint8_t	read (size_t offset)
	Safely reads a byte from the buffer at the specified offset.

void	copy_from (const Buffer *buffer)
	Copies all the bytes from another buffer into this buffer.

void	copy_from (const Buffer *buffer, size_t length)
	Copies a range of bytes from another buffer into this buffer.

void	copy_from (const Buffer *buffer, size_t length, size_t offset)
	Copies a range of bytes from another buffer into this buffer at a specified offset.

void	copy_from (const Buffer *buffer, size_t length, size_t offset, size_t offset_other)
	Copies a range of bytes from another buffer into this buffer at a specified offset for both.

void	copy_from (const void *source, size_t length)
	Copies a range of bytes from a source into this buffer.

void	copy_from (const void *source, size_t length, size_t offset)
	Copies a range of bytes from a source into this buffer at a specified offset.

void	copy_to (Buffer *buffer)
	Copies all the bytes from this buffer into another buffer.

void	copy_to (Buffer *buffer, size_t length)
	Writes a range of bytes from this buffer into another buffer.

void	copy_to (Buffer *buffer, size_t length, size_t offset)
	Copies a range of bytes from this buffer into another buffer at a specified offset.

void	copy_to (Buffer *buffer, size_t length, size_t offset, size_t offset_other)
	Copies a range of bytes from this buffer into another at an offset for each.

void	copy_to (void *destination, size_t length)
	Copies a range of bytes from this buffer into a source.

void	copy_to (void *destination, size_t length, size_t offset)
	Copies a range of bytes from this buffer at an offset into a source.

Public Attributes
bool	update_offset = true
	Should operations write/read/copy update the offset in the buffer?

Detailed Description

Wrapper class for a region of bytes in memor in an attempt to add some memory safety. Automatically allocates the size specified and frees it once done, adds boundary to I/O.

Definition at line 25 of file buffer.h.

Constructor & Destructor Documentation

◆ Buffer() [1/2]

Buffer::Buffer	(	size_t	size,
		bool	update_offset = `true`
	)

explicit

Creates a buffer of the specified size.

Parameters

size	The capacity of the buffer
update_offset	Should operations update the offset of the buffer?

Definition at line 20 of file buffer.cpp.

        : m_capacity(size),
          update_offset(update_offset) {
 
    // Create the buffer
    m_bytes = new uint8_t[size];
 
}

◆ Buffer() [2/2]

Buffer::Buffer	(	void *	source,
		size_t	size,
		bool	update_offset = `true`
	)

Creates a buffer pointing to a source.

Parameters

source	The source
size	The capacity of the source
update_offset	Should buffer operations update the internal offset?

Definition at line 36 of file buffer.cpp.

        : update_offset(update_offset) {
 
    m_bytes = (uint8_t*) source;
    m_capacity = size;
    m_dont_delete = true;
 
}

◆ ~Buffer()

Buffer::~Buffer ( )

Destroy the buffer, freeing the memory.

Definition at line 48 of file buffer.cpp.

                {
    if (!m_dont_delete && m_bytes)
        delete[] m_bytes;
}

Member Function Documentation

◆ capacity()

size_t Buffer::capacity ( ) const

The max bytes the buffer can currently store.

See also: Buffer:grow(size_t size) to increase this.

Returns: The length of the buffer storage array

Definition at line 95 of file buffer.cpp.

                              {
    return m_capacity;
}

Referenced by copy_from(), copy_from(), copy_from(), copy_from(), copy_to(), copy_to(), copy_to(), copy_to(), read(), write(), and MaxOS::drivers::disk::Disk::write().

◆ clear()

void Buffer::clear ( )

Fulls the buffer with 0's and resets the offset.

Definition at line 65 of file buffer.cpp.

                   {
 
    m_offset = 0;
    memset(m_bytes, 0, m_capacity);
}

References memset().

Referenced by MaxOS::filesystem::format::Fat32File::read(), and MaxOS::filesystem::format::Fat32File::write().

◆ copy_from() [1/6]

void Buffer::copy_from ( const Buffer * buffer )

Copies all the bytes from another buffer into this buffer.

Parameters

buffer Where to read from

Definition at line 195 of file buffer.cpp.

                                           {
 
    // Copy the buffer
    ASSERT(buffer->capacity() <= capacity(), "Copy exceeds buffer capacity");
    copy_from(buffer->raw(), buffer->capacity());
 
}

References ASSERT, capacity(), copy_from(), and raw().

Referenced by copy_from(), copy_from(), copy_from(), copy_from(), MaxOS::filesystem::format::Fat32File::read(), MaxOS::filesystem::format::ext2::Ext2File::write(), MaxOS::filesystem::format::Fat32File::write(), and MaxOS::filesystem::format::ext2::Ext2Volume::write_inode().

◆ copy_from() [2/6]

void Buffer::copy_from	(	const Buffer *	buffer,
		size_t	length
	)

Copies a range of bytes from another buffer into this buffer.

Parameters

buffer	Where to read from
length	How much to read

Definition at line 209 of file buffer.cpp.

                                                          {
 
    // Copy the buffer
    ASSERT(length <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_from(buffer->raw(), length);
 
}

References ASSERT, capacity(), copy_from(), and raw().

◆ copy_from() [3/6]

void Buffer::copy_from	(	const Buffer *	buffer,
		size_t	length,
		size_t	offset
	)

Copies a range of bytes from another buffer into this buffer at a specified offset.

Parameters

buffer	Where to read from
length	How much to read
offset	Where to start writing into this at

Definition at line 223 of file buffer.cpp.

                                                                         {
 
    // Copy the buffer
    ASSERT(length <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_from(buffer->raw(), length, offset);
 
}

References ASSERT, capacity(), copy_from(), and raw().

◆ copy_from() [4/6]

void Buffer::copy_from	(	const Buffer *	buffer,
		size_t	length,
		size_t	offset,
		size_t	offset_other
	)

Copies a range of bytes from another buffer into this buffer at a specified offset for both.

Parameters

buffer	Where to read from
length	How much to read
offset	Where to start writing into this at
offset_other	Where to start reading from the other buffer

Definition at line 239 of file buffer.cpp.

                                                                                              {
 
    // Copy the buffer
    ASSERT(length + offset_other <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_from(buffer->raw() + offset_other, length, offset);
 
}

References ASSERT, capacity(), copy_from(), and raw().

◆ copy_from() [5/6]

void Buffer::copy_from	(	const void *	source,
		size_t	length
	)

Copies a range of bytes from a source into this buffer.

Parameters

source	Where to read from
length	How much to read

Definition at line 253 of file buffer.cpp.

                                                        {
 
    // 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);
}

References ASSERT, memcpy(), and set_offset().

◆ copy_from() [6/6]

void Buffer::copy_from	(	const void *	source,
		size_t	length,
		size_t	offset
	)

Copies a range of bytes from a source into this buffer at a specified offset.

Parameters

source	Where to read from
length	How much to read
offset	Where to start writing at

Definition at line 268 of file buffer.cpp.

                                                                       {
 
    // 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);
 
}

References ASSERT, memcpy(), and set_offset().

◆ copy_to() [1/6]

void Buffer::copy_to ( Buffer * buffer )

Copies all the bytes from this buffer into another buffer.

Parameters

buffer Where to write to

Definition at line 282 of file buffer.cpp.

                                   {
 
    // Copy the buffer
    ASSERT(capacity() <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_to(buffer->raw(), capacity());
 
}

References ASSERT, capacity(), copy_to(), and raw().

Referenced by copy_to(), copy_to(), copy_to(), copy_to(), MaxOS::filesystem::format::ext2::Ext2File::read(), and MaxOS::filesystem::format::ext2::Ext2Volume::read_inode().

◆ copy_to() [2/6]

void Buffer::copy_to	(	Buffer *	buffer,
		size_t	length
	)

Writes a range of bytes from this buffer into another buffer.

Parameters

buffer	Where to write to
length	How much to write

Definition at line 296 of file buffer.cpp.

                                                  {
 
    // Copy the buffer
    ASSERT(length <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_to(buffer->raw(), length);
 
}

References ASSERT, capacity(), copy_to(), and raw().

◆ copy_to() [3/6]

void Buffer::copy_to	(	Buffer *	buffer,
		size_t	length,
		size_t	offset
	)

Copies a range of bytes from this buffer into another buffer at a specified offset.

Parameters

buffer	Where to write to
length	How much to write
offset	Where to start reading at

Definition at line 311 of file buffer.cpp.

                                                                 {
 
    // Copy the bytes
    ASSERT((length + offset) <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_to(buffer->raw(), length, offset);
 
}

References ASSERT, capacity(), copy_to(), and raw().

◆ copy_to() [4/6]

void Buffer::copy_to	(	Buffer *	buffer,
		size_t	length,
		size_t	offset,
		size_t	offset_other
	)

Copies a range of bytes from this buffer into another at an offset for each.

Parameters

buffer	Where to write to
length	How much to write
offset	Where to start reading from
offset_other	Where to start writing to

Definition at line 327 of file buffer.cpp.

                                                                                      {
 
    // Copy the bytes
    ASSERT((length + offset) <= buffer->capacity(), "Copy exceeds external buffer capacity");
    copy_to(buffer->raw() + offset_other, length, offset);
 
}

References ASSERT, capacity(), copy_to(), and raw().

◆ copy_to() [5/6]

void Buffer::copy_to	(	void *	destination,
		size_t	length
	)

Copies a range of bytes from this buffer into a source.

Parameters

destination	Where to write to
length	How much to write

Definition at line 342 of file buffer.cpp.

                                                     {
 
    // 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);
 
}

References ASSERT, memcpy(), and set_offset().

◆ copy_to() [6/6]

void Buffer::copy_to	(	void *	destination,
		size_t	length,
		size_t	offset
	)

Copies a range of bytes from this buffer at an offset into a source.

Parameters

destination	Where to write to
length	How much to write
offset	Where to start reading from

Definition at line 358 of file buffer.cpp.

                                                                    {
 
    // 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);
 
}

References ASSERT, memcpy(), and set_offset().

◆ full()

void Buffer::full	(	uint8_t	byte,
		size_t	offset = `0`,
		size_t	amount = `0`
	)

Full the buffer with a specified byte at an offset.

Parameters

byte	The byte to write
offset	Where to start writing (deafults to 0)
amount

Definition at line 78 of file buffer.cpp.

                                                            {
 
    // 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);
 
}

References ASSERT, and memset().

◆ raw()

uint8_t * Buffer::raw ( ) const

The raw pointer to the bytes stored in memory, use is not recommended.

Returns: The address of buffer's storage

Definition at line 57 of file buffer.cpp.

                           {
 
    return m_bytes;
}

Referenced by copy_from(), copy_from(), copy_from(), copy_from(), copy_to(), copy_to(), copy_to(), and copy_to().

◆ read() [1/2]

uint8_t Buffer::read ( )

Safely reads a byte from the buffer at the current offset.

Returns: The read byte

Definition at line 168 of file buffer.cpp.

                     {
    set_offset(m_offset + 1);
    return m_bytes[m_offset - 1];
}

References set_offset().

Referenced by MaxOS::drivers::disk::AdvancedTechnologyAttachment::write().

◆ read() [2/2]

uint8_t Buffer::read ( size_t offset )

Safely reads a byte from the buffer at the specified offset.

Parameters

offset The offset into the buffer storage array

Returns: The read byte

Definition at line 180 of file buffer.cpp.

                                  {
 
    // 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];
}

References ASSERT, capacity(), and set_offset().

◆ resize()

void Buffer::resize ( size_t size )

Grow the buffer to fit a new size.

Parameters

size	The new max capacity of the buffer

Definition at line 104 of file buffer.cpp.

                               {
 
    // 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;
 
}

References memcpy().

◆ set_offset()

void Buffer::set_offset ( size_t offset )

Set the offset for where operations should begin from.

Parameters

offset The new offset

Definition at line 128 of file buffer.cpp.

                                     {
 
    if (update_offset)
        m_offset = offset;
 
}

References update_offset.

Referenced by copy_from(), copy_from(), copy_to(), copy_to(), read(), MaxOS::filesystem::format::Fat32File::read(), read(), MaxOS::filesystem::format::ext2::Ext2Volume::read_block(), MaxOS::filesystem::format::Fat32File::write(), write(), write(), and MaxOS::filesystem::format::ext2::Ext2Volume::write_block().

◆ write() [1/2]

void Buffer::write	(	size_t	offset,
		uint8_t	byte
	)

Safely writes a byte to the buffer at the specified offset.

Parameters

offset	The offset into the buffer storage array
byte	The byte to write

Definition at line 152 of file buffer.cpp.

                                              {
 
    // 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);
 
}

References ASSERT, capacity(), and set_offset().

◆ write() [2/2]

void Buffer::write ( uint8_t byte )

Safely writes a byte to the buffer at the current offset.

Parameters

byte	The byte to write

Definition at line 140 of file buffer.cpp.

                               {
    m_bytes[m_offset] = byte;
    set_offset(m_offset + 1);
}

References set_offset().

Member Data Documentation

◆ update_offset

bool MaxOS::common::Buffer::update_offset = true

Should operations write/read/copy update the offset in the buffer?

Definition at line 44 of file buffer.h.

Referenced by set_offset(), and MaxOS::filesystem::format::ext2::Ext2Volume::write_block().

The documentation for this class was generated from the following files:

/home/runner/work/MaxOS/MaxOS/kernel/include/common/buffer.h
/home/runner/work/MaxOS/MaxOS/kernel/src/common/buffer.cpp

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Buffer() [1/2]

◆ Buffer() [2/2]

◆ ~Buffer()

Member Function Documentation

◆ capacity()

◆ clear()

◆ copy_from() [1/6]

◆ copy_from() [2/6]

◆ copy_from() [3/6]

◆ copy_from() [4/6]

◆ copy_from() [5/6]

◆ copy_from() [6/6]

◆ copy_to() [1/6]

◆ copy_to() [2/6]

◆ copy_to() [3/6]

◆ copy_to() [4/6]

◆ copy_to() [5/6]

◆ copy_to() [6/6]

◆ full()

◆ raw()

◆ read() [1/2]

◆ read() [2/2]

◆ resize()

◆ set_offset()

◆ write() [1/2]

◆ write() [2/2]

Member Data Documentation

◆ update_offset