Struct Variant 

pub struct Variant<'a> {

    pub variant_name: String,
    pub deprecated: Option<String>,
    pub description: Vec<String>,
    pub processor: Vec<Processor>,
    pub compile: Vec<Compile>,
    pub debug: Vec<FamilyDebug>,
    pub debugconfig: Option<DebugConfig>,
    pub debugport: Vec<DebugPort>,
    pub access_port_v1: Vec<AccessPortV1>,
    pub access_port_v2: Vec<AccessPortV2>,
    pub algorithm: Vec<Algorithm>,
    pub flashinfo_raw: Vec<RawNode<'a>>,
    pub flashinfo: Vec<FlashInfo>,
    pub memory: Vec<Memory>,
    pub trace: Vec<Trace>,
    pub book: Vec<Book>,
    pub feature: Vec<Feature>,
    pub environment: Vec<FamilyEnvironment>,
    pub debugvars_raw: Vec<RawNode<'a>>,
    pub debugvars: Debugvars,
    pub sequences_raw: Vec<RawNode<'a>>,
    pub sequences: Sequences<'a>,
}

Represents a PDSC variant element

Defines a named variant of a device, overriding or extending the parent device’s properties.

Fields

variant_name: String

Variant name

deprecated: Option<String>

Date this variant was deprecated (xs:date, e.g. 2020-01-01)

description: Vec<String>

Brief variant description (0..*)

processor: Vec<Processor>

Processor definitions (0..*)

compile: Vec<Compile>

Compile-time definitions (0..*)

debug: Vec<FamilyDebug>

Debug unit assignments (0..*)

debugconfig: Option<DebugConfig>

Debug configuration (0..1)

debugport: Vec<DebugPort>

Debug port definitions (0..*)

access_port_v1: Vec<AccessPortV1>

Access port v1 definitions (0..*)

access_port_v2: Vec<AccessPortV2>

Access port v2 definitions (0..*)

algorithm: Vec<Algorithm>

Flash programming algorithms (0..*)

flashinfo_raw: Vec<RawNode<'a>>

Raw <flashinfo> nodes; see FlashInfo’s TryFrom<Node> impl for why these are deferred.

flashinfo: Vec<FlashInfo>

Flash information (0..*), populated from Self::flashinfo_raw by parse_flashinfo

memory: Vec<Memory>

Memory regions (0..*)

trace: Vec<Trace>

Trace unit definitions (0..*)

book: Vec<Book>

Reference documentation (0..*)

feature: Vec<Feature>

Feature descriptors (0..*)

environment: Vec<FamilyEnvironment>

Tool environment entries (0..*)

debugvars_raw: Vec<RawNode<'a>>

Raw <debugvars> nodes; see merge_debugvars for why these are deferred.

debugvars: Debugvars

Variant-level debug variables (rare; most packs define these at family level), merged from Self::debugvars_raw by merge_debugvars

sequences_raw: Vec<RawNode<'a>>

Raw <sequences> nodes; see merge_sequences for why these are deferred.

sequences: Sequences<'a>

Variant-level debug sequences (rare; most packs define these at family level), merged from Self::sequences_raw by merge_sequences

Trait Implementations

impl<'a> Clone for Variant<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Variant<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Variant<'a>

fn default() -> Variant<'a>

Returns the “default value” for a type.

impl<'de: 'a, 'a> Deserialize<'de> for Variant<'a>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> Eq for Variant<'a>

impl<'a> PartialEq for Variant<'a>

fn eq(&self, other: &Variant<'a>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a> Serialize for Variant<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> StructuralPartialEq for Variant<'a>