Enum aml::value::AmlValue

pub enum AmlValue {
    Boolean(bool),
    Integer(u64),
    String(String),
    OpRegion {
        region: RegionSpace,
        offset: u64,
        length: u64,
        parent_device: Option<AmlName>,
    },
    Field {
        region: AmlHandle,
        flags: FieldFlags,
        offset: u64,
        length: u64,
    },
    Method {
        flags: MethodFlags,
        code: MethodCode,
    },
    Buffer(Vec<u8>),
    Processor {
        id: u8,
        pblk_address: u32,
        pblk_len: u8,
    },
    Mutex {
        sync_level: u8,
    },
    Package(Vec<AmlValue>),
}

Variants

Boolean(bool)

Integer(u64)

String(String)

OpRegion

Describes an operation region. Some regions require other objects to be declared under their parent device (e.g. an _ADR object for a PciConfig region), in which case an absolute path to the object is stored in parent_device.

Fields of OpRegion

region: RegionSpaceoffset: u64length: u64parent_device: Option<AmlName>

Field

Describes a field unit within an operation region.

Fields of Field

region: AmlHandleflags: FieldFlagsoffset: u64length: u64

Method

Fields of Method

flags: MethodFlagscode: MethodCode

Buffer(Vec<u8>)

Processor

Fields of Processor

id: u8pblk_address: u32pblk_len: u8

Mutex

Fields of Mutex

sync_level: u8

Package(Vec<AmlValue>)

Implementations

impl AmlValue

pub fn zero() -> AmlValue

pub fn one() -> AmlValue

pub fn ones() -> AmlValue

pub fn native_method<F>(
    arg_count: u8,
    serialize: bool,
    sync_level: u8,
    f: F
) -> AmlValue where
    F: Fn(&mut AmlContext) -> Result<AmlValue, AmlError> + 'static, 

pub fn type_of(&self) -> AmlType

pub fn as_bool(&self) -> Result<bool, AmlError>

pub fn as_integer(&self, context: &AmlContext) -> Result<u64, AmlError>

pub fn as_buffer(&self, context: &AmlContext) -> Result<Vec<u8>, AmlError>

pub fn as_string(&self, context: &AmlContext) -> Result<String, AmlError>

pub fn as_status(&self) -> Result<StatusObject, AmlError>

Turns an AmlValue returned from a _STA method into a StatusObject. Should only be called for values returned from _STA. If you need a StatusObject, but the device does not have a _STA method, use StatusObject::default().

pub fn as_type(
    &self,
    desired_type: AmlType,
    context: &AmlContext
) -> Result<AmlValue, AmlError>

Convert this value to a value of the same data, but with the given AML type, if possible, by converting the implicit conversions described in §19.3.5 of the spec.

The implicit conversions applied are: Buffer from: Integer, String, Debug BufferField from: Integer, Buffer, String, Debug DdbHandle from: Integer, Debug FieldUnit from: Integer,Buffer, String, Debug Integer from: Buffer, BufferField, DdbHandle, FieldUnit, String, Debug Package from: Debug String from: Integer, Buffer, Debug

pub fn read_field(&self, context: &AmlContext) -> Result<AmlValue, AmlError>

Reads from a field of an opregion, returning either a AmlValue::Integer or an AmlValue::Buffer, depending on the size of the field.

pub fn write_field(
    &mut self,
    value: AmlValue,
    context: &mut AmlContext
) -> Result<(), AmlError>

pub fn cmp(
    &self,
    other: AmlValue,
    context: &mut AmlContext
) -> Result<Ordering, AmlError>

Logically compare two AmlValues, according to the rules that govern opcodes like DefLEqual, DefLLess, etc. The type of self dictates the type that other will be converted to, and the method by which the values will be compared:

• Integers are simply compared by numeric comparison
• Strings and Buffers are compared lexicographically - other is compared byte-wise until a byte is discovered that is either less or greater than the corresponding byte of self. If the bytes are identical, the lengths are compared. Luckily, the Rust standard library implements lexicographic comparison of strings and [u8] for us already.

Trait Implementations

impl Clone for AmlValue

fn clone(&self) -> AmlValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AmlValue

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

Formats the value using the given formatter.