wip

benches/common.rs

@@ -24,7 +24,7 @@ pub struct Bench {
 #[derive(AsnType, Decode, Encode)]
 pub struct EmptySequence {}
 
-#[derive(AsnType, Clone, Copy, Decode, Encode)]
+#[derive(AsnType, Clone, Copy, Decode, Encode, PartialEq)]
 #[rasn(enumerated)]
 pub enum BenchEnum {
     A,

macros/src/config.rs

@@ -370,7 +370,7 @@ impl OptionalEnum {
 }
 
 pub struct VariantConfig<'config> {
-    variant: &'config syn::Variant,
+    pub variant: &'config syn::Variant,
     container_config: &'config Config,
     generics: &'config syn::Generics,
     pub tag: Option<Tag>,
@@ -414,6 +414,13 @@ impl<'config> VariantConfig<'config> {
         }
     }
 
+    pub fn discriminant(&self) -> Option<usize> {
+        self.variant.discriminant.as_ref().and_then(|(_, expr)| match expr {
+            syn::Expr::Lit(syn::ExprLit { lit: syn::Lit::Int(int), ..})  => int.base10_parse().ok(),
+            _ => None,
+        })
+    }
+
     pub fn has_explicit_tag(&self) -> bool {
         self.tag.as_ref().map_or(false, |tag| tag.is_explicit())
     }

macros/src/enum.rs

@@ -86,6 +86,42 @@ impl Enum {
             }
         });
 
