Enum RawRecord 

pub enum RawRecord {
    AACT(AACT),
    ACHR(ACHR),
    ACTI(ACTI),
    ADDN(ADDN),
    ALCH(ALCH),
    AMMO(AMMO),
    ANIO(ANIO),
    APPA(APPA),
    ARMA(ARMA),
    ARMO(ARMO),
    ARTO(ARTO),
    ASPC(ASPC),
    ASTP(ASTP),
    AVIF(AVIF),
    BOOK(BOOK),
    BPTD(BPTD),
    CAMS(CAMS),
    CELL(CELL),
    CLAS(CLAS),
    CLFM(CLFM),
    CLMT(CLMT),
    COBJ(COBJ),
    COLL(COLL),
    CONT(CONT),
    CPTH(CPTH),
    CSTY(CSTY),
    DEBR(DEBR),
    DIAL(DIAL),
    DLBR(DLBR),
    DLVW(DLVW),
    DOBJ(DOBJ),
    DOOR(DOOR),
    DUAL(DUAL),
    ECZN(ECZN),
    EFSH(EFSH),
    ENCH(ENCH),
    EQUP(EQUP),
    EXPL(EXPL),
    EYES(EYES),
    FACT(FACT),
    FLOR(FLOR),
    FLST(FLST),
    FSTP(FSTP),
    FSTS(FSTS),
    FURN(FURN),
    GLOB(GLOB),
    GMST(GMST),
    GRAS(GRAS),
    GRUP(GRUP),
    HAZD(HAZD),
    HDPT(HDPT),
    IDLE(IDLE),
    IDLM(IDLM),
    IMAD(IMAD),
    IMGS(IMGS),
    INFO(INFO),
    INGR(INGR),
    IPCT(IPCT),
    IPDS(IPDS),
    KEYM(KEYM),
    KYWD(KYWD),
    LAND(LAND),
    LCRT(LCRT),
    LCTN(LCTN),
    LGTM(LGTM),
    LIGH(LIGH),
    LSCR(LSCR),
    LTEX(LTEX),
    LVLI(LVLI),
    LVLN(LVLN),
    LVSP(LVSP),
    MATO(MATO),
    MATT(MATT),
    MESG(MESG),
    MGEF(MGEF),
    MISC(MISC),
    MOVT(MOVT),
    MSTT(MSTT),
    MUSC(MUSC),
    MUST(MUST),
    NAVI(NAVI),
    NAVM(NAVM),
    NOTE(NOTE),
    NPC_(NPC_),
    OTFT(OTFT),
    PACK(PACK),
    PERK(PERK),
    PGRE(PGRE),
    PHZD(PHZD),
    PROJ(PROJ),
    QUST(QUST),
    RACE(RACE),
    REFR(REFR),
    REGN(REGN),
    RELA(RELA),
    REVB(REVB),
    RFCT(RFCT),
    SCEN(SCEN),
    SCRL(SCRL),
    SHOU(SHOU),
    SLGM(SLGM),
    SMBN(SMBN),
    SMEN(SMEN),
    SMQN(SMQN),
    SNCT(SNCT),
    SNDR(SNDR),
    SOPM(SOPM),
    SOUN(SOUN),
    SPEL(SPEL),
    SPGD(SPGD),
    STAT(STAT),
    TACT(TACT),
    TREE(TREE),
    TXST(TXST),
    VTYP(VTYP),
    WATR(WATR),
    WEAP(WEAP),
    WOOP(WOOP),
    WRLD(WRLD),
    WTHR(WTHR),
}

Variants

AACT(AACT)

ACHR(ACHR)

ACTI(ACTI)

ADDN(ADDN)

ALCH(ALCH)

AMMO(AMMO)

ANIO(ANIO)

APPA(APPA)

ARMA(ARMA)

ARMO(ARMO)

ARTO(ARTO)

ASPC(ASPC)

ASTP(ASTP)

AVIF(AVIF)

BOOK(BOOK)

BPTD(BPTD)

CAMS(CAMS)

CELL(CELL)

CLAS(CLAS)

CLFM(CLFM)

CLMT(CLMT)

COBJ(COBJ)

COLL(COLL)

CONT(CONT)

CPTH(CPTH)

CSTY(CSTY)

