Struct ArtefactQuery

pub struct ArtefactQuery<'a> {
    pub pkg: &'a str,
    pub target: &'a str,
}

Names an Artefact that might exist in a channel.

This structure provides a way to talk about and refer to artefacts without having to find an already-existing ArtefactToken, or construct a whole new one.

let query = rust_release_channel::ArtefactQuery::new(
    "rust",
    "x86_64-unknown-linux-gnu",
);
let artefact = channel.lookup_artefact(query);

Fields

pkg: &'a str

The name of the package that was built to produce the target artefact.

See Channel::pkg for details.

target: &'a str

The name of the target the package was built for to produce the target artefact.

See Package::target for details.

Implementations

impl<'a> ArtefactQuery<'a>

pub fn new(pkg: &'a str, target: &'a str) -> ArtefactQuery<'a>

Create a new ArtefactQuery for the given package and target.

pkg is the name of the package that was built to produce the target artefact.

target is the name of the target the package was built for to produce the target artefact.

let query = rust_release_channel::ArtefactQuery::new(
    "somepackage",
    "aarch64-unknown-linux-gnu",
);

pub fn to_token(&self) -> ArtefactToken

Create an ArtefactToken with the same contents.

This allocates new copies of the pkg and target fields so that the new ArtefactToken struct can own them.

This is effectively the same thing as:

let token = rust_release_channel::ArtefactToken::new(
    query.pkg.into(),
    query.target.into(),
);

An example:

let token = rust_release_channel::ArtefactQuery::new(
    "rls",
    "x86_64-unknown-linux-gnu",
).to_token();

artefact.extensions.push(token);

Trait Implementations

impl<'a> Clone for ArtefactQuery<'a>

fn clone(&self) -> ArtefactQuery<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ArtefactQuery<'a>

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

Formats the value using the given formatter.

impl<'de: 'a, 'a> Deserialize<'de> for ArtefactQuery<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> Display for ArtefactQuery<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a ArtefactToken> for ArtefactQuery<'a>

fn from(src: &'a ArtefactToken) -> ArtefactQuery<'a>

Converts to this type from the input type.

impl<'a> Hash for ArtefactQuery<'a>

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<'a> Ord for ArtefactQuery<'a>

fn cmp(&self, other: &ArtefactQuery<'a>) -> 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<'a> PartialEq<ArtefactQuery<'a>> for ArtefactToken

fn eq(&self, other: &ArtefactQuery<'a>) -> 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<'a> PartialEq<ArtefactToken> for ArtefactQuery<'a>

fn eq(&self, other: &ArtefactToken) -> 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<'a> PartialEq for ArtefactQuery<'a>

fn eq(&self, other: &ArtefactQuery<'a>) -> 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<'a> PartialOrd for ArtefactQuery<'a>

fn partial_cmp(&self, other: &ArtefactQuery<'a>) -> 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<'a> Serialize for ArtefactQuery<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Copy for ArtefactQuery<'a>

impl<'a> Eq for ArtefactQuery<'a>

impl<'a> StructuralPartialEq for ArtefactQuery<'a>