Enum ComputationalData

pub enum ComputationalData<'a> {
    Byte(u8),
    Word(u16),
    DWord(u32),
    QWord(u64),
    String(&'a str),
    Zero,
    One,
    Ones,
    Revision,
    Buffer(Buffer<'a>),
}

Single value resolved at compile time.

Variants

Byte(u8)

Word(u16)

DWord(u32)

QWord(u64)

String(&'a str)

Zero

One

Ones

Revision

Buffer(Buffer<'a>)

Trait Implementations

impl<'a> Clone for ComputationalData<'a>

fn clone(&self) -> ComputationalData<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ComputationalData<'a>

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

Formats the value using the given formatter.

impl<'a> From<ComputationalData<'a>> for DataObject<'a>

fn from(d: ComputationalData<'a>) -> DataObject<'a>

Converts to this type from the input type.

impl<'a> From<ComputationalData<'a>> for DataRefObject<'a>

fn from(d: ComputationalData<'a>) -> DataRefObject<'a>

Converts to this type from the input type.

impl<'a> From<ComputationalData<'a>> for TermArg<'a>

fn from(d: ComputationalData<'a>) -> TermArg<'a>

Converts to this type from the input type.

impl<'a> Parse<'a> for ComputationalData<'a>

Grammar:

ComputationalData := ByteConst | WordConst | DWordConst | QWordConst | String |
                     ConstObj | RevisionOp | DefBuffer

ByteConst         := BytePrefix ByteData
BytePrefix        := 0x0A
WordConst         := WordPrefix WordData
WordPrefix        := 0x0B
DWordConst        := DWordPrefix DWordData
DWordPrefix       := 0x0C
QWordConst        := QWordPrefix QWordData
QWordPrefix       := 0x0E
String            := StringPrefix AsciiCharList NullChar
StringPrefix      := 0x0D

ConstObj          := ZeroOp | OneOp | OnesOp
ByteList          := Nothing | <ByteData ByteList>
ByteData          := 0x00 - 0xFF
WordData          := ByteData[0:7] ByteData[8:15]
    // 0x0000-0xFFFF
DWordData         := WordData[0:15] WordData[16:31]
    // 0x00000000-0xFFFFFFFF
QWordData         := DWordData[0:31] DWordData[32:63]
    // 0x0000000000000000-0xFFFFFFFFFFFFFFFF
AsciiCharList     := Nothing | <AsciiChar AsciiCharList>
AsciiChar         := 0x01 - 0x7F
NullChar          := 0x00
ZeroOp            := 0x00
OneOp             := 0x01
OnesOp            := 0xFF
RevisionOp        := ExtOpPrefix 0x30

fn parse<E: AMLParseError<'a>>( i: ParserState<'a>, ) -> AMLParseResult<'a, Self, E>

Try to parse an object of this type from the given input and state.

impl<'a> PartialEq for ComputationalData<'a>

fn eq(&self, other: &ComputationalData<'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> Eq for ComputationalData<'a>

impl<'a> StructuralPartialEq for ComputationalData<'a>