Struct PtrOffsetSerializer 

pub struct PtrOffsetSerializer<const STORAGE_ALIGNMENT: usize, const VALUE_ALIGNMENT: usize, const MAX_VALUE_ALIGNMENT: usize, const MAX_CAPACITY: usize, BorrowedStorage: BorrowMut<AlignedVec<STORAGE_ALIGNMENT, VALUE_ALIGNMENT, MAX_VALUE_ALIGNMENT, MAX_CAPACITY>>> { /* private fields */ }

Serializer that overwrites pointers in output with position offsets, relative to the start of the output buffer.

Unlike PureCopySerializer, this allows a deserializer to walk through the serializer output in any order.

Values in output will be correctly aligned for their types.

See AlignedStorage for an explanation of the const parameters.

Example

use ser_raw::{
	PtrOffsetSerializer, Serialize, Serializer,
	storage::ContiguousStorage
};

let boxed: Box<u8> = Box::new(123);
let mut ser = PtrOffsetSerializer::<16, 8, 16, 1024, _>::new();
let storage = ser.serialize(&boxed);
let slice = storage.as_slice();

const PTR_SIZE: usize = std::mem::size_of::<usize>();
let offset = usize::from_ne_bytes(slice[..PTR_SIZE].try_into().unwrap());
assert_eq!(offset, 8);
assert_eq!(slice[offset], 123);

Implementations

impl<const SA: usize, const VA: usize, const MVA: usize, const MAX: usize> PtrOffsetSerializer<SA, VA, MVA, MAX, AlignedVec<SA, VA, MVA, MAX>>

pub fn new() -> Self

Create new PtrOffsetSerializer with no memory pre-allocated.

If you know, or can estimate, the amount of buffer space that’s going to be needed in advance, allocating upfront with with_capacity can dramatically improve performance vs using new.

pub fn with_capacity(capacity: usize) -> Self

Create new PtrOffsetSerializer with buffer pre-allocated with capacity of at least capacity bytes.

capacity will be rounded up to a multiple of MAX_VALUE_ALIGNMENT.

Panics

Panics if capacity exceeds MAX_CAPACITY.

impl<const SA: usize, const VA: usize, const MVA: usize, const MAX: usize, BorrowedStorage> PtrOffsetSerializer<SA, VA, MVA, MAX, BorrowedStorage>

where BorrowedStorage: BorrowMut<AlignedVec<SA, VA, MVA, MAX>>,

pub const STORAGE_ALIGNMENT: usize = SA

Alignment of output buffer

pub const VALUE_ALIGNMENT: usize = VA

Typical alignment of values being serialized

pub const MAX_VALUE_ALIGNMENT: usize = MVA

Maximum alignment of values being serialized

pub const MAX_CAPACITY: usize = MAX

Maximum capacity of output buffer.

pub fn from_storage(storage: BorrowedStorage) -> Self

Create new PtrOffsetSerializer from an existing BorrowMut<AlignedVec>.

Trait Implementations

impl<const STORAGE_ALIGNMENT: usize, const VALUE_ALIGNMENT: usize, const MAX_VALUE_ALIGNMENT: usize, const MAX_CAPACITY: usize, BorrowedStorage: BorrowMut<AlignedVec<STORAGE_ALIGNMENT, VALUE_ALIGNMENT, MAX_VALUE_ALIGNMENT, MAX_CAPACITY>>> PosTracking for PtrOffsetSerializer<STORAGE_ALIGNMENT, VALUE_ALIGNMENT, MAX_VALUE_ALIGNMENT, MAX_CAPACITY, BorrowedStorage>

fn pos_mapping(&self) -> &PosMapping

Get current position mapping

fn set_pos_mapping(&mut self, pos_mapping: PosMapping)

Set current position mapping

fn pos_for<T>(&self, value: &T) -> usize

Get position for a value

fn do_serialize_value<T: Serialize<Self>>(&mut self, value: &T)

fn do_push_slice<T>(&mut self, slice: &[T], _ptr_addr: Self::Addr)

fn do_push_and_process_slice<T, P: FnOnce(&mut Self)>( &mut self, slice: &[T], _ptr_addr: Self::Addr, process: P, )

impl<const STORAGE_ALIGNMENT: usize, const VALUE_ALIGNMENT: usize, const MAX_VALUE_ALIGNMENT: usize, const MAX_CAPACITY: usize, BorrowedStorage: BorrowMut<AlignedVec<STORAGE_ALIGNMENT, VALUE_ALIGNMENT, MAX_VALUE_ALIGNMENT, MAX_CAPACITY>>> PtrOffset for PtrOffsetSerializer<STORAGE_ALIGNMENT, VALUE_ALIGNMENT, MAX_VALUE_ALIGNMENT, MAX_CAPACITY, BorrowedStorage>

