Trait binread::BinRead

pub trait BinRead: Sized {
    type Args: Any + Copy;
    fn read_options<R: Read + Seek>(
        reader: &mut R, 
        options: &ReadOptions, 
        args: Self::Args
    ) -> BinResult<Self>;

    fn read<R: Read + Seek>(reader: &mut R) -> BinResult<Self> { ... }
    fn read_args<R: Read + Seek>(
        reader: &mut R, 
        args: Self::Args
    ) -> BinResult<Self> { ... }
    fn after_parse<R: Read + Seek>(
        &mut self, 
        _: &mut R, 
        _: &ReadOptions, 
        _: Self::Args
    ) -> BinResult<()> { ... }
    fn args_default() -> Option<Self::Args> { ... }
}

A BinRead trait allows reading a structure from anything that implements io::Read and io::Seek BinRead is implemented on the type to be read out of the given reader

Associated Types

type Args: Any + Copy

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

NOTE: For types that don’t require any arguments, use the unit (()) type. This will allow read to be used.

Loading content...

Required methods

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

Read the type from the reader

Loading content...

Provided methods

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

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

Panics

Panics if there is no args_default implementation

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 after_parse<R: Read + Seek>(
    &mut self,
    _: &mut R,
    _: &ReadOptions,
    _: Self::Args
) -> BinResult<()>

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

Loading content...

Implementations on Foreign Types

impl BinRead for Vec<NonZeroU8>

type Args = ()

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

impl BinRead for Vec<NonZeroU16>

type Args = ()

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

impl BinRead for char

type Args = ()

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

impl BinRead for u8

type Args = ()

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

impl BinRead for u16

type Args = ()

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

impl BinRead for u32

type Args = ()

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

impl BinRead for u64

type Args = ()

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

impl BinRead for u128

type Args = ()

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

impl BinRead for i8

type Args = ()

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

impl BinRead for i16

type Args = ()

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

impl BinRead for i32

type Args = ()

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

impl BinRead for i64

type Args = ()

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

impl BinRead for i128

type Args = ()

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

impl BinRead for f32

type Args = ()

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

impl BinRead for f64

type Args = ()

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

impl<C: Copy + 'static, B: BinRead<Args = C>> BinRead for Vec<B>

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 0]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 1]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 2]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 3]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 4]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 5]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 6]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 7]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 8]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 9]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 10]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 11]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 12]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 13]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 14]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 15]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 16]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 17]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 18]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 19]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 20]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 21]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 22]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 23]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 24]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 25]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 26]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 27]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 28]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 29]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 30]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 31]

type Args = B::Args

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

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

impl<C: Copy + 'static, B: BinRead<Args = C> + Default> BinRead for [B; 32]

type Args = B::Args

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

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

