Struct SqpkExpandData 

pub struct SqpkExpandData {
    pub target_file: SqpackFileId,
    pub block_offset: u64,
    pub block_count: u32,
}

SQPK E command body: grow a .dat file by writing empty-block markers into a previously unallocated region.

ExpandData and SqpkDeleteData produce the same on-disk result — both write a SqPack empty-block header at block_offset followed by zeroed bytes for the full block range. The semantic difference is in the patch’s intent:

• E (ExpandData) extends the file into space that did not previously exist, growing the archive. It typically precedes a series of A (AddData) writes into that newly allocated space.
• D (DeleteData) clears existing live blocks, logically freeing them.

The apply implementation (src/apply/sqpk.rs) handles both commands with the same write_empty_block helper.

Wire format (all big-endian)

┌────────────────────────────────────────────────────────────────────┐
│ <padding>        : [u8; 3]   (reserved, always zero)               │  bytes 0–2
│ main_id          : u16 BE                                          │  bytes 3–4
│ sub_id           : u16 BE                                          │  bytes 5–6
│ file_id          : u32 BE                                          │  bytes 7–10
│ block_offset_raw : u32 BE    multiply by 128 to get byte offset    │  bytes 11–14
│ block_count      : u32 BE    number of 128-byte blocks to allocate │  bytes 15–18
│ <reserved>       : u32       (always zero)                         │  bytes 19–22
└────────────────────────────────────────────────────────────────────┘

block_offset_raw is in 128-byte SqPack block units and is multiplied by 128 (<< 7) during parsing. block_count is a direct block count (not a byte count) and is stored as-is.

The total byte range affected by this command is block_count * 128 bytes starting at block_offset.

Reference

Errors

Parsing returns crate::ParseError::Decode if the body is too short to contain all required fields.

Fields

target_file: SqpackFileId

SqPack file to expand.

Preceded by 3 bytes of alignment padding in the wire format.

block_offset: u64

Byte offset within the target .dat file at which the new block range begins.

Decoded from a raw big-endian u32 by multiplying by 128 (raw << 7). The raw wire value is in 128-byte SqPack block units.

block_count: u32

Number of 128-byte SqPack blocks to allocate.

Stored directly as a big-endian u32 without any unit shift. The total byte length of the affected region is block_count * 128. Must be non-zero; the apply layer’s write_empty_block helper returns an error for block_count == 0.

Followed by 4 bytes of reserved padding (pad_after = 4) in the wire format.

Trait Implementations

impl BinRead for SqpkExpandData

type Args<'__binrw_generated_args_lifetime> = ()

The type used for the args parameter of read_args() and read_options().

fn read_options<R: Read + Seek>( __binrw_generated_var_reader: &mut R, __binrw_generated_var_endian: Endian, __binrw_generated_var_arguments: Self::Args<'_>, ) -> BinResult<Self>

Read Self from the reader using the given Endian and arguments.

fn read<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self: ReadEndian, Self::Args<'a>: for<'a> Required,

Read Self from the reader using default arguments.

fn read_be<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read Self from the reader using default arguments and assuming big-endian byte order.

fn read_le<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read Self from the reader using default arguments and assuming little-endian byte order.

fn read_ne<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read T from the reader assuming native-endian byte order.

fn read_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek, Self: ReadEndian,

Read Self from the reader using the given arguments.

fn read_be_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read Self from the reader, assuming big-endian byte order, using the given arguments.

fn read_le_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read Self from the reader, assuming little-endian byte order, using the given arguments.

fn read_ne_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read T from the reader, assuming native-endian byte order, using the given arguments.

impl Clone for SqpkExpandData

fn clone(&self) -> SqpkExpandData

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SqpkExpandData

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

Formats the value using the given formatter.

impl PartialEq for SqpkExpandData

fn eq(&self, other: &SqpkExpandData) -> 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 ReadEndian for SqpkExpandData

const ENDIAN: EndianKind

The endianness of the type.

impl Eq for SqpkExpandData

impl StructuralPartialEq for SqpkExpandData