From f96207c93e1fcc771ad8ba9d165dd5a57f38dad4 Mon Sep 17 00:00:00 2001 From: Luro02 <24826124+Luro02@users.noreply.github.com> Date: Fri, 4 Oct 2019 11:19:03 +0200 Subject: [PATCH] remove `draft` content --- src/types/channels.rs | 111 ++++++++---------------------------------- 1 file changed, 20 insertions(+), 91 deletions(-) diff --git a/src/types/channels.rs b/src/types/channels.rs index b620edb..5cad2dc 100644 --- a/src/types/channels.rs +++ b/src/types/channels.rs @@ -11,14 +11,6 @@ use crate::Error; /// present in any [`MediaSegment`] in the rendition. For example, an /// `AC-3 5.1` rendition would have a `CHANNELS="6"` attribute. /// -/// The second parameter identifies the encoding of object-based audio used by -/// the rendition. This parameter is a comma-separated list of Audio -/// Object Coding Identifiers. It is optional. An Audio Object -/// Coding Identifier is a string containing characters from the set -/// `[A..Z]`, `[0..9]`, and `'-'`. They are codec-specific. A parameter -/// value of consisting solely of the dash character (`'-'`) indicates -/// that the audio is not object-based. -/// /// # Example /// Creating a `CHANNELS="6"` attribute /// ``` @@ -31,16 +23,11 @@ use crate::Error; /// ); /// ``` /// -/// # Note -/// Currently there are no example playlists in the documentation, -/// or in popular m3u8 libraries, showing a usage for the second parameter -/// of [`Channels`], so if you have one please open an issue on github! -/// /// [`MediaSegment`]: crate::MediaSegment #[derive(Debug, Clone, Default, Eq, PartialEq, Ord, PartialOrd, Hash)] pub struct Channels { - first_parameter: u64, - second_parameter: Option>, + channel_number: u64, + unknown: Vec, } impl Channels { @@ -51,77 +38,36 @@ impl Channels { /// # use hls_m3u8::types::Channels; /// let mut channels = Channels::new(6); /// ``` - pub const fn new(value: u64) -> Self { + pub fn new(value: u64) -> Self { Self { - first_parameter: value, - second_parameter: None, + channel_number: value, + unknown: vec![], } } - /// Returns the first parameter. + /// Returns the channel number. /// /// # Example /// ``` /// # use hls_m3u8::types::Channels; /// let mut channels = Channels::new(6); /// - /// assert_eq!(channels.first_parameter(), 6); + /// assert_eq!(channels.channel_number(), 6); /// ``` - pub const fn first_parameter(&self) -> u64 { self.first_parameter } + pub const fn channel_number(&self) -> u64 { self.channel_number } - /// Sets the first parameter. + /// Sets the channel number. /// /// # Example /// ``` /// # use hls_m3u8::types::Channels; /// let mut channels = Channels::new(3); /// - /// channels.set_first_parameter(6); - /// assert_eq!(channels.first_parameter(), 6) + /// channels.set_channel_number(6); + /// assert_eq!(channels.channel_number(), 6) /// ``` - pub fn set_first_parameter(&mut self, value: u64) -> &mut Self { - self.first_parameter = value; - self - } - - /// Returns the second parameter, if there is any! - /// - /// # Example - /// ``` - /// # use hls_m3u8::types::Channels; - /// let mut channels = Channels::new(3); - /// # assert_eq!(channels.second_parameter(), &None); - /// - /// channels.set_second_parameter(Some(vec!["AAC", "MP3"])); - /// assert_eq!( - /// channels.second_parameter(), - /// &Some(vec!["AAC".to_string(), "MP3".to_string()]) - /// ) - /// ``` - /// - /// # Note - /// Currently there is no use for this parameter. - pub const fn second_parameter(&self) -> &Option> { &self.second_parameter } - - /// Sets the second parameter. - /// - /// # Example - /// ``` - /// # use hls_m3u8::types::Channels; - /// let mut channels = Channels::new(3); - /// # assert_eq!(channels.second_parameter(), &None); - /// - /// channels.set_second_parameter(Some(vec!["AAC", "MP3"])); - /// assert_eq!( - /// channels.second_parameter(), - /// &Some(vec!["AAC".to_string(), "MP3".to_string()]) - /// ) - /// ``` - /// - /// # Note - /// Currently there is no use for this parameter. - pub fn set_second_parameter(&mut self, value: Option>) -> &mut Self { - self.second_parameter = value.map(|v| v.into_iter().map(|s| s.to_string()).collect()); + pub fn set_channel_number(&mut self, value: u64) -> &mut Self { + self.channel_number = value; self } } @@ -131,28 +77,23 @@ impl FromStr for Channels { fn from_str(input: &str) -> Result { let parameters = input.split('/').collect::>(); - let first_parameter = parameters + let channel_number = parameters .first() .ok_or_else(|| Error::missing_attribute("First parameter of channels!"))? .parse()?; - let second_parameter = parameters - .get(1) - .map(|v| v.split(',').map(|v| v.to_string()).collect()); - Ok(Self { - first_parameter, - second_parameter, + channel_number, + unknown: parameters[1..].iter().map(|v| v.to_string()).collect(), }) } } impl fmt::Display for Channels { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", self.first_parameter)?; - - if let Some(second) = &self.second_parameter { - write!(f, "/{}", second.join(","))?; + write!(f, "{}", self.channel_number)?; + if !self.unknown.is_empty() { + write!(f, "{}", self.unknown.join(","))?; } Ok(()) @@ -168,25 +109,13 @@ mod tests { let mut channels = Channels::new(6); assert_eq!(channels.to_string(), "6".to_string()); - channels.set_first_parameter(7); + channels.set_channel_number(7); assert_eq!(channels.to_string(), "7".to_string()); - - assert_eq!( - "6/P,K,J".to_string(), - Channels::new(6) - .set_second_parameter(Some(vec!["P", "K", "J"])) - .to_string() - ); } #[test] fn test_parser() { assert_eq!("6".parse::().unwrap(), Channels::new(6)); - let mut result = Channels::new(6); - result.set_second_parameter(Some(vec!["P", "K", "J"])); - - assert_eq!("6/P,K,J".parse::().unwrap(), result); - assert!("garbage".parse::().is_err()); assert!("".parse::().is_err()); }