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,
    },
    Device,
    Method {
        flags: MethodFlags,
        code: MethodCode,
    },
    Buffer(Arc<Spinlock<Vec<u8>>>),
    BufferField {
        buffer_data: Arc<Spinlock<Vec<u8>>>,
        offset: u64,
        length: u64,
    },
    Processor {
        id: u8,
        pblk_address: u32,
        pblk_len: u8,
    },
    Mutex {
        sync_level: u8,
    },
    Package(Vec<AmlValue>),
    PowerResource {
        system_level: u8,
        resource_order: u16,
    },
    ThermalZone,
}

Variants

Boolean

Tuple Fields of Boolean

0: bool

Integer

Tuple Fields of Integer

0: u64

String

Tuple Fields of String

0: 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

Device

Method

Fields of Method

flags: MethodFlagscode: MethodCode

Buffer

Tuple Fields of Buffer

0: Arc<Spinlock<Vec<u8>>>

BufferField

Fields of BufferField

buffer_data: Arc<Spinlock<Vec<u8>>>offset: u64

In bits.

length: u64

In bits.

Processor

Fields of Processor

id: u8pblk_address: u32pblk_len: u8

Mutex

Fields of Mutex

sync_level: u8

Package

Tuple Fields of Package

0: Vec<AmlValue>

PowerResource

Fields of PowerResource

system_level: u8resource_order: u16

ThermalZone

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 + Send + Sync, 

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<Arc<Spinlock<Vec<u8>>>, AmlError>

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

pub fn as_concat_type(&self) -> AmlValue

Converts an AmlValue to the representation that should be used when concatenating it with other values, primarily by the DefConcat opcode. This will always produce a AmlValue::Integer, AmlValue::String, or AmlValue::Buffer, with other types being converted to strings containing the name of their type.

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 read_buffer_field(
    &self,
    context: &AmlContext
) -> Result<AmlValue, AmlError>

pub fn write_buffer_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.

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.