Struct rss::Channel [−] [src]

pub struct Channel { /* fields omitted */ }

A representation of the <channel> element.

Methods

`impl Channel`
[src]

`fn title(&self) -> &str`

Get the title that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let title = "The Linux Action Show! OGG";

let channel = ChannelBuilder::new()
    .title(title)
    .finalize()
    .unwrap();

assert_eq!(title.to_string(), channel.title());

`fn link(&self) -> &str`

Get the link that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let link = "http://www.jupiterbroadcasting.com/";

let channel = ChannelBuilder::new()
    .link(link)
    .finalize()
    .unwrap();

assert_eq!(link.to_string(), channel.link());

`fn description(&self) -> &str`

Get the description that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let description = "Ogg Vorbis audio versions of The Linux ".to_string()
+ "Action Show! A show that covers everything geeks care about in the "
+ "computer industry. Get a solid dose of Linux, gadgets, news events "
+ "and much more!";

let channel = ChannelBuilder::new()
    .description(description.as_ref())
    .finalize()
    .unwrap();

assert_eq!(description.to_string(), channel.description());

`fn language(&self) -> Option<&str>`

Get the optional language that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let language_string = "en";

let channel = ChannelBuilder::new()
    .language(Some(language_string.to_string()))
    .finalize()
    .unwrap();

assert_eq!(Some(language_string), channel.language());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .language(None)
    .finalize()
    .unwrap();

assert!(channel.language().is_none());

`fn copyright(&self) -> Option<&str>`

Get the optional copyright that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let copyright_string =
    "Copyright 2002, Spartanburg Herald-Journal";

let channel = ChannelBuilder::new()
    .copyright(Some(copyright_string.to_string()))
    .finalize()
    .unwrap();

assert_eq!(Some(copyright_string), channel.copyright());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .copyright(None)
    .finalize()
    .unwrap();

assert!(channel.copyright().is_none());

`fn managing_editor(&self) -> Option<&str>`

Get the optional managing editor that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let managing_editor_string =
    "chris@jupiterbroadcasting.com (Chris Fisher)";

let channel = ChannelBuilder::new()
    .managing_editor(Some(managing_editor_string.to_string()))
    .finalize()
    .unwrap();

assert_eq!(Some(managing_editor_string), channel.managing_editor());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .managing_editor(None)
    .finalize()
    .unwrap();

assert!(channel.managing_editor().is_none());

`fn webmaster(&self) -> Option<&str>`

Get the optional web master that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let webmaster_string =
    "chris@jupiterbroadcasting.com (Chris Fisher)";

let channel = ChannelBuilder::new()
    .webmaster(Some(webmaster_string.to_string()))
    .finalize()
    .unwrap();

assert_eq!(Some(webmaster_string), channel.webmaster());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .webmaster(None)
    .finalize()
    .unwrap();

assert!(channel.webmaster().is_none());

`fn pub_date(&self) -> Option<&str>`

Get the optional pub date that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let pub_date = "Sun, 13 Mar 2016 20:02:02 -0700";

let channel = ChannelBuilder::new()
    .pub_date(Some(pub_date.to_string()))
    .finalize()
    .unwrap();

assert_eq!(Some(pub_date), channel.pub_date());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .pub_date(None)
    .finalize()
    .unwrap();

assert!(channel.pub_date().is_none());

`fn last_build_date(&self) -> Option<&str>`

Get the optional last build date that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let last_build_date = "Sun, 13 Mar 2016 20:02:02 -0700";

let channel = ChannelBuilder::new()
    .last_build_date(Some(last_build_date.to_string()))
    .finalize()
    .unwrap();

let local = channel.last_build_date();
assert!(local.is_some());

assert_eq!(Some(last_build_date), channel.last_build_date());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .last_build_date(None)
    .finalize()
    .unwrap();

assert!(channel.last_build_date().is_none());

`fn categories(&self) -> &[Category]`

Get the categories that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel, CategoryBuilder};

let category_1 = CategoryBuilder::new()
    .domain(None)
    .name("Media")
    .finalize()
    .unwrap();

