Struct FilePtr

pub struct FilePtr<Ptr: IntoSeekFrom, BR: BinRead> {
    pub ptr: Ptr,
    pub value: Option<BR>,
}

A wrapper type for representing a layer of indirection within a file.

A FilePtr<P, T> is composed of two types: a pointer type P and a value type T where the pointer type describes and offset to read the value type from. Once read from the file it can be dereferenced to yeild the value it points to.

Example

use binread::{prelude::*, io::Cursor, FilePtr};

#[derive(BinRead)]
struct Test {
    pointer: FilePtr<u32, u8>
}

let test: Test = Cursor::new(b"\0\0\0\x08\0\0\0\0\xff").read_be().unwrap();
assert_eq!(test.pointer.ptr, 8);
assert_eq!(*test.pointer, 0xFF);

Example data mapped out:

          [pointer]           [value]
00000000: 0000 0008 0000 0000 ff                   ............

Use offset to change what the pointer is relative to (default: beginning of reader).

Fields

ptr: Ptr

value: Option<BR>

Implementations

impl<Ptr: BinRead<Args = ()> + IntoSeekFrom, BR: BinRead> FilePtr<Ptr, BR>

pub fn parse<R: Read + Seek>( reader: &mut R, options: &ReadOptions, args: BR::Args, ) -> BinResult<BR>

Custom parser designed for use with the parse_with attribute (example) that reads a FilePtr then immediately dereferences it into an owned value

pub fn into_inner(self) -> BR

Consume the pointer and return the inner type

Panics

Will panic if the file pointer hasn’t been properly postprocessed

Trait Implementations

impl<Ptr: BinRead<Args = ()> + IntoSeekFrom, BR: BinRead> BinRead for FilePtr<Ptr, BR>

type Args = <BR 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, _: Self::Args, ) -> BinResult<Self>

Read the type from the reader

fn after_parse<R>( &mut self, reader: &mut R, ro: &ReadOptions, args: BR::Args, ) -> BinResult<()>

where R: Read + Seek,

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<Ptr, BR> Debug for FilePtr<Ptr, BR>

where Ptr: BinRead<Args = ()> + IntoSeekFrom, BR: BinRead + Debug,

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

Formats the value using the given formatter.

impl<Ptr: IntoSeekFrom, BR: BinRead> Deref for FilePtr<Ptr, BR>

Panics

Will panic if the FilePtr has not been read yet using BinRead::after_parse

type Target = BR

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Ptr: IntoSeekFrom, BR: BinRead> DerefMut for FilePtr<Ptr, BR>

Panics

Will panic if the FilePtr has not been read yet using BinRead::after_parse

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

Mutably dereferences the value.

impl<Ptr, BR> PartialEq for FilePtr<Ptr, BR>

where Ptr: BinRead<Args = ()> + IntoSeekFrom, BR: BinRead + PartialEq,

fn eq(&self, other: &Self) -> 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.