DEBR(DEBR)

DIAL(DIAL)

DLBR(DLBR)

DLVW(DLVW)

DOBJ(DOBJ)

DOOR(DOOR)

DUAL(DUAL)

ECZN(ECZN)

EFSH(EFSH)

ENCH(ENCH)

EQUP(EQUP)

EXPL(EXPL)

EYES(EYES)

FACT(FACT)

FLOR(FLOR)

FLST(FLST)

FSTP(FSTP)

FSTS(FSTS)

FURN(FURN)

GLOB(GLOB)

GMST(GMST)

GRAS(GRAS)

GRUP(GRUP)

HAZD(HAZD)

HDPT(HDPT)

IDLE(IDLE)

IDLM(IDLM)

IMAD(IMAD)

IMGS(IMGS)

INFO(INFO)

INGR(INGR)

IPCT(IPCT)

IPDS(IPDS)

KEYM(KEYM)

KYWD(KYWD)

LAND(LAND)

LCRT(LCRT)

LCTN(LCTN)

LGTM(LGTM)

LIGH(LIGH)

LSCR(LSCR)

LTEX(LTEX)

LVLI(LVLI)

LVLN(LVLN)

LVSP(LVSP)

MATO(MATO)

MATT(MATT)

MESG(MESG)

MGEF(MGEF)

MISC(MISC)

MOVT(MOVT)

MSTT(MSTT)

MUSC(MUSC)

MUST(MUST)

NAVI(NAVI)

NAVM(NAVM)

NOTE(NOTE)

NPC_(NPC_)

OTFT(OTFT)

PACK(PACK)

PERK(PERK)

PGRE(PGRE)

PHZD(PHZD)

PROJ(PROJ)

QUST(QUST)

RACE(RACE)

REFR(REFR)

REGN(REGN)

RELA(RELA)

REVB(REVB)

RFCT(RFCT)

SCEN(SCEN)

SCRL(SCRL)

SHOU(SHOU)

SLGM(SLGM)

SMBN(SMBN)

SMEN(SMEN)

SMQN(SMQN)

SNCT(SNCT)

SNDR(SNDR)

SOPM(SOPM)

SOUN(SOUN)

SPEL(SPEL)

SPGD(SPGD)

STAT(STAT)

TACT(TACT)

TREE(TREE)

TXST(TXST)

VTYP(VTYP)

WATR(WATR)

WEAP(WEAP)

WOOP(WOOP)

WRLD(WRLD)

WTHR(WTHR)

Trait Implementations

impl BinRead for RawRecord

type Args<'__binrw_generated_args_lifetime> = (bool,)

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.

fn after_parse<R>( &mut self, _: &mut R, _: Endian, _: Self::Args<'_>, ) -> Result<(), Error>

where R: Read + Seek,

Runs any post-processing steps required to finalize construction of the object.

impl BinWrite for RawRecord

type Args<'__binrw_generated_args_lifetime> = ()

The type used for the args parameter of write_args() and write_options().

fn write_options<W: Write + Seek>( &self, __binrw_generated_var_writer: &mut W, __binrw_generated_var_endian: Endian, __binrw_generated_var_arguments: Self::Args<'_>, ) -> BinResult<()>

Write Self to the writer using the given Endian and arguments.

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

where W: Write + Seek, Self: WriteEndian, Self::Args<'a>: for<'a> Required,

Write Self to the writer using default arguments.

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

where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming big-endian byte order.

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

where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming little-endian byte order.

fn write_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek, Self: WriteEndian,

Write Self to the writer using the given arguments.

fn write_be_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek,

Write Self to the writer, assuming big-endian byte order, using the given arguments.

fn write_le_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek,

Write Self to the writer, assuming little-endian byte order, using the given arguments.

impl Clone for RawRecord

fn clone(&self) -> RawRecord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RawRecord

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RawRecord

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ReadEndian for RawRecord

const ENDIAN: EndianKind

The endianness of the type.

impl Serialize for RawRecord

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<RawRecord> for Record

type Error = Error

The type returned in the event of a conversion error.

fn try_from(r: RawRecord) -> Result<Self, Self::Error>

Performs the conversion.

impl WriteEndian for RawRecord

const ENDIAN: EndianKind

The endianness of the type.