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

src/parse/context.rs

@@ -38,6 +38,36 @@ pub trait Context {
         &self,
         anchor: &Anchor<SimpleExtensionUri>,
     ) -> Result<&SimpleExtensions, ContextError>;
+
+    /// Add a [ExtensionFunction] to this context. Must return an error for duplicate
+    /// anchors, when the URI is not supported or if the definition does not contain a matching function with the given name.
+    ///
+    /// This function must eagerly resolve and parse the simple extension, returning an
+    /// error if either fails.
+    fn add_extension_function(
+        &mut self,
+        extension_function: &ExtensionFunction,
+    ) -> Result<&SimpleExtensions, ContextError>;
+
+    /// Add an [ExtensionType] to this context. Must return an error for duplicate
+    /// anchors, when the URI is not supported or if the definition does not contain a matching function with the given name.
+    ///
+    /// This function must eagerly resolve and parse the simple extension, returning an
+    /// error if either fails.
+    fn add_extension_type(
+        &mut self,
+        extension: &ExtensionType,
+    ) -> Result<&SimpleExtensions, ContextError>;
+
+    /// Add a [ExtensionTypeVariation] to this context. Must return an error for duplicate
+    /// anchors, when the URI is not supported or if the definition does not contain a matching function with the given name.
+    ///
+    /// This function must eagerly resolve and parse the simple extension, returning an
+    /// error if either fails.
+    fn add_extension_type_variation(
+        &mut self,
+        extension_type_variation: &ExtensionTypeVariation,
+    ) -> Result<&SimpleExtensions, ContextError>;
 }
 
 /// Parse context errors.

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,55 @@
+use super::simple_extension_declaration::SimpleExtensionDeclarationError;
+use crate::{
+    parse::{Anchor, Context, Parse},
+    proto,
+};
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ExtensionFunction {
+    anchor: Anchor<Self>,
+    name: Name<Self>,
+    extension_uri_reference: Anchor<SimpleExtensionUri>,
+}
+
+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),
+        };
+
+        // Add the ExtensionFunction to the given context.
+        ctx.add_extension_function(&extension_function)?;
+
+        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,52 @@
+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: Name<Self>,
+    extension_uri_reference: Anchor<SimpleExtensionUri>,
+}
+
+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),
+        };
+
+        // Add the ExtensionType to the given context.
+        ctx.add_extension_type();
+
+        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,56 @@
+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: Name<Self>,
+    extension_uri_reference: Anchor<SimpleExtensionUri>,
+}
+
+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),
+        };
+
+        // Add the ExtensionTypeVariation to the given context.
+        ctx.add_extension_type_variation(&extension_type_variation)?;
+
+        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,42 @@
+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) => Self::ExtensionFunction(inner.into()),
+            MappingType::ExtensionType(inner) => Self::ExtensionType(inner.into()),
+            MappingType::ExtensionTypeVariation(inner) => {
+                Self::ExtensionTypeVariation(inner.into())
+            }
+        }
+    }
+}

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

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

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

@@ -0,0 +1,50 @@
+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 {
+    #[error("No Mapping Type specified on Extension Declaration.")]
+    MissingMappingType,
+
+    /// Context error
+    #[error(transparent)]
+    Context(#[from] ContextError),
+}
+
+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: Some(
+                mapping_type
+                    .ok_or(SimpleExtensionDeclarationError::MissingMappingType)?
+                    .parse(ctx)?,
+            ),
+        })
+    }
+}
+
+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()),
+        }
+    }
+}