let category_2 = CategoryBuilder::new()
    .domain(Some("http://jupiterbroadcasting.com".to_string()))
    .name("Podcast")
    .finalize()
    .unwrap();

let categories_vec = vec![category_1, category_2];

let channel = ChannelBuilder::new()
    .categories(categories_vec.clone())
    .finalize()
    .unwrap();

let categories = channel.categories();
assert!(!categories.is_empty());

assert_eq!(categories_vec.clone().len(), categories.len());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .categories(Vec::new())
    .finalize()
    .unwrap();

assert!(channel.categories().is_empty());

`fn generator(&self) -> Option<&str>`

Get the optional generator that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let generator_string = "Feeder 2.5.12(2294); Mac OS X Version 10.9.5 (Build 13F34)
http://reinventedsoftware.com/feeder/";

let channel = ChannelBuilder::new()
    .generator(Some(generator_string.to_string()))
    .finalize()
    .unwrap();

assert_eq!(Some(generator_string), channel.generator());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .generator(None)
    .finalize()
    .unwrap();

assert!(channel.generator().is_none());

`fn docs(&self) -> Option<&str>`

Get the optional docs that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let docs_string = "http://blogs.law.harvard.edu/tech/rss/";

let channel = ChannelBuilder::new()
    .docs(Some(docs_string.to_string()))
    .finalize()
    .unwrap();

let docs_option = channel.docs();
assert!(docs_option.is_some());

assert_eq!(Some(docs_string), channel.docs());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .docs(None)
    .finalize()
    .unwrap();

assert!(channel.docs().is_none());

`fn cloud(&self) -> Option<&Cloud>`

Get the optional cloud that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel, CloudBuilder};

let cloud = CloudBuilder::new()
    .domain("http://rpc.sys.com/")
    .port(80)
    .path("/RPC2")
    .register_procedure("pingMe")
    .protocol("soap")
    .finalize()
    .unwrap();

let channel = ChannelBuilder::new()
    .cloud(Some(cloud))
    .finalize()
    .unwrap();

assert!(channel.cloud().is_some());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .cloud(None)
    .finalize()
    .unwrap();

assert!(channel.cloud().is_none());

`fn ttl(&self) -> Option<&str>`

Get the optional ttl that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let ttl_num = 60;

let channel = ChannelBuilder::new()
    .ttl(Some(ttl_num))
    .finalize()
    .unwrap();

assert_eq!(Some(ttl_num.to_string().as_str()), channel.ttl());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .ttl(None)
    .finalize()
    .unwrap();

assert!(channel.ttl().is_none());

`fn image(&self) -> Option<&Image>`

Get the optional image that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel, ImageBuilder};

let image = ImageBuilder::new()
    .link("http://www.jupiterbroadcasting.com")
    .url("http://jupiterbroadcasting.com/images/LAS-300-Badge.jpg")
    .title("LAS 300 Logo")
    .height(None)
    .width(None)
    .description(None)
    .finalize()
    .unwrap();

let channel = ChannelBuilder::new()
    .image(Some(image))
    .link("http://www.jupiterbroadcasting.com/")
    .finalize()
    .unwrap();

assert!(channel.image().is_some());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .image(None)
    .link("http://www.jupiterbroadcasting.com/")
    .finalize()
    .unwrap();

assert!(channel.image().is_none());

`fn rating(&self) -> Option<&str>`

Get the optional rating that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .rating(None)
    .link("http://www.jupiterbroadcasting.com/")
    .finalize()
    .unwrap();

assert!(channel.rating().is_none());

`fn text_input(&self) -> Option<&TextInput>`

Get the optional text input that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel, TextInputBuilder};

let text_input = TextInputBuilder::new()
    .title("Enter Comment")
    .description("Provided Feedback")
    .name("Comment")
    .link("http://www.example.com/feedback")
    .finalize()
    .unwrap();

let channel = ChannelBuilder::new()
    .text_input(Some(text_input))
    .link("http://www.jupiterbroadcasting.com/")
    .finalize()
    .unwrap();

