Struct stdf::records::MIR

pub struct MIR<'a> {

    pub setup_t: U4,
    pub start_t: U4,
    pub stat_num: U1,
    pub mode_cod: C1,
    pub rtst_cod: C1,
    pub prot_cod: C1,
    pub burn_tim: U2,
    pub cmod_cod: C1,
    pub lot_id: Cn<'a>,
    pub part_typ: Cn<'a>,
    pub node_nam: Cn<'a>,
    pub tstr_typ: Cn<'a>,
    pub job_nam: Cn<'a>,
    pub job_rev: Cn<'a>,
    pub sblot_id: Cn<'a>,
    pub oper_nam: Cn<'a>,
    pub exec_typ: Cn<'a>,
    pub exec_ver: Cn<'a>,
    pub test_cod: Cn<'a>,
    pub tst_temp: Cn<'a>,
    pub user_txt: Cn<'a>,
    pub aux_file: Cn<'a>,
    pub pkg_typ: Cn<'a>,
    pub famly_id: Cn<'a>,
    pub date_cod: Cn<'a>,
    pub facil_id: Cn<'a>,
    pub floor_id: Cn<'a>,
    pub proc_id: Cn<'a>,
    pub oper_frq: Cn<'a>,
    pub spec_nam: Cn<'a>,
    pub spec_ver: Cn<'a>,
    pub flow_id: Cn<'a>,
    pub setup_id: Cn<'a>,
    pub dsgn_rev: Cn<'a>,
    pub eng_id: Cn<'a>,
    pub rom_cod: Cn<'a>,
    pub serl_num: Cn<'a>,
    pub supr_nam: Cn<'a>,
}

Fields

setup_t: U4

start_t: U4

stat_num: U1

mode_cod: C1

rtst_cod: C1

prot_cod: C1

burn_tim: U2

cmod_cod: C1

lot_id: Cn<'a>

part_typ: Cn<'a>

node_nam: Cn<'a>

tstr_typ: Cn<'a>

job_nam: Cn<'a>

job_rev: Cn<'a>

sblot_id: Cn<'a>

oper_nam: Cn<'a>

exec_typ: Cn<'a>

exec_ver: Cn<'a>

test_cod: Cn<'a>

tst_temp: Cn<'a>

user_txt: Cn<'a>

aux_file: Cn<'a>

pkg_typ: Cn<'a>

famly_id: Cn<'a>

date_cod: Cn<'a>

facil_id: Cn<'a>

floor_id: Cn<'a>

proc_id: Cn<'a>

oper_frq: Cn<'a>

spec_nam: Cn<'a>

spec_ver: Cn<'a>

flow_id: Cn<'a>

setup_id: Cn<'a>

dsgn_rev: Cn<'a>

eng_id: Cn<'a>

rom_cod: Cn<'a>

serl_num: Cn<'a>

supr_nam: Cn<'a>

Trait Implementations

impl<'a> Debug for MIR<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq<MIR<'a>> for MIR<'a>

fn eq(&self, other: &MIR<'a>) -> 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<'a> TryRead<'a, Endian> for MIR<'a>

fn try_read(bytes: &'a [u8], endian: Endian) -> Result<(Self, usize)>

Try to read from bytes using context.

impl<'a> TryWrite<Endian> for MIR<'a>

fn try_write(self, bytes: &mut [u8], endian: Endian) -> Result<usize>

Try to write to bytes using context.

impl<'a> Eq for MIR<'a>

impl<'a> StructuralEq for MIR<'a>

impl<'a> StructuralPartialEq for MIR<'a>