Trait scroll::Pwrite

source · [−]
pub trait Pwrite<Ctx, E>: Index<usize> + IndexMut<RangeFrom<usize>> + MeasureWith<Ctx> where
    Ctx: Copy,
    E: From<Error>, {
    fn pwrite<N: TryIntoCtx<Ctx, <Self as Index<RangeFrom<usize>>>::Output, Error = E>>(
        &mut self, 
        n: N, 
        offset: usize
    ) -> Result<usize, E>
    where
        Ctx: Default,
    { ... }

    fn pwrite_with<N: TryIntoCtx<Ctx, <Self as Index<RangeFrom<usize>>>::Output, Error = E>>(
        &mut self, 
        n: N, 
        offset: usize, 
        ctx: Ctx
    ) -> Result<usize, E> { ... }

    fn gwrite<N: TryIntoCtx<Ctx, <Self as Index<RangeFrom<usize>>>::Output, Error = E>>(
        &mut self, 
        n: N, 
        offset: &mut usize
    ) -> Result<usize, E>
    where
        Ctx: Default,
    { ... }

    fn gwrite_with<N: TryIntoCtx<Ctx, <Self as Index<RangeFrom<usize>>>::Output, Error = E>>(
        &mut self, 
        n: N, 
        offset: &mut usize, 
        ctx: Ctx
    ) -> Result<usize, E> { ... }
}
Expand description

A very generic, contextual pwrite interface in Rust.

Like Pread — but for writing!

Implementing Pwrite on a data store allows you to then write almost arbitrarily complex types efficiently.

To this end the Pwrite trait works in conjuction with the TryIntoCtx; The TryIntoCtx trait implemented on a type defines how to convert said type into data that an implementation of Pwrite can … well … write.

As with Pread ‘data’ does not necessarily mean &[u8] but can be any indexable type. In fact much of the documentation of Pread applies to Pwrite as well just with ‘read’ switched for ‘write’ and ‘From’ switched with ‘Into’ so if you haven’t yet you should read the documentation of Pread first.

Unless you need to implement your own data store — that is either can’t convert to &[u8] or have a data that is not &[u8] — you will probably want to implement TryIntoCtx on your Rust types to be written.

Provided methods

Write N at offset I with context Ctx

Example
use scroll::{Pwrite, Pread, LE};
let mut bytes: [u8; 8] = [0, 0, 0, 0, 0, 0, 0, 0];
bytes.pwrite_with::<u32>(0xbeefbeef, 0, LE).unwrap();
assert_eq!(bytes.pread_with::<u32>(0, LE).unwrap(), 0xbeefbeef);

Write n into self at offset, with a default Ctx. Updates the offset.

Write n into self at offset, with the ctx. Updates the offset.

Implementors