assert!(channel.text_input().is_some());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .text_input(None)
    .link("http://www.jupiterbroadcasting.com/")
    .finalize()
    .unwrap();

assert!(channel.text_input().is_none());

`fn skip_hours(&self) -> &[String]`

Get the skip hours that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let skip_hours_vec: Vec<i64> = vec![6,7,8,14,22];

let channel = ChannelBuilder::new()
    .skip_hours(skip_hours_vec.clone())
    .link("http://www.jupiterbroadcasting.com/")
    .finalize()
    .unwrap();

let skip_hours  = channel.skip_hours();
assert!(!skip_hours.is_empty());

let len = skip_hours_vec.clone().len();
assert_eq!(len, skip_hours.len());

for x in 0..len {
    assert_eq!(skip_hours_vec[x].to_string(), skip_hours[x]);
}

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .skip_hours(Vec::new())
    .link("http://www.jupiterbroadcasting.com/")
    .finalize()
    .unwrap();

assert!(channel.skip_hours().is_empty());

`fn skip_days(&self) -> &[String]`

Get the skip days that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel};

let skip_days_vec: Vec<String> = vec!["Monday".to_string(),
"Sunday".to_string(), "Thursday".to_owned(),
    "Wednesday".to_string()];

let channel = ChannelBuilder::new()
    .skip_days(skip_days_vec.clone())
    .link("http://www.jupiterbroadcasting.com/")
    .finalize()
    .unwrap();

let skip_days = channel.skip_days();
assert!(!skip_days.is_empty());

let len = skip_days_vec.clone().len();
assert_eq!(len, skip_days.len());

for x in 0..len {
    assert_eq!(skip_days_vec[x], skip_days[x].clone());
}

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .skip_days(Vec::new())
    .link("http://www.jupiterbroadcasting.com/")
    .finalize()
    .unwrap();

assert!(channel.skip_days().is_empty());

`fn items(&self) -> &[Item]`

Get the items that exists under Channel.

Examples

use rss::{ChannelBuilder, Channel, ItemBuilder};

let link = "http://www.jupiterbroadcasting.com/97561/".to_string()
+ "making-music-with-linux-las-408/";

let description = "<![CDATA[<p>In special Rasberry Pi 3 ".to_string()
+ "edition of the show we look at the new hardware, review & chat with "
+ "Mycroft CTO Ryan Sipes on how important the Raspberry Pi is for "
+ "development of their open artificial intelligence platform & get "
+ "the latest news.</p><p>Plus replacing Spotify on Linux, the new "
+ "Microsoft lock-in, our hosts face a moral quandary & more!</p>]]>";

let title = "Making Music with Linux | LAS 408".to_string();

let item_1 = ItemBuilder::new()
    .title(Some(title))
    .link(Some(link))
    .description(None)
    .author(None)
    .categories(Vec::new())
    .enclosure(None)
    .guid(None)
    .pub_date(None)
    .source(None)
    .finalize()
    .unwrap();

let item_2 = ItemBuilder::new()
    .title(None)
    .link(None)
    .description(Some(description))
    .author(None)
    .categories(Vec::new())
    .enclosure(None)
    .guid(None)
    .pub_date(None)
    .source(None)
    .finalize()
    .unwrap();

let items_vec = vec![item_1, item_2];

let channel = ChannelBuilder::new()
    .items(items_vec.clone())
    .link("http://www.jupiterbroadcasting.com/")
    .finalize()
    .unwrap();

let items = channel.items();
assert!(!items.is_empty());

assert_eq!(items_vec.clone().len(), items.len());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .items(Vec::new())
    .link("http://www.jupiterbroadcasting.com/")
    .finalize()
    .unwrap();

assert!(channel.items().is_empty());

`fn itunes_ext(&self) -> Option<&ITunesChannelExtension>`

Get the optional ITunesChannelExtension under Channel.

Examples

use rss::{ChannelBuilder, Channel};
use rss::extension::itunes::{ITunesChannelExtensionBuilder,
ITunesOwnerBuilder, ITunesCategoryBuilder};

