Struct rkyv::ser::serializers::WriteSerializer

pub struct WriteSerializer<W: Write> { /* fields omitted */ }

Wraps a type that implements io::Write and equips it with Serializer.

Examples

use rkyv::ser::{serializers::WriteSerializer, Serializer};

let mut serializer = WriteSerializer::new(Vec::new());
assert_eq!(serializer.pos(), 0);
serializer.write(&[0u8, 1u8, 2u8, 3u8]);
assert_eq!(serializer.pos(), 4);
let buf = serializer.into_inner();
assert_eq!(buf.len(), 4);
assert_eq!(buf, vec![0u8, 1u8, 2u8, 3u8]);

Implementations

impl<W: Write> WriteSerializer<W>

pub fn new(inner: W) -> Self

Creates a new serializer from a writer.

pub fn with_pos(inner: W, pos: usize) -> Self

Creates a new serializer from a writer, and assumes that the underlying writer is currently at the given position.

pub fn into_inner(self) -> W

Consumes the serializer and returns the internal writer used to create it.

Trait Implementations

impl<W: Write> Fallible for WriteSerializer<W>

type Error = Error

The error produced by any failing methods

impl<W: Write + Seek> SeekSerializer for WriteSerializer<W>

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

Seeks the serializer to the given absolute position.

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

Archives the given value at the nearest available position. If the serializer is already aligned, it will archive it at the current position.

fn serialize_unsized_front<T: SerializeUnsized<Self> + ?Sized>(
    &mut self,
    value: &T
) -> Result<usize, Self::Error> where
    T::Metadata: Serialize<Self>,
    T::Archived: ArchivePointee<ArchivedMetadata = Archived<T::Metadata>>, 

Archives a reference to the given value at the nearest available position. If the serializer is already aligned, it will archive it at the current position.

impl<W: Write> Serializer for WriteSerializer<W>

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: Archive + ?Sized>(
    &mut self,
    value: &T,
    resolver: T::Resolver
) -> Result<usize, Self::Error>

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

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

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

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

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

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

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