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

use super::{EbmlSpecification, EbmlTag, Master, TagDataType};

///
/// An empty specification for use with examples or testing.
///
/// This struct isn't intended for production use and should only be used for examples or PoCs. Use at your own risk - may change in the future without warning.
///
/// # NOT SUITABLE FOR PRODUCTION
///
#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd)]
pub struct EmptySpec {
    id: u64, 
    children: Option<Master<EmptySpec>>,
    data: Option<Vec<u8>>,
}

impl EmptySpec {
    pub fn with_children(id: u64, children: Vec<EmptySpec>) -> Self {
        EmptySpec::get_master_tag(id, Master::Full(children)).unwrap()
    }

    pub fn with_data(id: u64, data: &[u8]) -> Self {
        EmptySpec::get_binary_tag(id, data).unwrap()
    }
}

impl EbmlSpecification<EmptySpec> for EmptySpec {
    fn get_tag_data_type(_id: u64) -> TagDataType {
        TagDataType::Binary
    }

    fn get_unsigned_int_tag(_id: u64, _data: u64) -> Option<EmptySpec> {
        None
    }

    fn get_signed_int_tag(_id: u64, _data: i64) -> Option<EmptySpec> {
        None
    }

    fn get_utf8_tag(_id: u64, _data: String) -> Option<EmptySpec> {
        None
    }

    fn get_binary_tag(id: u64, data: &[u8]) -> Option<EmptySpec> {
        Some(EmptySpec {
            id,
            children: None,
            data: Some(data.to_vec()),
        })
    }

    fn get_float_tag(_id: u64, _data: f64) -> Option<EmptySpec> {
        None
    }

    fn get_master_tag(id: u64, data: Master<EmptySpec>) -> Option<EmptySpec> {
        Some(EmptySpec {
            id,
            children: Some(data),
            data: None,
        })
    }

    fn get_raw_tag(id: u64, data: &[u8]) -> EmptySpec {
        EmptySpec::get_binary_tag(id, data).expect("get binary tag for EmptySpec should always return Some")
    }
}

impl EbmlTag<EmptySpec> for EmptySpec {

    fn get_id(&self) -> u64 { 
        self.id
    }

    fn as_unsigned_int(&self) -> Option<&u64> {
        None
    }

    fn as_signed_int(&self) -> Option<&i64> {
        None
    }

    fn as_utf8(&self) -> Option<&str> {
        None
    }

    fn as_binary(&self) -> Option<&[u8]> {
        self.data.as_deref()
    }

    fn as_float(&self) -> Option<&f64> {
        None
    }

    fn as_master(&self) -> Option<&Master<EmptySpec>> {
        match &self.children {
            Some(children) => Some(children),
            None => None
        }
    }
}