Struct PosValue

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

A wrapper where the position it was read from is stored alongside the value

use binread::{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

pos: u64

Trait Implementations

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

type Args = <T as BinRead>::Args

The type of arguments needed to be supplied in order to read this type, usually a tuple.

fn read_options<R: Read + Seek>( reader: &mut R, options: &ReadOptions, args: T::Args, ) -> BinResult<Self>

Read the type from the reader

fn after_parse<R: Read + Seek>( &mut self, reader: &mut R, options: &ReadOptions, args: Self::Args, ) -> BinResult<()>

fn read<R: Read + Seek>(reader: &mut R) -> BinResult<Self>

Read the type from the reader while assuming no arguments have been passed

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

Read the type from the reader using the specified arguments

fn args_default() -> Option<Self::Args>

The default arguments to be used when using the read shortcut method. Override this for any type that optionally requries 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> 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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T> Deref for PosValue<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.