Add new enums to convert from strings

Also write new methods to access the parsed SDP members as enums

Author: tkanakamalla

src/lib.rs

@@ -43,6 +43,8 @@
 //!    are currently parsed as a plain string and not according to the SDP
 //!    grammar.
 
+use std::str::FromStr;
+
 use bstr::*;
 use fallible_iterator::FallibleIterator;
 
@@ -51,6 +53,65 @@ mod writer;
 
 pub use parser::ParserError;
 
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum NetType {
+    In,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum ParseEnumError {
+    Invalid(String),
+}
+
+
+impl std::str::FromStr for NetType {
+    type Err =  ParseEnumError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "IN" => Ok(NetType::In),
+            _ => Err(ParseEnumError::Invalid(s.to_string())),
+        }
+    }
+}
+
+impl Into<String> for NetType {
+    fn into(self) -> String {
+        match self {
+            NetType::In => format!("IN")
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum AddrType {
+    Ip4,
+    Ip6,
+}
+
+impl std::str::FromStr for AddrType {
+    type Err =  ParseEnumError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "IP4" => Ok(AddrType::Ip4),
+            "IP6" => Ok(AddrType::Ip6),
+            _ => Err(ParseEnumError::Invalid(s.to_string())),
+        }
+    }
+}
+
+impl Into<String> for AddrType {
+    fn into(self) -> String {
+        match self {
+            AddrType::Ip4 => format!("IP4"),
+            AddrType::Ip6 => format!("IP6")
+        }
+    }
+}
+
 /// Originator of the session.
 ///
 /// See [RFC 4566 Section 5.2](https://tools.ietf.org/html/rfc4566#section-5.2) for more details.
@@ -311,6 +372,26 @@ impl Session {
     }
 }
 
+
+impl Origin {
+
+    pub fn try_addrtype(&self) -> Result<AddrType, ParseEnumError> {
+        AddrType::from_str(self.addrtype.as_str())
+    }
+
+    pub fn set_from_addrtype(&mut self, addrtype: AddrType) {
+        self.addrtype = addrtype.into();
+    }
+
+    pub fn try_nettype(&self) -> Result<NetType, ParseEnumError> {
+        NetType::from_str(self.nettype.as_str())
+    }
+
+    pub fn set_from_nettype(&mut self, nettype: NetType) {
+        self.nettype = nettype.into();
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -472,5 +553,6 @@ a=fingerprint:sha-256 3A:96:6D:57:B2:C2:C7:61:A0:46:3E:1C:97:39:D3:F7:0A:88:A0:B
             &[None]
         );
         assert!(session.get_attribute_values("foo").is_err());
+        assert_eq!(session.origin.try_addrtype(), Ok(AddrType::Ip4));
     }
 }

src/parser.rs

@@ -862,7 +862,8 @@ a=control:track1\r
 a=rtpmap:8 PCMA/8000/1\r
 
 ";
-        let _parsed = Session::parse(&sdp[..]).unwrap();
+        let parsed = Session::parse(&sdp[..]).unwrap();
+        assert_eq!(parsed.origin.try_nettype(), Ok(NetType::In));
     }
 
     /// Parses SDP from a Geovision camera which (incorrectly) omits the "t="