Trait Cwrite

pub trait Cwrite<Ctx: Copy, I = usize>: Index<I> + IndexMut<RangeFrom<I>> {
    // Provided methods
    fn cwrite<N: IntoCtx<Ctx, <Self as Index<RangeFrom<I>>>::Output>>(
        &mut self,
        n: N,
        offset: I,
    )
       where Ctx: Default { ... }
    fn cwrite_with<N: IntoCtx<Ctx, <Self as Index<RangeFrom<I>>>::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 as Index<RangeFrom<I>>>::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 as Index<RangeFrom<I>>>::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);

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

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