Struct Strategy

pub struct Strategy<T, E>
where
    T: ?Sized,
{ /* private fields */ }

Available on crate feature dep_rkyv only.

Equips a type with a Fallible implementation that chooses E as its error type.

Example

use rancor::{Failure, Fallible, Strategy};

trait Print<E = <Self as Fallible>::Error> {
    fn print(&self, message: &str) -> Result<(), E>;
}

impl<T: Print<E> + ?Sized, E> Print<E> for Strategy<T, E> {
    fn print(&self, message: &str) -> Result<(), E> {
        T::print(self, message)
    }
}

struct StdOut;

impl<E> Print<E> for StdOut {
    fn print(&self, message: &str) -> Result<(), E> {
        println!("{message}");
        Ok(())
    }
}

Strategy::<_, Failure>::wrap(&mut StdOut)
    .print("hello world")
    .unwrap();

Implementations

impl<T, E> Strategy<T, E>

where T: ?Sized,

pub fn wrap(inner: &mut T) -> &mut Strategy<T, E>

Wraps the given mutable reference, returning a mutable reference to a Strategy.

Example

use core::ops::Deref;

use rancor::{Failure, Strategy};
fn test() {
    struct Inner {
        value: u64,
    }

    let mut inner = Inner { value: 10 };

    let inner_value_ptr = &inner.value as *const u64;
    let strategy: &mut Strategy<Inner, Failure> =
        Strategy::wrap(&mut inner);
    let strategy_value_ptr = (&strategy.deref().value) as *const u64;
    assert_eq!(inner_value_ptr, strategy_value_ptr);
    // Strategy wraps a type but does not change its memory layout.
}

test();

Trait Implementations

impl<T, E> Allocator<E> for Strategy<T, E>

where T: 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<T, E> ArchiveContext<E> for Strategy<T, E>

where T: ArchiveContext<E> + ?Sized,

fn check_subtree_ptr( &mut self, ptr: *const u8, layout: &Layout, ) -> Result<(), E>

Checks that the given data address and layout is located completely within the subtree range.

unsafe fn push_subtree_range( &mut self, root: *const u8, end: *const u8, ) -> Result<Range<usize>, E>

Pushes a new subtree range onto the validator and starts validating it.

unsafe fn pop_subtree_range(&mut self, range: Range<usize>) -> Result<(), E>

Pops the given range, restoring the original state with the pushed range removed.

impl<T, E> Deref for Strategy<T, E>

where T: ?Sized,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<Strategy<T, E> as Deref>::Target

Dereferences the value.

impl<T, E> DerefMut for Strategy<T, E>

where T: ?Sized,

fn deref_mut(&mut self) -> &mut <Strategy<T, E> as Deref>::Target

Mutably dereferences the value.

impl<T, E> Fallible for Strategy<T, E>

where T: ?Sized,

type Error = E

The error type associated with this type’s operations.

impl<T, E> Pooling<E> for Strategy<T, E>

where T: Pooling<E>,

fn start_pooling(&mut self, address: usize) -> PoolingState

Starts pooling the value associated with the given address.

unsafe fn finish_pooling( &mut self, address: usize, ptr: ErasedPtr, drop: unsafe fn(_: ErasedPtr), ) -> Result<(), E>

Finishes pooling the value associated with the given address.

impl<T, E> Positional for Strategy<T, E>

where T: Positional + ?Sized,

fn pos(&self) -> usize

Returns the current position of the writer.

impl<T, E> SharedContext<E> for Strategy<T, E>

where T: SharedContext<E>,

fn start_shared( &mut self, address: usize, type_id: TypeId, ) -> Result<ValidationState, E>

Starts validating the value associated with the given address.

fn finish_shared(&mut self, address: usize, type_id: TypeId) -> Result<(), E>

Finishes validating the value associated with the given address.

impl<T, E> Sharing<E> for Strategy<T, E>

where T: Sharing<E> + ?Sized,

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<T, E> Writer<E> for Strategy<T, E>

where T: Writer<E> + ?Sized,

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

Attempts to write the given bytes to the serializer.