Struct Serializer

pub struct Serializer<W, A, S> {
    pub writer: W,
    pub allocator: A,
    pub sharing: S,
}

Available on crate feature dep_rkyv only.

A serializer built from composeable pieces.

Fields

writer: W

The writer of the serializer.

allocator: A

The allocator of the serializer.

sharing: S

The pointer sharing of the serializer.

Implementations

impl<W, A, S> Serializer<W, A, S>

pub fn new(writer: W, allocator: A, sharing: S) -> Serializer<W, A, S>

Creates a new serializer from a writer, allocator, and pointer sharing.

pub fn into_raw_parts(self) -> (W, A, S)

Consumes the serializer and returns the components.

pub fn into_writer(self) -> W

Consumes the serializer and returns the writer.

The allocator and pointer sharing are discarded.

Trait Implementations

impl<W, A, S, E> Allocator<E> for Serializer<W, A, S>

where A: Allocator<E>,

unsafe fn push_alloc(&mut self, layout: Layout) -> Result<NonNull<[u8]>, E>

Allocates scratch space of the requested size.

unsafe fn pop_alloc( &mut self, ptr: NonNull<u8>, layout: Layout, ) -> Result<(), E>

Deallocates previously allocated scratch space.

impl<W, A, S> Debug for Serializer<W, A, S>

where W: Debug, A: Debug, S: Debug,

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

Formats the value using the given formatter.

impl<W, A, S> Default for Serializer<W, A, S>

where W: Default, A: Default, S: Default,

fn default() -> Serializer<W, A, S>

Returns the “default value” for a type.

impl<W, A, S> Positional for Serializer<W, A, S>

where W: Positional,

fn pos(&self) -> usize

Returns the current position of the writer.

impl<W, A, S, E> Sharing<E> for Serializer<W, A, S>

where S: Sharing<E>,

fn start_sharing(&mut self, address: usize) -> SharingState

Starts sharing the value associated with the given address.

fn finish_sharing(&mut self, address: usize, pos: usize) -> Result<(), E>

Finishes sharing the value associated with the given address.

impl<W, A, S, E> Writer<E> for Serializer<W, A, S>

where W: Writer<E>,

fn write(&mut self, bytes: &[u8]) -> Result<(), E>

Attempts to write the given bytes to the serializer.