let owner = ITunesOwnerBuilder::new()
    .email(Some("email@example.com".to_string()))
    .name(Some("name".to_string()))
    .finalize()
    .unwrap();

let subcategory = ITunesCategoryBuilder::new()
    .text("text")
    .finalize()
    .unwrap();

let category = ITunesCategoryBuilder::new()
    .text("text")
    .subcategory(Some(Box::new(subcategory)))
    .finalize()
    .unwrap();

let categories = vec![category];

let itunes_channel = ITunesChannelExtensionBuilder::new()
    .author(Some("author".to_string()))
    .block(Some("block".to_string()))
    .image(Some("image".to_string()))
    .explicit(Some("explicit".to_string()))
    .subtitle(Some("subtitle".to_string()))
    .summary(Some("summary".to_string()))
    .keywords(Some("keywords".to_string()))
    .new_feed_url(Some("new_feed_url".to_string()))
    .complete(Some("complete".to_string()))
    .owner(Some(owner))
    .categories(categories)
    .finalize()
    .unwrap();

let channel = ChannelBuilder::new()
    .itunes_ext(Some(itunes_channel))
    .finalize()
    .unwrap();

assert!(channel.itunes_ext().is_some());

use rss::{ChannelBuilder, Channel};

let channel = ChannelBuilder::new()
    .itunes_ext(None)
    .finalize()
    .unwrap();

assert!(channel.itunes_ext().is_none());

`fn dublin_core_ext(&self) -> Option<&DublinCoreExtension>`

Get the optional DublinCoreExtension under Channel.

`fn extensions(&self) -> &ExtensionMap`

Get the ExtensionMap under Channel.

`fn namespaces(&self) -> &HashMap<String, String>`

Get the namespaces under Channel.

`impl Channel`
[src]

`fn read_from<R: BufRead>(reader: R) -> Result<Channel, Error>`

Attempt to read the RSS channel from the speficied reader.

Example

let reader: BufRead = ...;
let channel = Channel::read_from(reader).unwrap();

`fn write_to<W: Write>(&self, writer: W) -> Result<W, Error>`

Attempt to write the RSS channel as XML to the speficied writer.

Example

let channel: Channel = ...;
let writer: Write = ...;
channel.write_to(writer).unwrap();

`fn validate(&self) -> Result<Channel, Error>`

Validate Channel

Examples

extern crate rss;

use rss::Channel;

fn main()
{
    let input = include_str!("tests/data/rss2sample.xml");

    let channel = input.parse::<Channel>().unwrap();
    channel.validate().unwrap();
}

Trait Implementations

`impl Debug for Channel`
[src]

`fn fmt(&self, __arg_0: &mut Formatter) -> Result`

Formats the value using the given formatter.

`impl Default for Channel`
[src]

`fn default() -> Channel`

Returns the "default value" for a type. Read more

`impl Clone for Channel`
[src]

`fn clone(&self) -> Channel`

Returns a copy of the value. Read more

`fn clone_from(&mut self, source: &Self)`
1.0.0

Performs copy-assignment from source. Read more

`impl PartialEq for Channel`
[src]

`fn eq(&self, __arg_0: &Channel) -> bool`

This method tests for self and other values to be equal, and is used by ==. Read more

`fn ne(&self, __arg_0: &Channel) -> bool`

This method tests for !=.

`impl ToString for Channel`
[src]

`fn to_string(&self) -> String`

Converts the given value to a String. Read more

`impl FromStr for Channel`
[src]

`type Err = Error`

The associated error which can be returned from parsing.

`fn from_str(s: &str) -> Result<Channel, Error>`

Attempt to read the RSS channel from the speficied str.

Struct rss::Channel [−] [src]

Methods

impl Channel[src]

fn title(&self) -> &str

fn link(&self) -> &str

fn description(&self) -> &str

fn language(&self) -> Option<&str>

fn copyright(&self) -> Option<&str>

fn managing_editor(&self) -> Option<&str>

