Enum RecordHeader 

pub enum RecordHeader {
    Checksum,
    Filler(u16),
    MainHeader(u16),
    Text(u16),
    DescriptorType(u16),
    DescriptorData(u16),
    End,
    Unknown {
        id: u16,
        len: u16,
    },
}

Known Record Headers, based on the current knowledge.

Variants

Checksum

A one byte record that, if read, result in a 0 checksum.

Filler(u16)

A 0-0xFFFF record with nothing but zeros, usually lining the next record address.

MainHeader(u16)

Only two variations are known, a HWID and a PartNumber. Possibly describing the file format itself.

Text(u16)

Arbitrary data, usually containing valid ASCII text, mostly one line.

DescriptorType(u16)

Data information about the firmware, contains only the type.

This will be later combine with DescriptorData

DescriptorData(u16)

Data information about the firmware, contain only the data.

Need to be combined with DescriptorType to be interpreted.

End

Mark the end of the file. Can only be the last header.

Unknown

Header with Unknown ID, can be a Firmware block, if the ID is described on the Descriptor header, or Unknown/Undefined Record.

Fields

id: u16

len: u16

Implementations

impl RecordHeader

pub const fn id(&self) -> u16

Return the id from the Header

pub const fn len(&self) -> u16

Return the len from the Header, obs: not the len of the Header itself

pub const fn from_value(id: u16, len: u16) -> Self

Create a header using the id and len values.

pub fn from_raw<B: ByteOrder>(data: &[u8]) -> Result<(&[u8], Self)>

Create the Header using raw bytes

pub fn to_raw<'a, B: ByteOrder>( &self, data: &'a mut [u8], ) -> Result<&'a mut [u8]>

Write the Header to the raw byte buffer.

Trait Implementations

impl Clone for RecordHeader

fn clone(&self) -> RecordHeader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RecordHeader

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RecordHeader

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for RecordHeader

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RecordHeader

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for RecordHeader

impl Eq for RecordHeader

impl StructuralPartialEq for RecordHeader