+        let enumerated_impl = self.config.enumerated.then(|| {
+            let (variants, extended_variants): (Vec<_>, Vec<_>) = self.variants.iter()
+                .map(|variant| VariantConfig::new(variant, &self.generics, &self.config))
+                .partition(|config| config.extension_addition);
+
+            let discriminants = variants.iter().enumerate().map(|(i, config)| {
+                let discriminant = config.discriminant().unwrap_or(i) as isize;
+                let variant = &config.variant.ident;
+                quote!((Self::#variant, #discriminant))
+            });
+            let extended_discriminants = extended_variants.iter().enumerate().map(|(i, config)| {
+                let discriminant = config.discriminant().unwrap_or(i) as isize;
+                let variant = &config.variant.ident;
+                quote!((Self::#variant, #discriminant))
+            });
+
+            let variants = variants.iter().map(|config| config.variant.ident.clone());
+            let extended_variant_idents = extended_variants.iter().map(|config| config.variant.ident.clone());
+            let extended_variants = (!extended_variants.is_empty())
+                .then(|| quote!(Some(&[#(Self::#extended_variant_idents,)*])))
+                .unwrap_or(quote!(None));
+            let extended_discriminants = (!extended_variants.is_empty())
+                .then(|| quote!(Some(&[#(#extended_discriminants,)*])))
+                .unwrap_or(quote!(None));
+
+            quote! {
+                impl #impl_generics #crate_root::types::Enumerated for #name #ty_generics #where_clause {
+                    const VARIANTS: &'static [Self] = &[#(Self::#variants,)*];
+                    const EXTENDED_VARIANTS: Option<&'static [Self]> = #extended_variants;
+
+                    const DISCRIMINANTS: &'static [(Self, isize)] = &[#(#discriminants,)*];
+                    const EXTENDED_DISCRIMINANTS: Option<&'static [(Self, isize)]> = #extended_discriminants;
+                }
+            }
+        });
+
         quote! {
             impl #impl_generics #crate_root::AsnType for #name #ty_generics #where_clause {
                 const TAG: #crate_root::Tag = {
@@ -102,6 +138,7 @@ impl Enum {
             }
 
             #choice_impl
+            #enumerated_impl
         }
     }
 
@@ -129,23 +166,7 @@ impl Enum {
         let mut generics = self.generics.clone();
         generics.add_trait_bounds(&self.config.crate_root, quote::format_ident!("Decode"));
         let decode_with_tag = if self.config.enumerated {
-            let variants = self.variants.iter().map(|v| {
-                let ident = &v.ident;
-                quote!(i if i == #crate_root::types::Integer::from(Self::#ident as isize) => Self::#ident,)
-            });
-
-            quote! {
-                let integer = decoder.decode_enumerated(
-                    tag,
-                    constraints,
-                )?;
-
-                Ok(match integer {
-                    #(#variants)*
-                    _ => return Err(#crate_root::de::Error::custom("Invalid enumerated disrciminant."))
-                })
-
-            }
+            quote!(decoder.decode_enumerated(tag))
         } else {
             quote!(decoder.decode_explicit_prefix(tag))
         };
@@ -244,9 +265,8 @@ impl Enum {
     fn encode_with_tag(&self) -> proc_macro2::TokenStream {
         let crate_root = &self.config.crate_root;
         let operation = if self.config.enumerated {
-            let variance = self.variants.len();
             quote! {
-                encoder.encode_enumerated(tag, #variance, *self as isize).map(drop)
+                encoder.encode_enumerated(tag, self).map(drop)
             }
         } else {
             quote! {

src/ber/de.rs

@@ -12,7 +12,7 @@ use super::identifier::Identifier;
 use crate::{
     de::Error as _,
     types::{
-        self,
+        self, Enumerated,
         oid::{MAX_OID_FIRST_OCTET, MAX_OID_SECOND_OCTET},
         Constraints, Tag,
     },
@@ -148,8 +148,8 @@ impl<'input> crate::Decoder for Decoder<'input> {
         })
     }
 
-    fn decode_enumerated(&mut self, tag: Tag, constraints: Constraints) -> Result<types::Integer> {
-        self.decode_integer(tag, constraints)
+    fn decode_enumerated<E: Enumerated>(&mut self, tag: Tag) -> Result<E> {
+        E::from_discriminant(self.decode_integer(tag, <_>::default())?.try_into().map_err(|error| Error::custom(error))?).ok_or_else(|| Error::custom("no valid discriminant"))
     }
 
     fn decode_integer(&mut self, tag: Tag, _: Constraints) -> Result<types::Integer> {

src/ber/enc.rs

@@ -8,9 +8,9 @@ use alloc::{collections::VecDeque, string::ToString, vec::Vec};
 use super::Identifier;
 use crate::{
     types::{
-        self, constraints,
+        self,
         oid::{MAX_OID_FIRST_OCTET, MAX_OID_SECOND_OCTET},
-        Constraints, Tag,
+        Constraints, Tag, Enumerated,
     },
     Encode,
 };
@@ -279,19 +279,13 @@ impl crate::Encoder for Encoder {
         (encode_fn)(self).map(drop)
     }
 
-    fn encode_enumerated(
+    fn encode_enumerated<E: Enumerated>(
         &mut self,
         tag: Tag,
-        variance: usize,
-        value: isize,
+        value: &E,
     ) -> Result<Self::Ok, Self::Error> {
-        self.encode_integer(
-            tag,
-            Constraints::from(
-                &[constraints::Size::new(constraints::Bounded::up_to(variance)).into()],
-            ),
-            &(value.into()),
-        )
+        let value = E::discriminant(value);
+        self.encode_integer(tag, <_>::default(), &value.into())
     }
 
     fn encode_integer(

src/de.rs

@@ -3,7 +3,7 @@
 use alloc::{boxed::Box, vec::Vec};
 use core::convert::TryInto;
 
-use crate::types::{self, AsnType, Constraints, Tag};
+use crate::types::{self, AsnType, Constraints, Tag, Enumerated};
 
 pub use nom::Needed;
 pub use rasn_derive::Decode;
@@ -60,11 +60,10 @@ pub trait Decoder: Sized {
     /// Decode a `BOOL` identified by `tag` from the available input.
     fn decode_bool(&mut self, tag: Tag) -> Result<bool, Self::Error>;
     /// Decode an enumerated enum's discriminant identified by `tag` from the available input.
-    fn decode_enumerated(
+    fn decode_enumerated<E: Enumerated>(
         &mut self,
         tag: Tag,
-        constraints: Constraints,
-    ) -> Result<types::Integer, Self::Error>;
+    ) -> Result<E, Self::Error>;
     /// Decode a `INTEGER` identified by `tag` from the available input.
     fn decode_integer(
         &mut self,

src/enc.rs

@@ -1,6 +1,6 @@
 //! Generic ASN.1 encoding framework.
 
-use crate::types::{self, AsnType, Constraints, Tag};
+use crate::types::{self, AsnType, Constraints, Tag, Enumerated};
 
 pub use rasn_derive::Encode;
 
@@ -63,11 +63,10 @@ pub trait Encoder {
     ) -> Result<Self::Ok, Self::Error>;
 
     /// Encode a `ENUMERATED` value.
-    fn encode_enumerated(
+    fn encode_enumerated<E: Enumerated>(
         &mut self,
         tag: Tag,
-        variance: usize,
-        value: isize,
+        value: &E,
     ) -> Result<Self::Ok, Self::Error>;
 
     /// Encode a `OBJECT IDENTIFIER` value.

src/per.rs

@@ -104,6 +104,35 @@ mod tests {
         round_trip!(aper, Choice, Choice::Medium, &[0x80, 1, 0]);
     }
 
+    #[test]
+    fn enumerated() {
+
+        #[derive(AsnType, Clone, Copy, Debug, Decode, Encode, PartialEq)]
+        #[rasn(enumerated, crate_root = "crate")]
+        enum Enum1 { Green, Red, Blue, }
+
+        // round_trip!(uper, Enum1, Enum1::Green, &[0]);
+        // round_trip!(uper, Enum1, Enum1::Red, &[0x40]);
+        // round_trip!(uper, Enum1, Enum1::Blue, &[0x80]);
+
+        #[derive(AsnType, Clone, Copy, Debug, Decode, Encode, PartialEq)]
+        #[rasn(enumerated, crate_root = "crate")]
+        #[non_exhaustive]
+        enum Enum2 {
+            Red,
+            Blue,
+            Green,
+            #[rasn(extension_addition)]
+            Yellow,
+            #[rasn(extension_addition)]
+            Purple,
+        }
+
+        // round_trip!(uper, Enum2, Enum2::Red, &[0]);
+        round_trip!(uper, Enum2, Enum2::Yellow, &[0x80]);
+        round_trip!(uper, Enum2, Enum2::Purple, &[0x81]);
+    }
+
     #[test]
     fn extension_additions() {
         #[derive(AsnType, Clone, Copy, Debug, Decode, Default, Encode, PartialEq)]
@@ -138,6 +167,23 @@ mod tests {
             v2: MySequenceValExtension,
         }
 
+        let value = MySequenceVal {
+            item_code: 0,
+            item_name: None,
+            urgency: Urgency::High,
+            v2: MySequenceValExtension {
+                alternate_item_code: 0,
+                alternate_item_name: None,
+            },
+        };
+
+        round_trip!(
+            uper,
+            MySequenceVal,
+            value,
+            &[0x80, 0x00, 0xa0, 0x40, 0x00, 0x00, 0x0a]
+        );
+
         let value = MySequenceVal {
             item_code: 29,
             item_name: Some(Ia5String::try_from("SHERRY").unwrap()),
@@ -153,8 +199,9 @@ mod tests {
             MySequenceVal,
             value,
             &[
-                0xc7, 0x5d, 0x39, 0x11, 0x69, 0x52, 0xb2, 0x7, 0x1, 0x80, 0x5, 0x96, 0x9a, 0x13,
-                0xe9, 0x54
+            0xc7, 0x5d, 0x39, 0x11, 0x69, 0x52, 0xb2, 0x07, 0x01, 0x80,
+            0x05, 0x96, 0x9a, 0x13, 0xe9, 0x54
+
             ]
         );
     }

src/per/de.rs

@@ -9,6 +9,7 @@ use crate::{
     de::Error as _,
     types::{
         self,
+        Enumerated,
         constraints::{self, Extensible},
         fields::{Field, Fields},
         strings::StaticPermittedAlphabet,
@@ -273,8 +274,18 @@ impl<'input> crate::Decoder for Decoder<'input> {
         self.parse_one_bit()
     }
 
-    fn decode_enumerated(&mut self, tag: Tag, constraints: Constraints) -> Result<types::Integer> {
-        self.decode_integer(tag, constraints)
+    fn decode_enumerated<E: Enumerated>(&mut self, _: Tag) -> Result<E> {
+        let extensible = E::EXTENDED_VARIANTS.is_some().then(|| self.parse_one_bit()).transpose()?.unwrap_or_default();
+
+        if extensible {
+            let index: usize = self.parse_normally_small_integer()?.try_into().map_err(Error::custom)?;
+            E::from_extended_enumeration_index(index)
+                .ok_or_else(|| Error::custom(format!("Extended index {} not found", index)))
+        } else {
+            let index = self.parse_non_negative_binary_integer(E::variance() as i128)?.try_into().map_err(Error::custom)?;
+            E::from_enumeration_index(index)
+                .ok_or_else(|| Error::custom(format!("Index {} not found", index)))
+        }
     }
 
     fn decode_integer(&mut self, _: Tag, constraints: Constraints) -> Result<types::Integer> {