Struct microkelvin::StoreSerializer

pub struct StoreSerializer<I> { /* private fields */ }

A buffered serializer wrapping a StoreRef

Implementations

impl<I> StoreSerializer<I>

pub fn new(store: StoreRef<I>, buffer: TokenBuffer) -> Self

Creates a new serializer from a buffer

pub fn serialize<T: Serialize<Self>>(&mut self, t: &T)

Serialize into store

pub fn commit(&mut self) -> I

Commit the bytes written

pub fn spill_bytes<F, R>(self, f: F) -> R where
    F: Fn(&[u8]) -> R, 

Get access to the written bytes without writing them into the backing storage

Trait Implementations

impl<I> Drop for StoreSerializer<I>

fn drop(&mut self)

Executes the destructor for this type.

impl<I> Fallible for StoreSerializer<I>

type Error = Infallible

The error produced by any failing methods.

impl<I> ScratchSpace for StoreSerializer<I>

unsafe fn push_scratch(
    &mut self,
    layout: Layout
) -> Result<NonNull<[u8]>, Self::Error>

Allocates scratch space of the requested size.

unsafe fn pop_scratch(
    &mut self,
    ptr: NonNull<u8>,
    layout: Layout
) -> Result<(), Self::Error>

Deallocates previously allocated scratch space.

impl<I> Serializer for StoreSerializer<I>

fn pos(&self) -> usize

Returns the current position of the serializer.

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

Attempts to write the given bytes to the serializer.

fn pad(&mut self, padding: usize) -> Result<(), Self::Error>

Advances the given number of bytes as padding.

fn align(&mut self, align: usize) -> Result<usize, Self::Error>

Aligns the position of the serializer to the given alignment.

fn align_for<T>(&mut self) -> Result<usize, Self::Error>

Aligns the position of the serializer to be suitable to write the given type.

unsafe fn resolve_aligned<T>(
    &mut self,
    value: &T,
    resolver: <T as Archive>::Resolver
) -> Result<usize, Self::Error> where
    T: Archive + ?Sized, 

Resolves the given value with its resolver and writes the archived type.

fn serialize_value<T>(&mut self, value: &T) -> Result<usize, Self::Error> where
    T: Serialize<Self>, 

Archives the given object and returns the position it was archived at.

unsafe fn resolve_unsized_aligned<T>(
    &mut self,
    value: &T,
    to: usize,
    metadata_resolver: <T as ArchiveUnsized>::MetadataResolver
) -> Result<usize, Self::Error> where
    T: ArchiveUnsized + ?Sized, 

Resolves the given reference with its resolver and writes the archived reference.

fn serialize_unsized_value<T>(
    &mut self,
    value: &T
) -> Result<usize, Self::Error> where
    T: SerializeUnsized<Self> + ?Sized, 

Archives a reference to the given object and returns the position it was archived at.

impl<I> StoreProvider<I> for StoreSerializer<I>

fn store(&self) -> &StoreRef<I>

Get a StoreRef associated with Self