Struct 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.

Implementations

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 Clone for Channel

fn clone(&self) -> Channel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Channel

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

Formats the value using the given formatter.

impl Default for Channel

fn default() -> Self

Returns the “default value” for a type.

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 Display for Channel

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

Formats the value using the given formatter.

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 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, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Channel

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

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 Eq for Channel

impl StructuralPartialEq for Channel