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

///
/// `TagPosition` is an enumeration containing three different tag "positions" that this library works with:
///

#[derive(PartialEq, Debug, Clone)]
pub enum TagPosition {

    ///
    /// A marker for the beginning of a "master" tag as defined in EBML.  Master tags are simply containers for other tags.  The u64 value is the "id" of the tag.
    ///
    StartTag(u64),

    ///
    /// A marker for the end of a "master" tag.  The u64 value is the "id" of the tag.
    ///
    EndTag(u64),

    ///
    /// A complete tag that includes both the id and full data of the tag.  See [`TagData`] for more detail.
    ///
    FullTag(u64, TagData),
}


impl TagPosition {
    pub fn start_tag(&self) -> Option<u64> {
        match &self {
            TagPosition::StartTag(id) => Some(*id),
            _ => None
        }
    }

    pub fn end_tag(&self) -> Option<u64> {
        match &self {
            TagPosition::EndTag(id) => Some(*id),
            _ => None
        }
    }

    pub fn full_tag(self) -> Option<(u64, TagData)> {
        match self {
            TagPosition::FullTag(id, data) => Some((id, data)),
            _ => None
        }
    }
}

///
/// Contains the content of a tag.
///
/// This struct contains tag content data - i.e. the "meat" of the tag.  
///
/// Note: This library made a concious decision to not parse "Date" elements from EBML due to lack of built-in support for dates in Rust. Specification implementations should treat Date elements as Binary so that consumers have the option of parsing the unaltered data using their library of choice, if needed.
/// 

#[derive(PartialEq, Debug, Clone)]
pub enum TagData {

    ///
    /// A complete master tag containing any number of child tags.
    ///
    Master(Vec<(u64, TagData)>),

    ///
    /// An unsigned integer.
    ///
    UnsignedInt(u64),

    ///
    /// A signed integer.
    ///
    Integer(i64),

    ///
    /// A Unicode text string.  Note that the [EBML spec][https://datatracker.ietf.org/doc/rfc8794/] includes a separate element type for ASCII.  Given that ASCII is a subset of Utf8, this library currently parses and encodes both types using the same Utf8 element.
    ///
    Utf8(String),

    ///
    /// Binary data, otherwise uninterpreted.
    ///
    Binary(Vec<u8>),

    ///
    /// IEEE-754 floating point number.
    ///
    Float(f64),
}

impl TagData {
    pub fn master(self) -> Option<Vec<(u64, TagData)>> {
        match self {
            TagData::Master(children) => Some(children),
            _ => None
        }
    }

    pub fn unsigned_int(&self) -> Option<u64> {
        match &self {
            TagData::UnsignedInt(val) => Some(*val),
            _ => None
        }
    }

    pub fn integer(&self) -> Option<i64> {
        match &self {
            TagData::Integer(val) => Some(*val),
            _ => None
        }
    }

    pub fn utf8(self) -> Option<String> {
        match self {
            TagData::Utf8(val) => Some(val),
            _ => None
        }
    }

    pub fn binary(self) -> Option<Vec<u8>> {
        match self {
            TagData::Binary(val) => Some(val),
            _ => None
        }
    }

    pub fn float(&self) -> Option<f64> {
        match &self {
            TagData::Float(val) => Some(*val),
            _ => None
        }
    }
}