sdp-rs 0.2.1

SDP Rust library, parser & generator of the Session Description Protocol
Documentation 
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

use crate::{tokenizers::attributes::name_optvalue::Tokenizer as ParamsTokenizer, Error};

/// The fmtp tokenizer, which is part of the attribute (`a=`) line. This is low
/// level stuff and you shouldn't interact directly with it, unless you know what you are doing.
pub use crate::tokenizers::attributes::fmtp::Tokenizer;

/// The `fmtp` attribute as it appears in the attribute line(s) (`a=`).
#[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Clone)]
pub struct Fmtp {
    pub fmt: String,
    pub params: String,
}

impl Fmtp {
    pub fn params_list(&self) -> Result<Vec<(&str, Option<&str>)>, Error> {
        use nom::multi::many1;

        let (_, tokenizers) = many1(ParamsTokenizer::tokenize)(&self.params)?;

        Ok(tokenizers.into_iter().map(|t| (t.name, t.value)).collect())
    }
}

impl<'a> From<Tokenizer<'a>> for Fmtp {
    fn from(tokenizer: Tokenizer<'a>) -> Self {
        Self {
            fmt: tokenizer.fmt.into(),
            params: tokenizer.params.into(),
        }
    }
}

impl std::fmt::Display for Fmtp {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{} {}", self.fmt, self.params)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::convert::TryFrom;

    #[test]
    fn from_str1() {
        let tokenizer = Tokenizer {
            fmt: "96",
            params: "profile-level-id=42e016;max-mbps=108000;max-fs=3600",
        };

        assert_eq!(
            Fmtp::try_from(tokenizer),
            Ok(Fmtp {
                fmt: "96".into(),
                params: "profile-level-id=42e016;max-mbps=108000;max-fs=3600".into(),
            })
        );
    }

    #[test]
    fn params_list1() {
        let fmtp = Fmtp {
            fmt: "96".into(),
            params: "profile-level-id=42e016;max-mbps=108000;max-fs=3600".into(),
        };

        assert_eq!(
            fmtp.params_list(),
            Ok(vec![
                ("profile-level-id", Some("42e016")),
                ("max-mbps", Some("108000")),
                ("max-fs", Some("3600")),
            ])
        );
    }

    #[test]
    fn params_list2() {
        let fmtp = Fmtp {
            fmt: "96".into(),
            params: "profile-level-id=42e016;max-mbps=108000;max-fs=3600;".into(),
        };

        assert_eq!(
            fmtp.params_list(),
            Ok(vec![
                ("profile-level-id", Some("42e016")),
                ("max-mbps", Some("108000")),
                ("max-fs", Some("3600")),
            ])
        );
    }

    #[test]
    fn params_list3() {
        let fmtp = Fmtp {
            fmt: "96".into(),
            params: "profile-level-id;max-mbps=108000;max-fs".into(),
        };

        assert_eq!(
            fmtp.params_list(),
            Ok(vec![
                ("profile-level-id", None),
                ("max-mbps", Some("108000")),
                ("max-fs", None),
            ])
        );
    }

    #[test]
    fn display1() {
        assert_eq!(
            Fmtp {
                fmt: "96".into(),
                params: "profile-level-id;max-mbps=108000;max-fs".into(),
            }
            .to_string(),
            "96 profile-level-id;max-mbps=108000;max-fs"
        );
    }
}