SC::Buffer Struct Reference

An heap allocated byte buffer that can optionally use an inline buffer. More...

#include <Buffer.h>

Inheritance diagram for SC::Buffer:

Public Member Functions
	Segment (uint32_t capacityInBytes, SegmentAllocator allocator=SegmentAllocator::Global) noexcept
	Segment (Segment &&other) noexcept
	Segment (const Segment &other) noexcept
template<typename U = T>
	Segment (Span< const U > span) noexcept
	Segment (std::initializer_list< T > list) noexcept

Friends
template<typename VTable2 >
struct	Segment

Detailed Description

An heap allocated byte buffer that can optionally use an inline buffer.

See also

SC::SmallBuffer to use an inline buffer that can optionally become heap allocated as needed.

Note

This class (and SC::SmallBuffer) reduces needs for the header-only SC::Vector (from Containers). SC::Buffer avoids some compile time / executable size bloat because it's not header only.

Example:

bool funcRequiringBuffer(Buffer& buffer)
{
    for (size_t idx = 0; idx < buffer.size(); ++idx)
    {
        if (buffer[idx] != 123)
            return false;
    }
    return true;
}
 
void BufferTest::basic()
{
    Buffer buffer;
    // Allocate 16 bytes
    SC_TEST_EXPECT(buffer.resizeWithoutInitializing(16));
 
    // Buffer is not inline (it's heap allocated)
    SC_TEST_EXPECT(not buffer.isInline());
 
    // Fill buffer with a value
    buffer.clear();
    SC_TEST_EXPECT(buffer.resize(buffer.capacity(), 123));
    funcRequiringBuffer(buffer);
 
    // Declare a buffer with inline capacity of 128 bytes
    SmallBuffer<128> smallBuffer;
 
    // copy buffer (will not allocate)
    smallBuffer = buffer;
 
    // smallBuffer is using inline buffer (no heap allocation)
    SC_TEST_EXPECT(smallBuffer.isInline());
    SC_TEST_EXPECT(smallBuffer.size() == 16);
    SC_TEST_EXPECT(smallBuffer.capacity() == 128);
 
    // SmallBuffer can be passed in place of regular Buffer
    funcRequiringBuffer(smallBuffer);
 
    SC_TEST_EXPECT(buffer.resizeWithoutInitializing(1024));
 
    // SmallBuffer now will allocate 1024 bytes
    // by using assignCopy instead of assignment operator
    // caller can check for allocation failure
    SC_TEST_EXPECT(smallBuffer.assign(buffer.toSpanConst()));
    SC_TEST_EXPECT(not smallBuffer.isInline());
    SC_TEST_EXPECT(smallBuffer.size() == 1024);
    SC_TEST_EXPECT(smallBuffer.capacity() == 1024);
 
    // Allocate 2kb on another buffer
    Buffer buffer2;
    SC_TEST_EXPECT(buffer2.resizeWithoutInitializing(2048));
 
    // SmallBuffer will "steal" the 2Kb buffer
    smallBuffer = move(buffer2);
 
    SC_TEST_EXPECT(smallBuffer.size() == 2048);
    SC_TEST_EXPECT(smallBuffer.capacity() == 2048);
    SC_TEST_EXPECT(buffer2.isEmpty());
 
    // Resize small buffer to its original capacity
    SC_TEST_EXPECT(smallBuffer.resizeWithoutInitializing(128));
 
    // The heap block is still in use
    SC_TEST_EXPECT(not smallBuffer.isInline());
    SC_TEST_EXPECT(smallBuffer.capacity() == 2048);
 
    // Shrinking it will restore its original inline buffer
    SC_TEST_EXPECT(smallBuffer.shrink_to_fit());
 
    // And verify that that's actually true
    SC_TEST_EXPECT(smallBuffer.isInline());
    SC_TEST_EXPECT(smallBuffer.capacity() == 128);
}

---

The documentation for this struct was generated from the following file:

• Buffer.h