Struct ssbh_lib::SsbhArray

pub struct SsbhArray<T: BinRead> {
    pub elements: Vec<T>,
}

A fixed-size collection of contiguous elements consisting of a relative offset to the array elements and an element count.

use binread::BinRead;
use ssbh_lib::{SsbhArray, Matrix4x4};
use ssbh_lib::SsbhWrite;
use ssbh_write_derive::SsbhWrite;

#[derive(BinRead, SsbhWrite)]
struct Transforms {
    array_relative_offset: u64,
    array_item_count: u64
}

This can instead be expressed as the following struct with an explicit array item type. The generated parsing and exporting code will correctly read and write the array data from the appropriate offset.

use binread::BinRead;
use ssbh_lib::{SsbhArray, Matrix4x4, SsbhWrite};
use ssbh_write_derive::SsbhWrite;

#[derive(BinRead, SsbhWrite)]
struct Transforms {
    data: SsbhArray<Matrix4x4>,
}

Fields

elements: Vec<T>

Implementations

impl<T: BinRead> SsbhArray<T>

pub fn new(elements: Vec<T>) -> Self

Creates a new array from elements.

let array = SsbhArray::new(vec![0, 1, 2]);
assert_eq!(vec![0, 1, 2], array.elements);

Trait Implementations

impl<C: Copy + 'static, T: BinRead<Args = C>> BinRead for SsbhArray<T>

type Args = C

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,
    args: C
) -> BinResult<Self>

Read the type from the reader

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

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

fn read_args<R>(reader: &mut R, args: Self::Args) -> Result<Self, Error> where
    R: Read + Seek, 

Read the type from the reader using the specified arguments

fn after_parse<R>(
    &mut self,
    &mut R,
    &ReadOptions,
    Self::Args
) -> Result<(), Error> where
    R: Read + Seek, 

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<T: Debug + BinRead> Debug for SsbhArray<T>

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

Formats the value using the given formatter.

impl<'de, T: BinRead + Deserialize<'de>> Deserialize<'de> for SsbhArray<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: BinRead> From<Vec<T, Global>> for SsbhArray<T>

fn from(v: Vec<T>) -> Self

Performs the conversion.

impl<T> Serialize for SsbhArray<T> where
    T: BinRead + Serialize, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T: BinRead + SsbhWrite + Sized> SsbhWrite for SsbhArray<T>

fn ssbh_write<W: Write + Seek>(
    &self,
    writer: &mut W,
    data_ptr: &mut u64
) -> Result<()>

Writes the byte representation of self to writer and update data_ptr as needed to ensure the next relative offset is correctly calculated.

fn size_in_bytes(&self) -> u64

The offset in bytes between successive elements in an array of this type. This should include any alignment or padding. For most types, this is simply the value of std::mem::size_of.

fn alignment_in_bytes(&self) -> u64

The alignment of the relative_offset for types stored in a RelPtr64.