feat(parse): add proto::extensions::SimpleExtensionDeclaration parser

src/parse/proto/extensions/mod.rs

@@ -2,5 +2,7 @@
 
 //! Parsing of [proto::extensions] types.
 
+mod simple_extension_declaration;
 mod simple_extension_uri;
+
 pub use simple_extension_uri::SimpleExtensionUri;

src/parse/proto/extensions/simple_extension_declaration/extension_function.rs

@@ -0,0 +1,50 @@
+use super::simple_extension_declaration::SimpleExtensionDeclarationError;
+use crate::parse::{Anchor, Context, Parse};
+use crate::proto;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ExtensionFunction {
+    anchor: Anchor<Self>,
+    name: String,
+    extension_uri_reference: Anchor<Self>,
+}
+
+impl<C: Context> Parse<C> for proto::extensions::simple_extension_declaration::ExtensionFunction {
+    type Parsed = ExtensionFunction;
+    type Error = SimpleExtensionDeclarationError;
+
+    fn parse(self, _ctx: &mut C) -> Result<Self::Parsed, Self::Error> {
+        let proto::extensions::simple_extension_declaration::ExtensionFunction {
+            extension_uri_reference,
+            function_anchor,
+            name,
+        } = self;
+
+        // Construct the parsed ExtensionFunction
+        let extension_function = ExtensionFunction {
+            extension_uri_reference: Anchor::new(extension_uri_reference),
+            name,
+            anchor: Anchor::new(function_anchor),
+        };
+
+        Ok(extension_function)
+    }
+}
+
+impl From<ExtensionFunction>
+    for proto::extensions::simple_extension_declaration::ExtensionFunction
+{
+    fn from(value: ExtensionFunction) -> Self {
+        let ExtensionFunction {
+            anchor,
+            name,
+            extension_uri_reference,
+        } = value;
+
+        Self {
+            extension_uri_reference: extension_uri_reference.into_inner(),
+            function_anchor: anchor.into_inner(),
+            name: name,
+        }
+    }
+}

src/parse/proto/extensions/simple_extension_declaration/extension_type.rs

@@ -0,0 +1,49 @@
+use crate::parse::{Anchor, Context, Parse};
+use crate::proto;
+
+use super::simple_extension_declaration::SimpleExtensionDeclarationError;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ExtensionType {
+    anchor: Anchor<Self>,
+    name: String,
+    extension_uri_reference: Anchor<Self>,
+}
+
+impl<C: Context> Parse<C> for proto::extensions::simple_extension_declaration::ExtensionType {
+    type Parsed = ExtensionType;
+    type Error = SimpleExtensionDeclarationError;
+
+    fn parse(self, _ctx: &mut C) -> Result<Self::Parsed, Self::Error> {
+        let proto::extensions::simple_extension_declaration::ExtensionType {
+            extension_uri_reference,
+            type_anchor,
+            name,
+        } = self;
+
+        // Construct the parsed ExtensionType
+        let extension_type_variation = ExtensionType {
+            extension_uri_reference: Anchor::new(extension_uri_reference),
+            name,
+            anchor: Anchor::new(type_anchor),
+        };
+
+        Ok(extension_type_variation)
+    }
+}
+
+impl From<ExtensionType> for proto::extensions::simple_extension_declaration::ExtensionType {
+    fn from(value: ExtensionType) -> Self {
+        let ExtensionType {
+            anchor,
+            name,
+            extension_uri_reference,
+        } = value;
+
+        Self {
+            extension_uri_reference: extension_uri_reference.into_inner(),
+            type_anchor: anchor.into_inner(),
+            name: name,
+        }
+    }
+}

src/parse/proto/extensions/simple_extension_declaration/extension_type_variation.rs

@@ -0,0 +1,53 @@
+use crate::parse::{Anchor, Context, Parse};
+use crate::proto;
+
+use super::simple_extension_declaration::SimpleExtensionDeclarationError;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ExtensionTypeVariation {
+    anchor: Anchor<Self>,
+    name: String,
+    extension_uri_reference: Anchor<Self>,
+}
+
+impl<C: Context> Parse<C>
+    for proto::extensions::simple_extension_declaration::ExtensionTypeVariation
+{
+    type Parsed = ExtensionTypeVariation;
+    type Error = SimpleExtensionDeclarationError;
+
+    fn parse(self, _ctx: &mut C) -> Result<Self::Parsed, Self::Error> {
+        let proto::extensions::simple_extension_declaration::ExtensionTypeVariation {
+            extension_uri_reference,
+            type_variation_anchor,
+            name,
+        } = self;
+
+        // Construct the parsed ExtensionTypeVariation
+        let extension_type_variation = ExtensionTypeVariation {
+            extension_uri_reference: Anchor::new(extension_uri_reference),
+            name,
+            anchor: Anchor::new(type_variation_anchor),
+        };
+
+        Ok(extension_type_variation)
+    }
+}
+
+impl From<ExtensionTypeVariation>
+    for proto::extensions::simple_extension_declaration::ExtensionTypeVariation
+{
+    fn from(value: ExtensionTypeVariation) -> Self {
+        let ExtensionTypeVariation {
+            anchor,
+            name,
+            extension_uri_reference,
+        } = value;
+
+        Self {
+            extension_uri_reference: extension_uri_reference.into_inner(),
+            type_variation_anchor: anchor.into_inner(),
+            name: name,
+        }
+    }
+}

