refactor(header): unpack GlobalModuleReference in header

librasn · Mar 22, 2024 · 04df8f4 · 04df8f4
1 parent 1a5d9f9
commit 04df8f4
Show file tree

Hide file tree

Showing 6 changed files with 286 additions and 100 deletions.
diff --git a/rasn-compiler-tests/tests/structured_types.rs b/rasn-compiler-tests/tests/structured_types.rs
@@ -58,4 +58,4 @@ e2e_pdu!(
         fn personnel_record_children_default () -> SequenceOf<VisibleString> {
             alloc::vec![]
         }                          "#
-);
+);
diff --git a/rasn-compiler/src/generator/rasn/builder.rs b/rasn-compiler/src/generator/rasn/builder.rs
@@ -32,7 +32,7 @@ impl Backend for Rust {
         if let Some((module_ref, _)) = tlds.first().and_then(|tld| tld.get_index().cloned()) {
             let name = to_rust_snake_case(&module_ref.name);
             let imports = module_ref.imports.iter().map(|import| {
-                let module = to_rust_snake_case(&import.origin_name);
+                let module = to_rust_snake_case(&import.global_module_reference.module_reference);
                 let mut usages = Some(vec![]);
                 'imports: for usage in &import.types {
                     if usage.contains("{}") || usage.chars().all(|c| c.is_uppercase() || c == '-') {

diff --git a/rasn-compiler/src/generator/rasn/utils.rs b/rasn-compiler/src/generator/rasn/utils.rs
@@ -506,8 +506,14 @@ pub fn type_to_tokens(ty: &ASN1Type) -> Result<TokenStream, GeneratorError> {
             "Set values are currently unsupported!"
         )),
         ASN1Type::ElsewhereDeclaredType(e) => Ok(to_rust_title_case(&e.identifier)),
-        ASN1Type::InformationObjectFieldReference(_) => todo!(),
-        ASN1Type::Time(_) => todo!(),
+        ASN1Type::InformationObjectFieldReference(_) => Err(error!(
+            NotYetInplemented,
+            "Information Object field reference values are currently unsupported!"
+        )),
+        ASN1Type::Time(_) => Err(error!(
+            NotYetInplemented,
+            "Time values are currently unsupported!"
+        )),
         ASN1Type::GeneralizedTime(_) => Ok(quote!(GeneralizedTime)),
         ASN1Type::UTCTime(_) => Ok(quote!(UtcTime)),
         ASN1Type::EmbeddedPdv | ASN1Type::External => Ok(quote!(Any)),

diff --git a/rasn-compiler/src/intermediate/mod.rs b/rasn-compiler/src/intermediate/mod.rs
@@ -272,33 +272,60 @@ pub enum With {
     Descendants,
 }
 
+/// Represents a global module reference as specified in
+/// Rec. ITU-T X.680 (02/2021)
+#[derive(Debug, Clone, PartialEq)]
+pub struct ExternalValueReference {
+    pub module_reference: String,
+    pub value_reference: String,
+}
+
+/// Represents a global module reference as specified in
+/// Rec. ITU-T X.680 (02/2021)
+#[derive(Debug, Clone, PartialEq)]
+pub struct GlobalModuleReference {
+    pub module_reference: String,
+    pub assigned_identifier: AssignedIdentifier,
+}
+
+impl From<(&str, AssignedIdentifier)> for GlobalModuleReference {
+    fn from(value: (&str, AssignedIdentifier)) -> Self {
+        Self {
+            module_reference: value.0.to_owned(),
+            assigned_identifier: value.1,
+        }
+    }
+}
+
+/// Represents an assigned identifier as specified in
+/// Rec. ITU-T X.680 (02/2021)
+#[derive(Debug, Clone, PartialEq)]
+pub enum AssignedIdentifier {
+    ObjectIdentifierValue(ObjectIdentifierValue),
+    ExternalValueReference(ExternalValueReference),
+    ValueReference(String),
+    ParameterizedValue {
+        value_reference: String,
+        actual_parameter_list: String,
+    },
+    Empty,
+}
+
 /// Represents a module import as specified in
 /// Rec. ITU-T X.680 (02/2021) § 13.16
 #[derive(Debug, Clone, PartialEq)]
 pub struct Import {
     pub types: Vec<String>,
-    pub origin_name: String,
-    pub origin_identifier: Option<ObjectIdentifierValue>,
+    pub global_module_reference: GlobalModuleReference,
     pub with: Option<With>,
 }
 
-impl
-    From<(
-        Vec<&str>,
-        (&str, Option<ObjectIdentifierValue>, Option<&str>),
-    )> for Import
-{
-    fn from(
-        value: (
-            Vec<&str>,
-            (&str, Option<ObjectIdentifierValue>, Option<&str>),
-        ),
-    ) -> Self {
+impl From<(Vec<&str>, (GlobalModuleReference, Option<&str>))> for Import {
+    fn from(value: (Vec<&str>, (GlobalModuleReference, Option<&str>))) -> Self {
         Self {
             types: value.0.into_iter().map(String::from).collect(),
-            origin_name: value.1 .0.into(),
-            origin_identifier: value.1 .1,
-            with: value.1 .2.map(|with| {
+            global_module_reference: value.1 .0,
+            with: value.1 .1.map(|with| {
                 if with == WITH_SUCCESSORS {
                     With::Successors
                 } else {