Enum Addressing 

pub enum Addressing {
    Sum {
        terms: Vec<AddressTerm>,
        len: u32,
    },
    BySelector {
        selector: String,
        map: Vec<(String, (u64, u32))>,
    },
}

Register addressing metadata for a node.

Variants

Sum

Register address is the sum of every declared address term.

This is the GenICam register address model: <Address>, <pAddress> and <pIndex> may each appear any number of times on one register and all of them add up. A node such as

<IntReg Name="SerialPortSource_Val">
  <pAddress>SerialPortSourceAddr</pAddress>
  <Address>0x00000008</Address>
</IntReg>

lives eight bytes past the block base, not at the base and not at offset eight. Keeping only one term reads the wrong register and says nothing about it — that was issue #35.

Fields

terms: Vec<AddressTerm>

Terms to add together, in declaration order.

len: u32

Length of the register block in bytes.

BySelector

Node switches between register blocks based on a selector value.

This is <Selected>/<pSelected>, which picks one block rather than contributing an offset, so it is not a term in the sum above.

Fields

selector: String

Name of the selector node controlling the address.

map: Vec<(String, (u64, u32))>

Mapping of selector value to (address, length) pair.

Implementations

impl Addressing

pub fn fixed(address: u64, len: u32) -> Self

A plain register at a literal address.

pub fn byte_len(&self) -> Option<u32>

Register block length in bytes, when it does not depend on a selector.

pub fn referenced_nodes(&self) -> Vec<&str>

Names of every node this addressing reads at resolution time.

Used to build the invalidation graph: when one of these changes, the address changes, so anything cached against it is stale.

Trait Implementations

impl Clone for Addressing

fn clone(&self) -> Addressing

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Addressing

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Addressing

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Addressing

fn eq(&self, other: &Addressing) -> 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 Serialize for Addressing

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Addressing

impl StructuralPartialEq for Addressing