Struct OptionalDependency 

pub struct OptionalDependency {
    package_relation: PackageRelation,
    description: Option<String>,
}

An optional dependency for a package.

This type is used for representing dependencies that are not essential for base functionality of a package, but may be necessary to make use of certain features of a package.

An OptionalDependency consists of a package relation and an optional description separated by a colon (:).

• The package relation component must be a valid PackageRelation.
• If a description is provided it must be at least one character long.

Refer to alpm-package-relation of type optional dependency for details on the format.

Examples

use std::str::FromStr;

use alpm_types::{Name, OptionalDependency};

// Create OptionalDependency from &str
let opt_depend = OptionalDependency::from_str("example: this is an example dependency")?;

// Get the name
assert_eq!("example", opt_depend.name().as_ref());

// Get the description
assert_eq!(
    Some("this is an example dependency"),
    opt_depend.description().as_deref()
);

// Format as String
assert_eq!(
    "example: this is an example dependency",
    format!("{opt_depend}")
);

Fields

package_relation: PackageRelation

description: Option<String>

Implementations

impl OptionalDependency

pub fn new( package_relation: PackageRelation, description: Option<String>, ) -> OptionalDependency

Create a new OptionalDependency in a Result

pub fn name(&self) -> &Name

Return the name of the optional dependency

pub fn version_requirement(&self) -> &Option<VersionRequirement>

Return the version requirement of the optional dependency

pub fn description(&self) -> &Option<String>

Return the description for the optional dependency, if it exists

pub fn package_relation(&self) -> &PackageRelation

Returns a reference to the tracked PackageRelation.

Trait Implementations

impl AlpmParser for OptionalDependency

fn parser(input: &mut &str) -> ModalResult<Self>

Recognizes an OptionalDependency in a string slice.

This format is inherently flawed, as the : delimiter may exist in two different, optional places.

1. After the optional epoch
2. Before the optional description

The : delimiter may also appear inside the description, although that isn’t an issue during parsing.

why>=1:17.0.1-5: my dependency
is>=1:17.0.1-5
it>=17.0.1-5: my other dependency :::::
this: 1:17.0.1-5 my other dependency
way>1: 17.0.1-5 ambiguous.

Due to this, the parser disambiguates the two cases as follows:

• A : directly followed by a non-whitespace character is considered an epoch delimiter.
• A : followed by whitespace starts a description.

As such, ambiguous input like example>=1:foo bar is treated as containing an epoch and rejected, as foo bar is not a valid version. Input like example>=1: 3.2.1-5 foo bar is successfully parsed with the version being 1 and the description being 3.2.1-5 foo bar.

Errors

Returns an error if input is not a valid alpm-package-relation of type optional dependency.

fn delimiter_error_context<'a, O, P>( parser: P, ) -> impl Parser<&'a str, O, ErrMode<ContextError>>

where P: Parser<&'a str, O, ErrMode<ContextError>>,

Attaches a winnow error context to the parser when a parse error is encountered.

impl Clone for OptionalDependency

fn clone(&self) -> OptionalDependency

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OptionalDependency

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OptionalDependency

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for OptionalDependency

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

Formats the value using the given formatter.

impl FromStr for OptionalDependency

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

Creates a new OptionalDependency from a string slice.

Delegates to OptionalDependency::parser.

Errors

Returns an error if OptionalDependency::parser fails.

type Err = Error

The associated error which can be returned from parsing.

impl PartialEq for OptionalDependency

fn eq(&self, other: &OptionalDependency) -> 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 Serialize for OptionalDependency

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 OptionalDependency

impl StructuralPartialEq for OptionalDependency