src/parse/proto/extensions/simple_extension_declaration/mapping_type.rs

@@ -0,0 +1,52 @@
+use crate::{
+    parse::{Context, Parse},
+    proto,
+};
+
+use super::{
+    extension_function, extension_type, extension_type_variation,
+    simple_extension_declaration::SimpleExtensionDeclarationError,
+};
+
+/// MappingType
+#[derive(Clone, Debug, PartialEq)]
+pub enum MappingType {
+    ExtensionType(extension_type::ExtensionType),
+    ExtensionTypeVariation(extension_type_variation::ExtensionTypeVariation),
+    ExtensionFunction(extension_function::ExtensionFunction),
+}
+
+impl<C: Context> Parse<C> for proto::extensions::simple_extension_declaration::MappingType {
+    type Parsed = MappingType;
+    type Error = SimpleExtensionDeclarationError;
+
+    fn parse(self, ctx: &mut C) -> Result<Self::Parsed, Self::Error> {
+        Ok(match self {
+            proto::extensions::simple_extension_declaration::MappingType::ExtensionFunction(inner) => MappingType::ExtensionFunction(inner.parse(ctx)?),
+            proto::extensions::simple_extension_declaration::MappingType::ExtensionType(inner) => MappingType::ExtensionType(inner.parse(ctx)?),
+            proto::extensions::simple_extension_declaration::MappingType::ExtensionTypeVariation(inner) => MappingType::ExtensionTypeVariation(inner.parse(ctx)?),
+        })
+    }
+}
+
+impl From<MappingType> for proto::extensions::simple_extension_declaration::MappingType {
+    fn from(value: MappingType) -> Self {
+        match value {
+            MappingType::ExtensionFunction(inner) => {
+                proto::extensions::simple_extension_declaration::MappingType::ExtensionFunction(
+                    inner.into(),
+                )
+            }
+            MappingType::ExtensionType(inner) => {
+                proto::extensions::simple_extension_declaration::MappingType::ExtensionType(
+                    inner.into(),
+                )
+            }
+            MappingType::ExtensionTypeVariation(inner) => {
+                proto::extensions::simple_extension_declaration::MappingType::ExtensionTypeVariation(
+                    inner.into(),
+                )
+            }
+        }
+    }
+}

src/parse/proto/extensions/simple_extension_declaration/mod.rs

@@ -0,0 +1,5 @@
+mod extension_function;
+mod extension_type;
+mod extension_type_variation;
+mod mapping_type;
+mod simple_extension_declaration;

src/parse/proto/extensions/simple_extension_declaration/simple_extension_declaration.rs

@@ -0,0 +1,41 @@
+use crate::{
+    parse::{Context, Parse},
+    proto,
+};
+use thiserror::Error;
+
+use super::mapping_type::MappingType;
+
+// SimpleExtensionDeclaration
+#[derive(Clone, Debug, PartialEq)]
+pub struct SimpleExtensionDeclaration {
+    pub mapping_type: Option<MappingType>,
+}
+
+#[derive(Debug, PartialEq, Error)]
+pub enum SimpleExtensionDeclarationError {}
+
+impl<C: Context> Parse<C> for proto::extensions::SimpleExtensionDeclaration {
+    type Parsed = SimpleExtensionDeclaration;
+    type Error = SimpleExtensionDeclarationError;
+
+    fn parse(self, ctx: &mut C) -> Result<Self::Parsed, Self::Error> {
+        let proto::extensions::SimpleExtensionDeclaration { mapping_type } = self;
+
+        Ok(SimpleExtensionDeclaration {
+            mapping_type: mapping_type
+                .map(|mapping_type| mapping_type.parse(ctx).ok())
+                .flatten(),
+        })
+    }
+}
+
+impl From<SimpleExtensionDeclaration> for proto::extensions::SimpleExtensionDeclaration {
+    fn from(declaration: SimpleExtensionDeclaration) -> Self {
+        let SimpleExtensionDeclaration { mapping_type } = declaration;
+
+        proto::extensions::SimpleExtensionDeclaration {
+            mapping_type: mapping_type.map(|mapping_type| mapping_type.into()),
+        }
+    }
+}