unsafe fn do_write_ptr(&mut self, ptr_pos: usize, target_pos: usize)

Overwrite pointer.

impl<const STORAGE_ALIGNMENT: usize, const VALUE_ALIGNMENT: usize, const MAX_VALUE_ALIGNMENT: usize, const MAX_CAPACITY: usize, BorrowedStorage: BorrowMut<AlignedVec<STORAGE_ALIGNMENT, VALUE_ALIGNMENT, MAX_VALUE_ALIGNMENT, MAX_CAPACITY>>> PtrWriting for PtrOffsetSerializer<STORAGE_ALIGNMENT, VALUE_ALIGNMENT, MAX_VALUE_ALIGNMENT, MAX_CAPACITY, BorrowedStorage>

unsafe fn write_ptr(&mut self, ptr_pos: usize, target_pos: usize)

Overwrite pointer.

Safety

• ptr_pos and target_pos must both sit within bounds of output.
• target_pos must be location of a valid value for the type being pointed to.
• ptr_pos must be aligned for a pointer.

fn do_push_slice<T>(&mut self, slice: &[T], ptr_addr: Self::Addr)

fn do_push_and_process_slice<T, P: FnOnce(&mut Self)>( &mut self, slice: &[T], ptr_addr: Self::Addr, process: P, )

impl<const STORAGE_ALIGNMENT: usize, const VALUE_ALIGNMENT: usize, const MAX_VALUE_ALIGNMENT: usize, const MAX_CAPACITY: usize, BorrowedStorage: BorrowMut<AlignedVec<STORAGE_ALIGNMENT, VALUE_ALIGNMENT, MAX_VALUE_ALIGNMENT, MAX_CAPACITY>>> Serializer for PtrOffsetSerializer<STORAGE_ALIGNMENT, VALUE_ALIGNMENT, MAX_VALUE_ALIGNMENT, MAX_CAPACITY, BorrowedStorage>

type Storage = AlignedVec<STORAGE_ALIGNMENT, VALUE_ALIGNMENT, MAX_VALUE_ALIGNMENT, MAX_CAPACITY>

Storage which backs this serializer.

type BorrowedStorage = BorrowedStorage

BorrowMut of Storage which backs this serializer. This enables creating a serializer from an existing Storage.

type Addr = TrackingAddr

Addr type this serializer uses.

fn serialize_value<T: Serialize<Self>>(&mut self, value: &T)

Serialize a value and all its dependencies.

fn push_slice<T>(&mut self, slice: &[T], ptr_addr: Self::Addr)

Push a slice of values to output.

fn push_and_process_slice<T, P: FnOnce(&mut Self)>( &mut self, slice: &[T], ptr_addr: Self::Addr, process: P, )

Push a slice of values to output and continue processing content of the slice.

fn storage( &self, ) -> &AlignedVec<STORAGE_ALIGNMENT, VALUE_ALIGNMENT, MAX_VALUE_ALIGNMENT, MAX_CAPACITY>

Get immutable ref to Storage backing this Serializer.

fn storage_mut( &mut self, ) -> &mut AlignedVec<STORAGE_ALIGNMENT, VALUE_ALIGNMENT, MAX_VALUE_ALIGNMENT, MAX_CAPACITY>

Get mutable ref to Storage backing this Serializer.

fn into_storage(self) -> BorrowedStorage

Consume Serializer and return the backing storage as a BorrowMut<Storage>.

fn serialize<T: Serialize<Self>>(self, value: &T) -> Self::BorrowedStorage

Serialize a value and all its dependencies.

fn push<T>(&mut self, value: &T, ptr_addr: Self::Addr)

Push a value to output.

fn push_and_process<T, P: FnOnce(&mut Self)>( &mut self, t: &T, ptr_addr: Self::Addr, process: P, )

Push a value to output and continue processing the value.

fn push_raw<T>(&mut self, value: &T)

Push a value to output.

fn push_raw_slice<T>(&mut self, slice: &[T])

Push a slice of values to output.

fn push_raw_bytes(&mut self, bytes: &[u8])

Push raw bytes to output.

unsafe fn write<T>(&mut self, value: &T, addr: usize)

Write a value to storage at a specific position.

fn write_correction<W: FnOnce(&mut Self)>(&mut self, write: W)

Write a correction to storage.

fn finalize(self) -> Self::BorrowedStorage

Finalize serialization, consume serializer, and return backing storage as BorrowMut<Storage>.

fn capacity(&self) -> usize

Get current capacity of output.

fn pos(&self) -> usize

Get current position in output.