Enum aml::value::AmlValue[][src]

pub enum AmlValue {
    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,
    Processor {
        id: u8,
        pblk_address: u32,
        pblk_len: u8,
    Mutex {
        sync_level: u8,



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>

Describes a field unit within an operation region.

Fields of Field

region: AmlHandleflags: FieldFlagsoffset: u64length: u64

Fields of Method

flags: MethodFlagscode: MethodCode

Fields of Processor

id: u8pblk_address: u32pblk_len: u8

Fields of Mutex

sync_level: u8


impl AmlValue[src]

pub fn zero() -> AmlValue[src]

pub fn one() -> AmlValue[src]

pub fn ones() -> AmlValue[src]

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[src]

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

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

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

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

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

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(
    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>[src]

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(
    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[src]

impl Debug for AmlValue[src]

Auto Trait Implementations

impl !Send for AmlValue

impl !Sync for AmlValue

impl Unpin for AmlValue

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<T> ToOwned for T where
    T: Clone

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.