impl<b1: BinRead<Args = ()>, b2: BinRead<Args = ()>, b3: BinRead<Args = ()>, b4: BinRead<Args = ()>, b5: BinRead<Args = ()>, b6: BinRead<Args = ()>, b7: BinRead<Args = ()>, b8: BinRead<Args = ()>, b9: BinRead<Args = ()>, b10: BinRead<Args = ()>, b11: BinRead<Args = ()>, b12: BinRead<Args = ()>, b13: BinRead<Args = ()>, b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b2: BinRead<Args = ()>, b3: BinRead<Args = ()>, b4: BinRead<Args = ()>, b5: BinRead<Args = ()>, b6: BinRead<Args = ()>, b7: BinRead<Args = ()>, b8: BinRead<Args = ()>, b9: BinRead<Args = ()>, b10: BinRead<Args = ()>, b11: BinRead<Args = ()>, b12: BinRead<Args = ()>, b13: BinRead<Args = ()>, b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b3: BinRead<Args = ()>, b4: BinRead<Args = ()>, b5: BinRead<Args = ()>, b6: BinRead<Args = ()>, b7: BinRead<Args = ()>, b8: BinRead<Args = ()>, b9: BinRead<Args = ()>, b10: BinRead<Args = ()>, b11: BinRead<Args = ()>, b12: BinRead<Args = ()>, b13: BinRead<Args = ()>, b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b4: BinRead<Args = ()>, b5: BinRead<Args = ()>, b6: BinRead<Args = ()>, b7: BinRead<Args = ()>, b8: BinRead<Args = ()>, b9: BinRead<Args = ()>, b10: BinRead<Args = ()>, b11: BinRead<Args = ()>, b12: BinRead<Args = ()>, b13: BinRead<Args = ()>, b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b5: BinRead<Args = ()>, b6: BinRead<Args = ()>, b7: BinRead<Args = ()>, b8: BinRead<Args = ()>, b9: BinRead<Args = ()>, b10: BinRead<Args = ()>, b11: BinRead<Args = ()>, b12: BinRead<Args = ()>, b13: BinRead<Args = ()>, b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b6: BinRead<Args = ()>, b7: BinRead<Args = ()>, b8: BinRead<Args = ()>, b9: BinRead<Args = ()>, b10: BinRead<Args = ()>, b11: BinRead<Args = ()>, b12: BinRead<Args = ()>, b13: BinRead<Args = ()>, b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b7: BinRead<Args = ()>, b8: BinRead<Args = ()>, b9: BinRead<Args = ()>, b10: BinRead<Args = ()>, b11: BinRead<Args = ()>, b12: BinRead<Args = ()>, b13: BinRead<Args = ()>, b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b8: BinRead<Args = ()>, b9: BinRead<Args = ()>, b10: BinRead<Args = ()>, b11: BinRead<Args = ()>, b12: BinRead<Args = ()>, b13: BinRead<Args = ()>, b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b9: BinRead<Args = ()>, b10: BinRead<Args = ()>, b11: BinRead<Args = ()>, b12: BinRead<Args = ()>, b13: BinRead<Args = ()>, b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b10: BinRead<Args = ()>, b11: BinRead<Args = ()>, b12: BinRead<Args = ()>, b13: BinRead<Args = ()>, b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b11: BinRead<Args = ()>, b12: BinRead<Args = ()>, b13: BinRead<Args = ()>, b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b12: BinRead<Args = ()>, b13: BinRead<Args = ()>, b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b13: BinRead<Args = ()>, b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b14: BinRead<Args = ()>, b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b15: BinRead<Args = ()>, b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b16: BinRead<Args = ()>, b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b17: BinRead<Args = ()>, b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b18: BinRead<Args = ()>, b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b19: BinRead<Args = ()>, b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b20: BinRead<Args = ()>, b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b21: BinRead<Args = ()>, b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b22: BinRead<Args = ()>, b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b23: BinRead<Args = ()>, b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b23, b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b24: BinRead<Args = ()>, b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b24, b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b25: BinRead<Args = ()>, b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b25, b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b26: BinRead<Args = ()>, b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b26, b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b27: BinRead<Args = ()>, b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b27, b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b28: BinRead<Args = ()>, b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b28, b29, b30, b31, b32)

type Args = ()

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

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

impl<b29: BinRead<Args = ()>, b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b29, b30, b31, b32)

type Args = ()

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

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

impl<b30: BinRead<Args = ()>, b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b30, b31, b32)

type Args = ()

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

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

impl<b31: BinRead<Args = ()>, b32: BinRead<Args = ()>> BinRead for (b31, b32)

type Args = ()

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

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

impl<b32: BinRead<Args = ()>> BinRead for (b32,)

type Args = ()

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

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

impl BinRead for ()

type Args = ()

fn read_options<R: Read + Seek>(
    _: &mut R,
    _: &ReadOptions,
    _: Self::Args
) -> BinResult<Self>

impl<T: BinRead> BinRead for Box<T>

type Args = T::Args

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

impl<T: BinRead> BinRead for Option<T>

type Args = T::Args

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

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

impl<T> BinRead for PhantomData<T>

type Args = ()

fn read_options<R: Read + Seek>(
    _: &mut R,
    _: &ReadOptions,
    _: Self::Args
) -> BinResult<Self>

Loading content...

Implementors

impl BinRead for NullString

type Args = ()

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

impl BinRead for NullWideString

type Args = ()

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

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

type Args = BR::Args

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

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

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

type Args = T::Args

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

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

Loading content...