Struct timely::container::flatcontainer::impls::codec::CodecRegion

pub struct CodecRegion<C, R = OwnedRegion<u8>>
where
    C: Codec,
{ /* private fields */ }

A region that encodes its data in a codec C.

Trait Implementations

impl<C, R> Clone for CodecRegion<C, R>

where C: Clone + Codec, R: Clone,

fn clone(&self) -> CodecRegion<C, R>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C, R> Debug for CodecRegion<C, R>

where C: Debug + Codec, R: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<C, R> Default for CodecRegion<C, R>

where C: Default + Codec, R: Default,

fn default() -> CodecRegion<C, R>

Returns the “default value” for a type.

impl<C, R> Push<&[u8]> for CodecRegion<C, R>

where C: Codec, R: for<'a> Region<ReadItem<'a> = &'a [u8]> + for<'a> Push<&'a [u8]> + 'a,

fn push(&mut self, item: &[u8]) -> <CodecRegion<C, R> as Region>::Index

Push item into self, returning an index that allows to look up the corresponding read item.

impl<C, R> Region for CodecRegion<C, R>

where C: Codec, R: for<'a> Region<ReadItem<'a> = &'a [u8]> + 'a,

fn merge_regions<'a>( regions: impl Iterator<Item = &'a CodecRegion<C, R>> + Clone ) -> CodecRegion<C, R>

where CodecRegion<C, R>: 'a,

Construct a region that can absorb the contents of regions in the future.

type Owned = Vec<u8>

An owned type that can be constructed from a read item.

type ReadItem<'a> = &'a [u8] where CodecRegion<C, R>: 'a

The type of the data that one gets out of the container.

type Index = <R as Region>::Index

The type to index into the container. Should be treated as an opaque type, even if known.

fn index( &self, index: <CodecRegion<C, R> as Region>::Index ) -> <CodecRegion<C, R> as Region>::ReadItem<'_>

Index into the container. The index must be obtained by pushing data into the container.

fn reserve_regions<'a, I>(&mut self, regions: I)

where CodecRegion<C, R>: 'a, I: Iterator<Item = &'a CodecRegion<C, R>> + Clone,

Ensure that the region can absorb the items of regions without reallocation

fn clear(&mut self)

Remove all elements from this region, but retain allocations if possible.

fn heap_size<F>(&self, callback: F)

where F: FnMut(usize, usize),

Heap size, size - capacity

fn reborrow<'b, 'a>( item: <CodecRegion<C, R> as Region>::ReadItem<'a> ) -> <CodecRegion<C, R> as Region>::ReadItem<'b>

where 'a: 'b, C: 'a,

Converts a read item into one with a narrower lifetime.