pub trait BinRead: Sized {
type Args<'a>;
// Required method
fn read_options<R: Read + Seek>(
reader: &mut R,
endian: Endian,
args: Self::Args<'_>,
) -> BinResult<Self>;
// Provided methods
fn read<R: Read + Seek>(reader: &mut R) -> BinResult<Self>
where Self: ReadEndian,
for<'a> Self::Args<'a>: Required { ... }
fn read_be<R: Read + Seek>(reader: &mut R) -> BinResult<Self>
where for<'a> Self::Args<'a>: Required { ... }
fn read_le<R: Read + Seek>(reader: &mut R) -> BinResult<Self>
where for<'a> Self::Args<'a>: Required { ... }
fn read_ne<R: Read + Seek>(reader: &mut R) -> BinResult<Self>
where for<'a> Self::Args<'a>: Required { ... }
fn read_args<R: Read + Seek>(
reader: &mut R,
args: Self::Args<'_>,
) -> BinResult<Self>
where Self: ReadEndian { ... }
fn read_be_args<R: Read + Seek>(
reader: &mut R,
args: Self::Args<'_>,
) -> BinResult<Self> { ... }
fn read_le_args<R: Read + Seek>(
reader: &mut R,
args: Self::Args<'_>,
) -> BinResult<Self> { ... }
fn read_ne_args<R: Read + Seek>(
reader: &mut R,
args: Self::Args<'_>,
) -> BinResult<Self> { ... }
}Expand description
The BinRead trait reads data from streams and converts it into objects.
This trait is usually derived, but can also be manually implemented by
writing an appropriate Args type and read_options() function.
§Derivable
This trait can be used with #[derive] or #[binread]. Each field of a
derived type must either implement BinRead or be annotated with an
attribute containing a map, try_map, or parse_with directive.
Using #[binread] instead of #[derive] is required when using
temporary fields.
Required Associated Types§
Sourcetype Args<'a>
type Args<'a>
The type used for the args parameter of read_args() and
read_options().
When the given type implements Default, convenience functions like
read() are enabled. BinRead implementations that don’t receive any
arguments should use the () type.
When BinRead is derived, the import and import_tuple
directives define this type.
Required Methods§
Sourcefn read_options<R: Read + Seek>(
reader: &mut R,
endian: Endian,
args: Self::Args<'_>,
) -> BinResult<Self>
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.
§Errors
If reading fails, an Error variant will be returned.
§Examples
struct CustomPtr32<T>(T);
impl<T> BinRead for CustomPtr32<T>
where
for<'a> T: BinRead<Args<'a> = ()>,
{
type Args<'a> = u64;
fn read_options<R: Read + Seek>(
reader: &mut R,
endian: binrw::Endian,
args: Self::Args<'_>,
) -> BinResult<Self> {
let offset = u32::read_options(reader, endian, ())?;
let saved_position = reader.stream_position()?;
// Read from an offset with a provided base offset.
reader.seek(SeekFrom::Start(args + offset as u64))?;
let value = T::read_options(reader, endian, ())?;
reader.seek(SeekFrom::Start(saved_position))?;
Ok(CustomPtr32(value))
}
}Provided Methods§
Sourcefn read<R: Read + Seek>(reader: &mut R) -> BinResult<Self>where
Self: ReadEndian,
for<'a> Self::Args<'a>: Required,
fn read<R: Read + Seek>(reader: &mut R) -> BinResult<Self>where
Self: ReadEndian,
for<'a> Self::Args<'a>: Required,
Sourcefn read_be<R: Read + Seek>(reader: &mut R) -> BinResult<Self>where
for<'a> Self::Args<'a>: Required,
fn read_be<R: Read + Seek>(reader: &mut R) -> BinResult<Self>where
for<'a> Self::Args<'a>: Required,
Sourcefn read_le<R: Read + Seek>(reader: &mut R) -> BinResult<Self>where
for<'a> Self::Args<'a>: Required,
fn read_le<R: Read + Seek>(reader: &mut R) -> BinResult<Self>where
for<'a> Self::Args<'a>: Required,
Sourcefn read_ne<R: Read + Seek>(reader: &mut R) -> BinResult<Self>where
for<'a> Self::Args<'a>: Required,
fn read_ne<R: Read + Seek>(reader: &mut R) -> BinResult<Self>where
for<'a> Self::Args<'a>: Required,
Sourcefn read_args<R: Read + Seek>(
reader: &mut R,
args: Self::Args<'_>,
) -> BinResult<Self>where
Self: ReadEndian,
fn read_args<R: Read + Seek>(
reader: &mut R,
args: Self::Args<'_>,
) -> BinResult<Self>where
Self: ReadEndian,
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.