Struct ssbh_lib::SsbhEnum64

pub struct SsbhEnum64<T: BinRead<Args = (u64,)> + SsbhWrite> {
    pub data: RelPtr64<T>,
    pub data_type: u64,
}

Parses a struct with a relative offset to a structure of type T with some data type. Parsing will fail if there is no matching variant for data_type.

use binread::BinRead;

#[derive(BinRead)]
struct EnumData {
    data_relative_offset: u64,
    data_type: u64
}

This can instead be expressed as the following struct. The T type should have line to specify that it takes the data type as an argument. data_type is automatically passed as an argument when reading T.

use binread::BinRead;
use ssbh_lib::SsbhEnum64;
use ssbh_lib::SsbhWrite;

impl SsbhWrite for Data {
    fn write_ssbh<W: std::io::Write + std::io::Seek>(
        &self,
        writer: &mut W,
        data_ptr: &mut u64,
    ) -> std::io::Result<()> {
        match self {
            Data::Float(f) => f.write_ssbh(writer, data_ptr),
            Data::Boolean(b) => b.write_ssbh(writer, data_ptr),
        }
    }

    fn size_in_bytes(&self) -> u64 {
        16
    }
}

#[derive(BinRead)]
#[br(import(data_type: u64))]
pub enum Data {
    #[br(pre_assert(data_type == 01u64))]
    Float(f32),
    #[br(pre_assert(data_type == 02u64))]
    Boolean(u32),
    // Add additional variants as needed.
}

#[derive(BinRead)]
pub struct EnumData {
    data: SsbhEnum64<Data>,
}

Fields

data: RelPtr64<T>

data_type: u64

Trait Implementations

impl<T> BinRead for SsbhEnum64<T> where
    T: BinRead<Args = (u64,)> + SsbhWrite, 

type Args = ()

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: Self::Args
) -> 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<Args = (u64,)> + SsbhWrite> Debug for SsbhEnum64<T>

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

Formats the value using the given formatter.

impl<'de, T: BinRead<Args = (u64,)> + SsbhWrite> Deserialize<'de> for SsbhEnum64<T> where
    T: Deserialize<'de>, 

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

Deserialize this value from the given Serde deserializer.

impl<T: BinRead<Args = (u64,)> + SsbhWrite> Serialize for SsbhEnum64<T> where
    T: 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<Args = (u64,)> + SsbhWrite> SsbhWrite for SsbhEnum64<T>

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

fn size_in_bytes(&self) -> u64

fn alignment_in_bytes(&self) -> u64