Struct MPR

pub struct MPR<'a> {

    pub test_num: U4,
    pub head_num: U1,
    pub site_num: U1,
    pub test_flg: B1,
    pub parm_flg: B1,
    pub rtn_icnt: U2,
    pub rslt_cnt: U2,
    pub rtn_stat: Vec<N1>,
    pub rtn_rslt: Vec<R4>,
    pub test_txt: Cn<'a>,
    pub alarm_id: Cn<'a>,
    pub opt_flag: B1,
    pub res_scal: I1,
    pub llm_scal: I1,
    pub hlm_scal: I1,
    pub lo_limit: R4,
    pub hi_limit: R4,
    pub start_in: R4,
    pub incr_in: R4,
    pub rtn_indx: Vec<U2>,
    pub units: Cn<'a>,
    pub units_in: Cn<'a>,
    pub c_resfmt: Cn<'a>,
    pub c_llmfmt: Cn<'a>,
    pub c_hlmfmt: Cn<'a>,
    pub lo_spec: R4,
    pub hi_spec: R4,
}

Fields

test_num: U4

head_num: U1

site_num: U1

test_flg: B1

parm_flg: B1

rtn_icnt: U2

rslt_cnt: U2

rtn_stat: Vec<N1>

rtn_rslt: Vec<R4>

test_txt: Cn<'a>

alarm_id: Cn<'a>

opt_flag: B1

res_scal: I1

llm_scal: I1

hlm_scal: I1

lo_limit: R4

hi_limit: R4

start_in: R4

incr_in: R4

rtn_indx: Vec<U2>

units: Cn<'a>

units_in: Cn<'a>

c_resfmt: Cn<'a>

c_llmfmt: Cn<'a>

c_hlmfmt: Cn<'a>

lo_spec: R4

hi_spec: R4

Trait Implementations

impl<'a> Debug for MPR<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for MPR<'a>

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

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

Try to read from bytes using context.

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

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

Try to write to bytes using context.

impl<'a> StructuralPartialEq for MPR<'a>