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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use crate::model::{Error, PeekableTokens};
use crate::parser::Token;
use std::convert::TryFrom;
use std::iter::Peekable;

///ITU-T X.680 | ISO/IEC 8824-1, chapter 8
///
/// # Ordering
/// According to ITU-T X.680 | ISO/IEC 8824-1, 8.6, the canonical order is
/// a) Universal, Application, ContextSpecific and Private and
/// b) within each class, the numbers shall be ordered ascending
///
/// ```rust
/// use asn1rs_model::model::Tag;
/// let mut tags = vec![
///     Tag::Universal(1),
///     Tag::Application(0),
///     Tag::Private(7),
///     Tag::ContextSpecific(107),
///     Tag::ContextSpecific(32),
///     Tag::Universal(0),
/// ];
/// tags.sort();
/// assert_eq!(tags, vec![
///     Tag::Universal(0),
///     Tag::Universal(1),
///     Tag::Application(0),
///     Tag::ContextSpecific(32),
///     Tag::ContextSpecific(107),
///     Tag::Private(7),
/// ]);
/// ```
#[derive(Debug, Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]
pub enum Tag {
    Universal(usize),
    Application(usize),
    ContextSpecific(usize),
    Private(usize),
}

impl Tag {
    pub const DEFAULT_BOOLEAN: Tag = Tag::Universal(1);
    pub const DEFAULT_INTEGER: Tag = Tag::Universal(2);
    pub const DEFAULT_BIT_STRING: Tag = Tag::Universal(3);
    pub const DEFAULT_OCTET_STRING: Tag = Tag::Universal(4);
    pub const DEFAULT_NULL: Tag = Tag::Universal(5);
    pub const DEFAULT_ENUMERATED: Tag = Tag::Universal(10);
    pub const DEFAULT_UTF8_STRING: Tag = Tag::Universal(12);
    pub const DEFAULT_SEQUENCE: Tag = Tag::Universal(16);
    pub const DEFAULT_SEQUENCE_OF: Tag = Tag::Universal(16);
    pub const DEFAULT_SET: Tag = Tag::Universal(17);
    pub const DEFAULT_SET_OF: Tag = Tag::Universal(17);

    /// ITU-T Rec. X.680, 41
    pub const DEFAULT_NUMERIC_STRING: Tag = Tag::Universal(18);
    /// ITU-T Rec. X.680, 41
    pub const DEFAULT_PRINTABLE_STRING: Tag = Tag::Universal(19);
    /// ITU-T Rec. X.680, 41
    pub const DEFAULT_TELETEXT_STRING: Tag = Tag::Universal(20);
    /// ITU-T Rec. X.680, 41
    pub const DEFAULT_VIDEOTEXT_STRING: Tag = Tag::Universal(21);
    /// ITU-T Rec. X.680, 41
    pub const DEFAULT_IA5_STRING: Tag = Tag::Universal(22);
    /// ITU-T Rec. X.680, 41
    pub const DEFAULT_GRAPHIC_STRING: Tag = Tag::Universal(25);
    /// ITU-T Rec. X.680, 41
    pub const DEFAULT_VISIBLE_STRING: Tag = Tag::Universal(26);
    /// ITU-T Rec. X.680, 41
    pub const DEFAULT_GENERAL_STRING: Tag = Tag::Universal(27);
    /// ITU-T Rec. X.680, 41
    pub const DEFAULT_UNIVERSAL_STRING: Tag = Tag::Universal(28);
    /// ITU-T Rec. X.680, 41
    pub const DEFAULT_BMP_STRING: Tag = Tag::Universal(30);
}

impl<T: Iterator<Item = Token>> TryFrom<&mut Peekable<T>> for Tag {
    type Error = Error;

    fn try_from(iter: &mut Peekable<T>) -> Result<Self, Self::Error> {
        macro_rules! parse_tag_number {
            () => {
                parse_tag_number!(iter.next_or_err()?)
            };
            ($tag:expr) => {{
                let tag = $tag;
                tag.text()
                    .and_then(|t| t.parse().ok())
                    .ok_or_else(|| Error::invalid_tag(tag))?
            }};
        }

        Ok(match iter.next_or_err()? {
            t if t.eq_text_ignore_ascii_case("UNIVERSAL") => Tag::Universal(parse_tag_number!()),
            t if t.eq_text_ignore_ascii_case("APPLICATION") => {
                Tag::Application(parse_tag_number!())
            }
            t if t.eq_text_ignore_ascii_case("PRIVATE") => Tag::Private(parse_tag_number!()),
            t if t.text().is_some() => Tag::ContextSpecific(parse_tag_number!(t)),
            t => return Err(Error::no_text(t)),
        })
    }
}

pub trait TagProperty {
    fn tag(&self) -> Option<Tag>;

    fn set_tag(&mut self, tag: Tag);

    fn reset_tag(&mut self);

    fn with_tag_opt(self, tag: Option<Tag>) -> Self
    where
        Self: Sized,
    {
        if let Some(tag) = tag {
            self.with_tag(tag)
        } else {
            self.without_tag()
        }
    }

    fn with_tag(mut self, tag: Tag) -> Self
    where
        Self: Sized,
    {
        self.set_tag(tag);
        self
    }

    fn without_tag(mut self) -> Self
    where
        Self: Sized,
    {
        self.reset_tag();
        self
    }
}

#[cfg(test)]
pub(crate) mod tests {
    use super::*;

    pub(crate) fn test_property<T: TagProperty>(mut property: T)
    where
        T: Sized,
    {
        property.set_tag(Tag::Universal(22));
        assert_eq!(Some(Tag::Universal(22)), property.tag());

        property.reset_tag();
        assert_eq!(None, property.tag());

        let property = property.with_tag_opt(Some(Tag::Application(1337)));
        assert_eq!(Some(Tag::Application(1337)), property.tag());

        let property = property.without_tag();
        assert_eq!(None, property.tag());

        let property = property.with_tag(Tag::Private(42));
        assert_eq!(Some(Tag::Private(42)), property.tag());
    }
}