fn webmaster(&self) -> Option<&str>

fn pub_date(&self) -> Option<&str>

fn last_build_date(&self) -> Option<&str>

fn categories(&self) -> &[Category]

fn generator(&self) -> Option<&str>

fn docs(&self) -> Option<&str>

fn cloud(&self) -> Option<&Cloud>

fn ttl(&self) -> Option<&str>

fn image(&self) -> Option<&Image>

fn rating(&self) -> Option<&str>

fn text_input(&self) -> Option<&TextInput>

fn skip_hours(&self) -> &[String]

fn skip_days(&self) -> &[String]

fn items(&self) -> &[Item]

fn itunes_ext(&self) -> Option<&ITunesChannelExtension>

fn dublin_core_ext(&self) -> Option<&DublinCoreExtension>

fn extensions(&self) -> &ExtensionMap

fn namespaces(&self) -> &HashMap<String, String>

impl Channel[src]

fn read_from<R: BufRead>(reader: R) -> Result<Channel, Error>

fn write_to<W: Write>(&self, writer: W) -> Result<W, Error>

fn validate(&self) -> Result<Channel, Error>

Trait Implementations

impl Debug for Channel[src]

fn fmt(&self, __arg_0: &mut Formatter) -> Result

impl Default for Channel[src]

fn default() -> Channel

impl Clone for Channel[src]

fn clone(&self) -> Channel

fn clone_from(&mut self, source: &Self)1.0.0

impl PartialEq for Channel[src]

fn eq(&self, __arg_0: &Channel) -> bool

fn ne(&self, __arg_0: &Channel) -> bool

impl ToString for Channel[src]

fn to_string(&self) -> String

impl FromStr for Channel[src]

type Err = Error

fn from_str(s: &str) -> Result<Channel, Error>

`impl Channel`
[src]

`fn title(&self) -> &str`

`fn link(&self) -> &str`

`fn description(&self) -> &str`

`fn language(&self) -> Option<&str>`

`fn copyright(&self) -> Option<&str>`

`fn managing_editor(&self) -> Option<&str>`

`fn webmaster(&self) -> Option<&str>`

`fn pub_date(&self) -> Option<&str>`

`fn last_build_date(&self) -> Option<&str>`

`fn categories(&self) -> &[Category]`

`fn generator(&self) -> Option<&str>`

`fn docs(&self) -> Option<&str>`

`fn cloud(&self) -> Option<&Cloud>`

`fn ttl(&self) -> Option<&str>`

`fn image(&self) -> Option<&Image>`

`fn rating(&self) -> Option<&str>`

`fn text_input(&self) -> Option<&TextInput>`

`fn skip_hours(&self) -> &[String]`

`fn skip_days(&self) -> &[String]`

`fn items(&self) -> &[Item]`

`fn itunes_ext(&self) -> Option<&ITunesChannelExtension>`

`fn dublin_core_ext(&self) -> Option<&DublinCoreExtension>`

`fn extensions(&self) -> &ExtensionMap`

`fn namespaces(&self) -> &HashMap<String, String>`

`impl Channel`
[src]

`fn read_from<R: BufRead>(reader: R) -> Result<Channel, Error>`

`fn write_to<W: Write>(&self, writer: W) -> Result<W, Error>`

`fn validate(&self) -> Result<Channel, Error>`

`impl Debug for Channel`
[src]

`fn fmt(&self, __arg_0: &mut Formatter) -> Result`

`impl Default for Channel`
[src]

`fn default() -> Channel`

`impl Clone for Channel`
[src]

`fn clone(&self) -> Channel`

`fn clone_from(&mut self, source: &Self)`
1.0.0

`impl PartialEq for Channel`
[src]

`fn eq(&self, __arg_0: &Channel) -> bool`

`fn ne(&self, __arg_0: &Channel) -> bool`

`impl ToString for Channel`
[src]

`fn to_string(&self) -> String`

`impl FromStr for Channel`
[src]

`type Err = Error`

`fn from_str(s: &str) -> Result<Channel, Error>`