types: Fixes #146, VisibleString character set (#147)

* types: Fixes #146 * visiblestring: remove dbg! * per: add checks when restricted strings should be indexed, printable string tests
librasn · Oct 11, 2023 · 15f8774 · 15f8774
1 parent 9d70f93
commit 15f8774
Show file tree

Hide file tree

Showing 4 changed files with 153 additions and 39 deletions.
diff --git a/src/per/enc.rs b/src/per/enc.rs
@@ -236,7 +236,9 @@ impl Encoder {
                         value.to_octet_aligned_index_string()
                     }
                 });
-                let value = value.to_index_string();
+                // 30.5.4 Rec. ITU-T X.691 (02/2021)
+                let value = value.to_index_or_value_bitstring();
+
                 let octet_aligned_value = &octet_aligned_value;
                 self.encode_string_length(
                     &mut buffer,

diff --git a/src/types/strings/constrained.rs b/src/types/strings/constrained.rs
@@ -31,6 +31,14 @@ pub(crate) trait StaticPermittedAlphabet: Sized + Default {
         range
     }
 
+    fn to_index_or_value_bitstring(&self) -> types::BitString {
+        if should_be_indexed(Self::CHARACTER_WIDTH, Self::CHARACTER_SET) {
+            self.to_index_string()
+        } else {
+            self.to_bit_string()
+        }
+    }
+
     fn to_index_string(&self) -> types::BitString {
         let index_map = Self::index_map();
         let mut index_string = types::BitString::new();
@@ -164,19 +172,34 @@ pub(crate) fn try_from_permitted_alphabet<S: StaticPermittedAlphabet>(
 ) -> Result<S, FromPermittedAlphabetError> {
     let mut string = S::default();
     let permitted_alphabet_char_width = crate::per::log2(alphabet.len() as i128);
-
-    for ch in input.chunks_exact(permitted_alphabet_char_width as usize) {
-        let index = ch.load_be();
-
-        string.push_char(
-            *alphabet
-                .get(&index)
-                .ok_or(FromPermittedAlphabetError::IndexNotFound { index })?,
-        );
+    // Alphabet should be always indexed key-alphabetvalue pairs at this point
+    let values_only = alphabet.values().copied().collect::<Vec<u32>>();
+    if should_be_indexed(permitted_alphabet_char_width, &values_only) {
+        for ch in input.chunks_exact(permitted_alphabet_char_width as usize) {
+            let index = ch.load_be();
+            string.push_char(
+                *alphabet
+                    .get(&index)
+                    .ok_or(FromPermittedAlphabetError::IndexNotFound { index })?,
+            );
+        }
+    } else {
+        for ch in input.chunks_exact(permitted_alphabet_char_width as usize) {
+            let value = ch.load_be();
+            string.push_char(value);
+        }
     }
 
     Ok(string)
 }
+pub(crate) fn should_be_indexed(width: u32, character_set: &[u32]) -> bool {
+    let largest_value = character_set.iter().copied().max().unwrap_or(0);
+    if 2u32.pow(width) - 1 >= largest_value {
+        false
+    } else {
+        true
+    }
+}
 
 #[derive(Debug, Default, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct DynConstrainedCharacterString {
@@ -196,20 +219,35 @@ impl DynConstrainedCharacterString {
     ) -> Result<Self, ConstrainedConversionError> {
         let mut buffer = types::BitString::new();
         let char_width = crate::per::log2(character_set.len() as i128);
-        let alphabet = BTreeMap::from_iter(
-            character_set
-                .iter()
-                .enumerate()
-                .map(|(i, a)| (*a, i as u32)),
-        );
-
-        for ch in data {
-            let Some(index) = alphabet.get(&ch).copied() else {
-                return Err(ConstrainedConversionError);
-            };
-            let range = ((u32::BITS - char_width) as usize)..(u32::BITS as usize);
-            let bit_ch = &index.view_bits::<Msb0>()[range];
-            buffer.extend_from_bitslice(bit_ch);
+        let indexed = should_be_indexed(char_width, character_set);
+        let alphabet: BTreeMap<u32, u32>;
+        if indexed {
+            alphabet = BTreeMap::from_iter(
+                character_set
+                    .iter()
+                    .enumerate()
+                    .map(|(i, a)| (*a, i as u32)),
+            );
+            for ch in data {
+                let Some(index) = alphabet.get(&ch).copied() else {
+                    return Err(ConstrainedConversionError);
+                };
+                let range = ((u32::BITS - char_width) as usize)..(u32::BITS as usize);
+                let bit_ch = &index.view_bits::<Msb0>()[range];
+                buffer.extend_from_bitslice(bit_ch);
+            }
+        } else {
+            alphabet = BTreeMap::from_iter(
+                character_set
+                    .iter()
+                    .enumerate()
+                    .map(|(i, a)| (i as u32, *a)),
+            );
+            for ch in data {
+                let range = ((u32::BITS - char_width) as usize)..(u32::BITS as usize);
+                let bit_ch = &ch.view_bits::<Msb0>()[range];
+                buffer.extend_from_bitslice(bit_ch);
+            }
         }
 
         Ok(Self {

diff --git a/src/types/strings/visible.rs b/src/types/strings/visible.rs
@@ -2,36 +2,51 @@ use super::*;
 
 use alloc::{borrow::ToOwned, boxed::Box, string::String, vec::Vec};
 
-/// An string which contains the characters defined in the ISO 646
-/// character set.
+/// A string which contains a subset of the ISO 646 character set.
+/// Type **should be** constructed by using `try_from` or `from` methods.
+///
+/// This type is restricted to allow only the graphically visible characters and space character (0x20),
+/// which is defined in X.680 (02/2021), Section 41, Table 8.
+///
+/// Should contain registration 6. set from ISO International Register of Coded Character Sets and SPACE character.
+/// Graphical restrictions (registration 6.) are defined freely and publicly in sister standard ITU-T T.50, section 6.4.
 #[derive(Debug, Default, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[allow(clippy::module_name_repetitions)]
 pub struct VisibleString(Vec<u8>);
 
 impl VisibleString {
+    /// Create a new `VisibleString` from ISO 646 bytes (also known as US-ASCII/IA5/IRA5).
+    ///
+    /// # Errors
+    ///
+    /// Error of type `InvalidIso646Bytes` is raised if the restriction is not met.
     pub fn from_iso646_bytes(bytes: &[u8]) -> Result<Self, InvalidIso646Bytes> {
-        if !bytes.iter().all(|byte| byte & 0x80 == 0) {
-            Err(InvalidIso646Bytes)
-        } else {
+        if bytes
+            .iter()
+            .all(|byte| Self::CHARACTER_SET.contains(&u32::from(*byte)))
+        {
             Ok(Self(bytes.to_owned()))
+        } else {
+            Err(InvalidIso646Bytes)
         }
     }
-
+    /// Converts the `VisibleString` into ISO 646 bytes (also known as US-ASCII/IA5/IRA5).
+    #[must_use]
     pub fn as_iso646_bytes(&self) -> &[u8] {
         &self.0
     }
 }
 
 impl StaticPermittedAlphabet for VisibleString {
+    /// Includes Space (0x20) and all graphically visible characters (0x21-0x7E).
     const CHARACTER_SET: &'static [u32] = &[
-        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
-        0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
-        0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C,
-        0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
-        0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
-        0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
-        0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
-        0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
-        0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
+        0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E,
+        0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D,
+        0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C,
+        0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B,
+        0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
+        0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+        0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
     ];
 
     fn chars(&self) -> Box<dyn Iterator<Item = u32> + '_> {

diff --git a/src/uper.rs b/src/uper.rs
@@ -199,6 +199,65 @@ mod tests {
             &[0x02, 0x39, 0x12]
         );
     }
+    #[test]
+    fn printable_string() {
+        round_trip_with_constraints!(
+            uper,
+            PrintableString,
+            Constraints::new(&[Constraint::Size(Size::new(Bounded::Single(16)).into())]),
+            PrintableString::from_bytes("0123456789abcdef".as_bytes()).unwrap(),
+            &[0x60, 0xc5, 0x93, 0x36, 0x8d, 0x5b, 0x37, 0x70, 0xe7, 0x0e, 0x2c, 0x79, 0x32, 0xe6]
+        );
+        round_trip_with_constraints!(
+            uper,
+            PrintableString,
+            Constraints::new(&[Constraint::Size(
+                Size::new(Bounded::Range {
+                    start: 0.into(),
+                    end: 31.into()
+                })
+                .into()
+            )]),
+            "".try_into().unwrap(),
+            &[0x00]
+        );
+        round_trip_with_constraints!(
+            uper,
+            PrintableString,
+            Constraints::new(&[Constraint::Size(
+                Size::new(Bounded::Range {
+                    start: 0.into(),
+                    end: 31.into()
+                })
+                .into()
+            )]),
+            "2".try_into().unwrap(),
+            &[0x0b, 0x20]
+        );
+
+        #[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq)]
+        #[rasn(crate_root = "crate")]
+        struct PrintStruct {
+            a: bool,
+            #[rasn(size("36"))]
+            b: PrintableString,
+            c: bool,
+        }
+        round_trip!(
+            uper,
+            PrintStruct,
+            PrintStruct {
+                a: true,
+                b: "123123123123123123123123123123123123".try_into().unwrap(),
+                c: true
+            },
+            &[
+                0xb1, 0x64, 0xcd, 0x8b, 0x26, 0x6c, 0x59, 0x33, 0x62, 0xc9, 0x9b, 0x16, 0x4c, 0xd8,
+                0xb2, 0x66, 0xc5, 0x93, 0x36, 0x2c, 0x99, 0xb1, 0x64, 0xcd, 0x8b, 0x26, 0x6c, 0x59,
+                0x33, 0x62, 0xc9, 0x9c
+            ]
+        );
+    }
 
     #[test]
     fn choice() {