Struct DefaultBuffer 

pub struct DefaultBuffer {
    pub buffer: Vec<u8>,
    pub head: usize,
    pub vtables: HashMap<Box<[u8]>, usize, BuildVTableHasher>,
}

The standard Buffer implementation.

Fields

• buffer — the raw backing allocation. Data grows from the high end toward the low end; bytes below head are uninitialized or stale and must never be read.
• head — index of the first byte of valid data. Always satisfies head <= buffer.len().
• vtables — deduplication map from vtable bytes to the slot where that vtable was written. Prevents writing the same vtable multiple times when many table elements share identical schemas (the common case).

Fields

buffer: Vec<u8>

head: usize

vtables: HashMap<Box<[u8]>, usize, BuildVTableHasher>

Trait Implementations

impl Buffer for DefaultBuffer

fn new(initial_size: usize) -> DefaultBuffer

Allocate an uninitialized buffer of initial_size bytes.

Uses with_capacity + set_len rather than vec![0; n] — see the module-level Cook-Mertz discussion for why zero-init is safe to skip here.

fn grow(&mut self, new_cap: usize)

Grow the buffer to new_cap bytes, shifting all existing written data to the right so that slot-based offsets remain valid.

Uses reserve + set_len rather than resize(n, 0) for the same reason as new: the new bytes in the low region are never read before being written.

fn share_vtable(&mut self, vtable: &[u8], table_slot: usize)

Write vtable to the buffer if not already present, then patch the 4-byte vtable-jump field at the start of the table object.

The vtable jump is a signed 32-bit integer stored at t_pos: jump = vtable_pos - table_pos (negative when vtable is before table)

Multiple table elements with the same schema share one physical vtable copy, which is why the dedup map is essential for space efficiency.

fn buffer(&self) -> &[u8]

Return the full backing byte slice (including the unwritten low region).

fn buffer_mut(&mut self) -> &mut [u8]

Return a mutable view of the full backing byte slice.

fn head(&self) -> usize

Return the current write frontier: the index of the first valid byte.

fn head_mut(&mut self) -> &mut usize

Return a mutable reference to the write frontier so callers can advance it with *buf.head_mut() -= n.

fn clear_vtables(&mut self)

Clear the vtable deduplication cache. Called by reset.

fn load<T>(bytes: &[u8]) -> DefaultBuffer

where T: Table,

Deserialize a finished flatbuffer into this buffer type.

fn reset(&mut self)

Reset the buffer for reuse without freeing the backing allocation.

fn len(&self) -> usize

Total capacity of the backing allocation in bytes.

fn ensure_capacity(&mut self, additional_size: usize)

Ensure additional_size bytes are available below head, growing the buffer if necessary.

fn slot(&self) -> usize

Distance from the end of the buffer to the current write frontier.

fn align(&mut self, alignment: usize)

Align head downward to alignment bytes (must be a power of two).

fn bytes(&self) -> &[u8]

The finished, readable byte slice starting at head.

fn finish(&mut self, slot: usize) -> &[u8]

Write the 4-byte root prefix and return the finished buffer slice.

impl Default for DefaultBuffer

fn default() -> DefaultBuffer

Returns the “default value” for a type.