Enum ToplevelDefinition

pub enum ToplevelDefinition {
    Type(ToplevelTypeDefinition),
    Value(ToplevelValueDefinition),
    Information(ToplevelInformationDefinition),
}

Represents a top-level ASN.1 definition. The compiler distinguished three different variants of top-level definitions.

• Type definitions define custom types based on ASN.1’s built-in types
• Value definitions define values using custom ot built-in types
• Information definitions define abstraction concepts introduced in ITU-T X.681

The linker and any [Backend] for this compiler consumes top-level definitions in order to generate bindings.

Variants

Type(ToplevelTypeDefinition)

Value(ToplevelValueDefinition)

Information(ToplevelInformationDefinition)

Implementations

impl ToplevelDefinition

pub fn name(&self) -> &String

Returns the name of a top-level definition.

Example

assert_eq!(
    ToplevelDefinition::Value(
        ToplevelValueDefinition {
            comments: String::from("Comments from the ASN.1 spec"),
            parameterization: None,
            name: String::from("the-answer"),
            associated_type: ASN1Type::Integer(Integer {
                constraints: vec![],
                distinguished_values: None,
            }),
            value: ASN1Value::Integer(42),
            index: None,
        }
    ).name(),
    &String::from("the-answer")
);

impl ToplevelDefinition

pub fn is_class_with_name( &self, name: &String, ) -> Option<&InformationObjectClass>

pub fn has_constraint_reference(&self) -> bool

Traverses a top-level declaration to check for references to other top-level declarations in a constraint. An example would be the constraint of the intercontinental field in the following example.

fifteen INTEGER = 15

Departures ::= SEQUENCE {
  local SEQUENCE (SIZE(0..999)) OF Local,
  continental SEQUENCE (SIZE(0..99)) OF Continental,
  intercontinental SEQUENCE (SIZE(0..fifteen)) OF Intercontinental
}

pub fn link_constraint_reference( &mut self, tlds: &BTreeMap<String, ToplevelDefinition>, ) -> Result<bool, GrammarError>

Traverses a top-level declaration to replace references to other top-level declarations in a constraint. An example would be the constraint of the intercontinental field in the following example.

fifteen INTEGER = 15

Departures ::= SEQUENCE {
  local SEQUENCE (SIZE(0..999)) OF Local,
  continental SEQUENCE (SIZE(0..99)) OF Continental,
  intercontinental SEQUENCE (SIZE(0..fifteen)) OF Intercontinental
}

The method handles linking of multiple constraint references within a top-level declaration.

Parameterization

This linking step also resolves implementations of parameterized types. The compiler does not create representations of abstract parameterized types but only of actual implementations. For example, no rust output will be generated for

ParamType { INTEGER: lower, BOOLEAN: flag } ::= SEQUENCE {
    int-value INTEGER (lower..12),
    bool-value BOOLEAN DEFAULT flag
}

but an implementing type such as

ImplType ::= ParamType { 2, TRUE }

will be represented in the generated rust bindings.

Params

• tlds - vector of other top-level declarations that will be searched as the method resolves a reference returns true if the reference was resolved successfully.

pub fn mark_recursive(&mut self) -> Result<(), GrammarError>

Traverses top-level declarations and marks recursive types

pub fn collect_supertypes( &mut self, tlds: &BTreeMap<String, ToplevelDefinition>, ) -> Result<(), GrammarError>

Collects supertypes of ASN1 values.

Trait Implementations

impl Clone for ToplevelDefinition

fn clone(&self) -> ToplevelDefinition

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ToplevelDefinition

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

Formats the value using the given formatter.

impl PartialEq for ToplevelDefinition

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