Struct Arena 

pub struct Arena { /* private fields */ }

Bump allocator for bulk array construction.

Allocates all column buffers from a single 64-byte aligned Vec64<u8>, reducing per-batch allocation count from O(columns) to O(1).

See the module-level documentation for usage examples.

Implementations

impl Arena

pub fn with_capacity(bytes: usize) -> Self

Create an arena with the given byte capacity.

The backing buffer is allocated once as a single Vec64<u8>. All subsequent push_* and reserve_* calls bump a cursor within this allocation.

pub fn used(&self) -> usize

Number of bytes used so far, including alignment padding.

pub fn remaining(&self) -> usize

Remaining capacity in bytes.

pub fn capacity(&self) -> usize

Total capacity in bytes.

pub fn push_slice<T: Copy>(&mut self, data: &[T]) -> ArenaRegion

Copy a typed slice into the arena, returning a region handle.

The region is 64-byte aligned for SIMD compatibility.

Panics

Panics if the arena does not have sufficient remaining capacity.

pub fn push_bitmask(&mut self, mask: &Bitmask) -> ArenaRegion

Copy a Bitmask’s raw bytes into the arena, returning a region handle.

The region is 64-byte aligned.

Panics

Panics if the arena does not have sufficient remaining capacity.

pub fn reserve_slice<T>(&mut self, count: usize) -> ArenaRegion

Reserve uninitialised space for count elements of type T.

The region is 64-byte aligned. Use region_as_mut_slice() to write data into the reserved region before freezing.

Panics

Panics if the arena does not have sufficient remaining capacity.

pub fn region_as_mut_slice<T>(&mut self, region: &ArenaRegion) -> &mut [T]

Get a mutable typed slice for a previously reserved region.

Use this to write data into a region obtained from reserve_slice() before calling freeze().

Panics

Panics if the region is out of bounds or its byte length is not a multiple of size_of::<T>().

pub fn write_slices<T: Copy>( &mut self, slices: &[(&[T], Option<&Bitmask>)], total_count: usize, has_nulls: bool, ) -> AAMaker

Write multiple typed slices into a single contiguous region.

Reserves space for total_count elements, then copies each slice sequentially into the region.

Optionally builds a null mask from per-slice masks. When has_nulls is true, a mask region is reserved and populated from the provided masks. Slices without a mask contribute all-valid bits.

pub fn write_string_slices<T>( &mut self, slices: &[(&[T], &[u8], Option<&Bitmask>)], total_rows: usize, total_data_bytes: usize, has_nulls: bool, ) -> AAMaker

where T: Copy + Default + Add<Output = T> + Sub<Output = T> + ToPrimitive + NumCast,

Write multiple string arrays into a single contiguous region.

Each entry is (offsets, data_bytes, null_mask) from one batch. Handles offset adjustment so the combined offsets reference the concatenated data buffer.

pub fn write_boolean_slices( &mut self, slices: &[(&Bitmask, Option<&Bitmask>)], total_rows: usize, has_nulls: bool, ) -> AAMaker

Write multiple bitmasks into a single contiguous boolean region.

Each entry is (data_bitmask, null_mask) from one batch.

pub fn capacity_for_regions(entries: &[(usize, usize)]) -> usize

Calculate total arena bytes needed for a set of regions.

Each entry is (len, element_size_in_bytes). Each region is rounded up to 64-byte alignment, matching reserve_slice padding.

pub fn freeze(self) -> SharedBuffer

Freeze the arena, returning the backing SharedBuffer.

The arena is consumed and can no longer be written to. Use ArenaRegion::to_buffer() and ArenaRegion::to_bitmask() to extract typed views from the returned SharedBuffer.