Struct ssbh_lib::SsbhArray

pub struct SsbhArray<T> {
    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 binrw::BinRead;
use ssbh_lib::{SsbhArray, Matrix4x4};
use ssbh_write::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 binrw::BinRead;
use ssbh_lib::{SsbhArray, Matrix4x4};
use ssbh_write::SsbhWrite;

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

Fields

elements: Vec<T>

Implementations

impl<T> SsbhArray<T>

pub fn new() -> Self

Creates an empty array.

let array: SsbhArray<u32> = SsbhArray::new();
assert!(array.elements.is_empty());

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

Creates a new array from elements.

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

Trait Implementations

impl<T> BinRead for SsbhArray<T>

where T: BinRead, for<'a> T::Args<'a>: Clone + Default,

type Args<'a> = <T as BinRead>::Args<'a>

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

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.

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_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<T: Clone> Clone for SsbhArray<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for SsbhArray<T>

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

Formats the value using the given formatter.

impl<T> Default for SsbhArray<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<Vec<T>> for SsbhArray<T>

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

Converts to this type from the input type.

impl<T> FromIterator<T> for SsbhArray<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: PartialEq> PartialEq for SsbhArray<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: SsbhWrite> 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. data_ptr is assumed to be the absolute offset where the next data stored behind an offset will be written. Struct that contains no offsets as fields can skip updating data_ptr.

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.

fn alignment_in_bytes() -> u64

The alignment for pointers of this type, which is useful for offset calculations.

fn write<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek,

Writes the byte representation of self to writer. This is a convenience method for ssbh_write that handles initializing the data pointer.

impl<T: Eq> Eq for SsbhArray<T>