Struct binrw::PosValue

pub struct PosValue<T> {
    pub val: T,
    pub pos: u64,
}

A wrapper that stores a value’s position alongside the value.

Examples

use binrw::{BinRead, PosValue, BinReaderExt, io::Cursor};

#[derive(BinRead)]
struct MyType {
    a: u16,
    b: PosValue<u8>
}

let val = Cursor::new(b"\xFF\xFE\xFD").read_be::<MyType>().unwrap();
assert_eq!(val.b.pos, 2);
assert_eq!(*val.b, 0xFD);

Fields

val: T

The read value.

pos: u64

The byte position of the start of the value.

Trait Implementations

impl<T: BinRead> BinRead for PosValue<T>

type Args<'a> = <T as BinRead>::Args<'a>

The type used for the args parameter of read_args() and read_options().

fn read_options<R: Read + Seek>( reader: &mut R, endian: Endian, args: Self::Args<'_> ) -> BinResult<Self>

Read Self from the reader using the given Endian and arguments.

fn after_parse<R: Read + Seek>( &mut self, reader: &mut R, endian: Endian, args: Self::Args<'_> ) -> BinResult<()>

Runs any post-processing steps required to finalize construction of the object.

fn read_be_args<R: Read + Seek>( reader: &mut R, args: Self::Args<'_> ) -> BinResult<Self>

Read Self from the reader, assuming big-endian byte order, using the given arguments.

fn read_le_args<R: Read + Seek>( reader: &mut R, args: Self::Args<'_> ) -> BinResult<Self>

Read Self from the reader, assuming little-endian byte order, using the given arguments.

fn read_ne_args<R: Read + Seek>( reader: &mut R, args: Self::Args<'_> ) -> BinResult<Self>

Read T from the reader, assuming native-endian byte order, using the given arguments.

impl<T: Clone> Clone for PosValue<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for PosValue<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Deref for PosValue<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for PosValue<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<U, T: PartialEq<U>> PartialEq<U> for PosValue<T>

fn eq(&self, other: &U) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.