Struct rust_release_channel::Channel

pub struct Channel {
    pub date: NaiveDate,
    pub pkg: BTreeMap<String, Package>,
    pub renames: BTreeMap<String, String>,
}

The metadata for a Rust release channel.

This data structure represents all the information available in a Rust release channel metadata file. You can create one from scratch with new(), or by parsing an official metadata file:

use std::fs;
use std::io::Read;

let mut handle = fs::File::open("examples/channel-rust-1.24.toml")?;
let mut buffer = String::new();
handle.read_to_string(&mut buffer);
let channel: rust_release_channel::Channel = buffer.parse()?;

Look at the pkg field to find out what packages are available from this channel. If you have something specific in mind, consult the .lookup_artefact() method.

Fields

date: NaiveDate

The creation date of the original metadata file, in YYYY-MM-DD format.

pkg: BTreeMap<String, Package>

The packages included in this channel.

Each key is the name of a package, the corresponding value is the metadata for that package.

renames: BTreeMap<String, String>

A mapping from old package names to new ones.

Sometimes packages get renamed. For the benefit of systems that have the old name recorded, this mapping allows them to look up the new name. Packages that have not been renamed should not appear in this map, and packages renamed multiple times should have each legacy name mapped to the current name.

Methods

impl Channel

pub fn new() -> Channel

Create a new, empty Channel whose creation date is today.

"today" means the current date in the local timezone.

let channel = rust_release_channel::Channel::new();

pub fn with_date(date: NaiveDate) -> Channel

Create a new, empty Channel whose creation date is set to the given value.

let channel = rust_release_channel::Channel::with_date(
    chrono::NaiveDate::from_ymd(2018, 2, 26),
);

pub fn to_string(&self) -> Result<String, Error>

Serialize this Channel to the standard metadata format.

If you write the resulting String to a file, it will be a standard channel metadata file.

let metadata_string = channel.to_string()?;

pub fn lookup_artefact<'s, 'q, T>(&'s self, query: T) -> Option<&'s Artefact> where     T: Into<ArtefactQuery<'q>>,

Find the Artefact for an ArtefactToken or ArtefactQuery.

If you found an ArtefactToken inside some other Artefact's components or extensions fields, you can pass it here to find out what artefact it was talking about.

If you're interested in some specific Artefact that might or might not be in this channel, you can create an ArtefactQuery and pass it here to find it if it exists.

If no artefact exists in this channel for the given package and target, this method will consult the renames map to see if the requested package is available under a new name. Note that the rename list is only checked once; this method will not follow a chain of renames, so the rename list should map each historical package name directly to the latest name for that package.

If there's still no matching artefact, this method returns None.

let query = rust_release_channel::ArtefactQuery::new(
    "rustc",
    "x86_64-unknown-linux-gnu",
);
channel.lookup_artefact(query)
    .map(|artefact| {
        println!("Rust for Linux available in these formats:");
        for each in artefact.standalone.keys() {
            println!("- {}", each);
        }
    });

pub fn validate<'a>(&'a self) -> Vec<ValidationError<'a>>

Validate the internal consistency of this metadata.

Specifically:

• If renames says a package named X was renamed to Y, then Y should exist in the pkg map and X should not.
• If a package is renamed, the new name must be different to the old name.
• Each component or extension in an Artefact should reference the name of a package in the channel's pkg map, and a target in that package's target map.
• The "components" links between artefacts must be acyclic; that is, an artefact must not include itself as a component, or include some other artefact that (directly or indirectly) includes it as a component.

Returns all detected problems.

let errors = channel.validate();
if !errors.is_empty() {
    println!("Errors found:");
    for each in errors {
        println!("  - {}", each);
    }
}

Trait Implementations

impl Serialize for Channel

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where     S: Serializer,

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for Channel

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where     D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Debug for Channel

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

Formats the value using the given formatter.

impl Clone for Channel

fn clone(&self) -> Channel

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq for Channel

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

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

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

This method tests for !=.

impl Eq for Channel

impl PartialOrd for Channel

fn partial_cmp(&self, other: &Channel) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Channel) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Channel) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Channel) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Channel) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Ord for Channel

fn cmp(&self, other: &Channel) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl Hash for Channel

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].

impl Default for Channel

fn default() -> Self

Returns the "default value" for a type.

impl FromStr for Channel

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Display for Channel

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.