1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Functionality for decoding character strings

use crate::aper::AperCodecData;
use crate::aper::AperCodecError;

use super::decode_internal::decode_length_determinent;

// 27.5.3 and 27.5.4
/// Decode a VisibleString CharacterString Type.
pub fn decode_visible_string(
    data: &mut AperCodecData,
    lb: Option<i128>,
    ub: Option<i128>,
    is_extensible: bool,
) -> Result<String, AperCodecError> {
    // Following values  are never used instead Canonical decode
    let (_val_lower, _val_higher) = (32u8, 127u8);

    let num_bits = 8; // N = 95, B = 7, B2 = 8

    let is_extended = if is_extensible {
        data.decode_bool()?
    } else {
        false
    };

    let length = if is_extended {
        decode_length_determinent(data, None, None, false)?
    } else {
        decode_length_determinent(data, lb, ub, false)?
    };

    let mut out = String::new();
    if length > 0 {
        let length = length * num_bits;

        if length > 16 {
            data.decode_align()?;
        }

        let bits = data.get_bitvec(length)?;
        let decoded = bits
            .chunks_exact(num_bits)
            .map(|c| c.as_raw_slice()[0] as char)
            .collect::<String>();
        out += &decoded;
    }

    Ok(out)
}

/// Decode a PrintableString CharacterString Type.
pub fn decode_printable_string(
    data: &mut AperCodecData,
    lb: Option<i128>,
    ub: Option<i128>,
    is_extensible: bool,
) -> Result<String, AperCodecError> {
    let (_val_lower, _val_higher) = (32u8, 122u8);

    let num_bits = 8; // N = 74, B = 7, B2 = 8

    let mut alphabet = vec![' ', '\'', '(', ')', '+', ',', '-', '.', '/'];
    alphabet.extend(('0'..='9').collect::<Vec<char>>());
    alphabet.extend(vec![':', '=', '?']);
    alphabet.extend(('a'..='z').collect::<Vec<char>>());
    alphabet.extend(('A'..='Z').collect::<Vec<char>>());

    let is_extended = if is_extensible {
        data.decode_bool()?
    } else {
        false
    };

    let length = if is_extended {
        decode_length_determinent(data, None, None, false)?
    } else {
        decode_length_determinent(data, lb, ub, false)?
    };

    let mut out = String::new();
    if length > 0 {
        let length = length * num_bits;

        if length > 16 {
            data.decode_align()?;
        }

        let bits = data.get_bitvec(length)?;
        let decoded = bits
            .chunks_exact(num_bits)
            .map(|c| c.as_raw_slice()[0] as char)
            .collect::<String>();
        out += &decoded;
    }

    Ok(String::new())
}

// UTF-8 String is always - indefinite length case as it's not a fixed character width string. It's
// almost like decoding an octet string.
// 27.6
/// Decode a UTF8String CharacterString Type.
pub fn decode_utf8_string(
    data: &mut AperCodecData,
    _lb: Option<i128>,
    _ub: Option<i128>,
    _is_extensible: bool,
) -> Result<String, AperCodecError> {
    let (_val_lower, _val_higher) = (0u8, 255u8);

    let num_bits = 8; // N = 74, B = 7, B2 = 8

    let length = decode_length_determinent(data, None, None, false)?;
    let mut out = String::new();
    if length > 0 {
        let length = length * num_bits;

        if length > 16 {
            data.decode_align()?;
        }

        let bits = data.get_bitvec(length)?;
        let decoded = bits
            .chunks_exact(num_bits)
            .map(|c| c.as_raw_slice()[0])
            .collect::<Vec<u8>>();
        let decoded = String::from_utf8(decoded).unwrap();

        out += &decoded;
    }
    Ok(out)
}