Struct BinaryReader 

pub struct BinaryReader<'a> { /* private fields */ }

Binary reader for Unity file formats

Implementations

impl<'a> BinaryReader<'a>

pub const DEFAULT_MAX_STRING_LEN: usize = 16_777_216usize

Default maximum length for length-prefixed strings.

Unity files can contain large text blobs (e.g. TextAsset), but unbounded allocations are a DoS risk when parsing hostile input.

pub fn new(data: &'a [u8], byte_order: ByteOrder) -> BinaryReader<'a>

Create a new binary reader from byte slice

pub fn position(&self) -> u64

Get current position in the stream

pub fn set_position(&mut self, pos: u64) -> Result<(), BinaryError>

Set position in the stream

pub fn seek(&mut self, offset: i64) -> Result<u64, BinaryError>

Seek to a position relative to the current position

pub fn len(&self) -> usize

Get the total length of the data

pub fn is_empty(&self) -> bool

Check if the reader is empty

pub fn remaining(&self) -> usize

Get remaining bytes from current position

pub fn has_bytes(&self, count: usize) -> bool

Check if we have at least count bytes remaining

pub fn align(&mut self) -> Result<(), BinaryError>

Align to the next 4-byte boundary

pub fn align_to(&mut self, alignment: u64) -> Result<(), BinaryError>

Align to the specified byte boundary

pub fn read_u8(&mut self) -> Result<u8, BinaryError>

Read a single byte

pub fn read_bool(&mut self) -> Result<bool, BinaryError>

Read a boolean (as u8, 0 = false, non-zero = true)

pub fn read_i8(&mut self) -> Result<i8, BinaryError>

Read a signed 8-bit integer

pub fn read_u16(&mut self) -> Result<u16, BinaryError>

Read an unsigned 16-bit integer

pub fn read_i16(&mut self) -> Result<i16, BinaryError>

Read a signed 16-bit integer

pub fn read_u32(&mut self) -> Result<u32, BinaryError>

Read an unsigned 32-bit integer

pub fn read_i32(&mut self) -> Result<i32, BinaryError>

Read a signed 32-bit integer

pub fn read_u64(&mut self) -> Result<u64, BinaryError>

Read an unsigned 64-bit integer

pub fn read_i64(&mut self) -> Result<i64, BinaryError>

Read a signed 64-bit integer

pub fn read_f32(&mut self) -> Result<f32, BinaryError>

Read a 32-bit floating point number

pub fn read_f64(&mut self) -> Result<f64, BinaryError>

Read a 64-bit floating point number

pub fn read_bytes(&mut self, count: usize) -> Result<Vec<u8>, BinaryError>

Read a fixed number of bytes

pub fn skip_bytes(&mut self, count: usize) -> Result<(), BinaryError>

Skip a fixed number of bytes without allocating.

pub fn read_remaining(&mut self) -> &[u8]

Read all remaining bytes

pub fn read_cstring(&mut self) -> Result<String, BinaryError>

Read a null-terminated string

pub fn read_string(&mut self) -> Result<String, BinaryError>

Read a string with a length prefix (32-bit)

pub fn read_string_limited( &mut self, max_len: usize, ) -> Result<String, BinaryError>

Read a string with a length prefix and an explicit maximum size.

Unity typically encodes these lengths as signed 32-bit integers.

pub fn read_string_fixed( &mut self, length: usize, ) -> Result<String, BinaryError>

Read a string with a specific length

pub fn read_aligned_string(&mut self) -> Result<String, BinaryError>

Read an aligned string (Unity format)

pub fn byte_order(&self) -> ByteOrder

Get the current byte order

pub fn set_byte_order(&mut self, byte_order: ByteOrder)

Set the byte order

pub fn remaining_slice(&self) -> &[u8]

Get a slice of the remaining data

pub fn sub_reader( &self, offset: usize, length: usize, ) -> Result<BinaryReader<'a>, BinaryError>

Create a new reader for a subset of the data