Struct kul_core::parser::premade::SliceDatumAllocator

pub struct SliceDatumAllocator<'a, TT, ET> { /* fields omitted */ }

A DatumAllocator for generic Datum types which simplistically allocates Datum values from a contiguous mutable slice of them by supplying mutable borrows of them. Once a Datum element has been allocated, it is not reused if dropped.

This is useful for either or both of:

• Allocating from stack arrays in constrained environments without heap allocation.

• Limiting the memory consumed by parsing, e.g. to prevent D.o.S. attacks. Heap-allocated arrays/slices could be used for this.

Allocated elements are not reused if dropped because that would require implementing Drop for the element type which would prevent being able to use basic arrays/slices (because the Datum elements reference each other with the same lifetime, and this only works for element types without Drop). To reuse a slice, a new allocator instance can be constructed with it again, once the prior parsing and borrows of the elements are finished.

Methods

impl<'a, TT, ET> SliceDatumAllocator<'a, TT, ET> where
    TT: Text, 

pub fn new(slice: &'a mut [MutRefDatum<'a, TT, ET>]) -> Self

Given a mutable slice of Datums of our type, make a new allocator from it.

pub fn unused(self) -> Option<&'a mut [MutRefDatum<'a, TT, ET>]>

Can be used to regain control of the borrow of the unused rest of the slice, so that it can be used for something else if desired.

Trait Implementations

impl<'a, TT, ET> DatumAllocator for SliceDatumAllocator<'a, TT, ET> where
    TT: Text, 

type TT = TT

The Text type for our Datum type. It should also implement TextConcat<Self> so it supports concatenation which the parsing requires.

type ET = ET

The "extra" type for our Datum type.

type DR = DatumMutRef<'a, Self::TT, Self::ET>

The type of references to Datums yielded by our parsing.

fn new_datum(
    &mut self,
    from: MutRefDatum<'a, Self::TT, Self::ET>
) -> Result<Self::DR, AllocError>

Allocate a fresh Datum, in whatever way the particular implementation wants, and set its initial value to that of the from argument. An AllocError is returned if allocation fails for any reason.

impl<'a, TT: Debug, ET: Debug> Debug for SliceDatumAllocator<'a, TT, ET>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.