Trait scroll::Cwrite

pub trait Cwrite<Ctx: Copy, I = usize>: Index<I> + IndexMut<RangeFrom<I>> {
    fn cwrite<N: IntoCtx<Ctx, Self::Output>>(&mut self, n: N, offset: I)
    where
        Ctx: Default,
    { ... }
    fn cwrite_with<N: IntoCtx<Ctx, Self::Output>>(
        &mut self, 
        n: N, 
        offset: I, 
        ctx: Ctx
    ) { ... }
}

Core-write - core, no_std friendly trait for writing basic types into byte buffers. Cannot fail unless the buffer is too small, in which case an assert fires and the program panics. Similar to Cread, if your type implements IntoCtx then you can cwrite(your_type, offset).

Example

use scroll::{ctx, Cwrite};

#[repr(packed)]
struct Bar {
    foo: i32,
    bar: u32,
}

impl ctx::IntoCtx<scroll::Endian> for Bar {
    fn into_ctx(self, bytes: &mut [u8], ctx: scroll::Endian) {
        use scroll::Cwrite;
        bytes.cwrite_with(self.foo, 0, ctx);
        bytes.cwrite_with(self.bar, 4, ctx);
    }
}

let bar = Bar { foo: -1, bar: 0xdeadbeef };
let mut bytes = [0x0; 16];
bytes.cwrite::<Bar>(bar, 0);

Provided Methods

fn cwrite<N: IntoCtx<Ctx, Self::Output>>(&mut self, n: N, offset: I) where
    Ctx: Default, 

Writes n into Self at offset; uses default context. For the primitive types, this will be the target machine's endianness.

Example

use scroll::{Cwrite, Cread};
let mut bytes = [0x0; 16];
bytes.cwrite::<i64>(42, 0);
bytes.cwrite::<u32>(0xdeadbeef, 8);

assert_eq!(bytes.cread::<i64>(0), 42);
assert_eq!(bytes.cread::<u32>(8), 0xdeadbeef);

fn cwrite_with<N: IntoCtx<Ctx, Self::Output>>(
    &mut self,
    n: N,
    offset: I,
    ctx: Ctx
)

Writes n into Self at offset with ctx

Example

use scroll::{Cwrite, Cread, LE, BE};
let mut bytes = [0x0; 0x10];
bytes.cwrite_with::<i64>(42, 0, LE);
bytes.cwrite_with::<u32>(0xdeadbeef, 8, BE);
assert_eq!(bytes.cread_with::<i64>(0, LE), 42);
assert_eq!(bytes.cread_with::<u32>(8, LE), 0xefbeadde);

Implementors

• impl<Ctx: Copy, I, W: ?Sized + Index<I> + IndexMut<RangeFrom<I>>> Cwrite<Ctx, I> for W