Enum RelationOrSoname 

pub enum RelationOrSoname {
    Relation(PackageRelation),
    SonameV1(SonameV1),
    SonameV2(SonameV2),
}

Provides either a PackageRelation or a SonameV1.

This enum is used for alpm-package-relations of type run-time dependency and provision in PackageInfoV1 or PackageInfoV2.

Variants

Relation(PackageRelation)

An alpm-package-relation.

SonameV1(SonameV1)

An alpm-sonamev1.

SonameV2(SonameV2)

An alpm-sonamev2.

Implementations

impl RelationOrSoname

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

Recognizes a SonameV2, a SonameV1 or a PackageRelation in a string slice.

First attempts to recognize a SonameV2, then a SonameV1 and if that fails, falls back to recognizing a PackageRelation. Depending on recognized type, a RelationOrSoname is created accordingly.

Trait Implementations

impl Clone for RelationOrSoname

fn clone(&self) -> RelationOrSoname

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RelationOrSoname

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

Formats the value using the given formatter.

impl Display for RelationOrSoname

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

Formats the value using the given formatter.

impl FromStr for RelationOrSoname

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

Creates a RelationOrSoname from a string slice.

Relies on RelationOrSoname::parser to recognize types in input and create a RelationOrSoname accordingly.

Errors

Returns an error if no RelationOrSoname can be created from input.

Examples

use alpm_pkginfo::RelationOrSoname;
use alpm_types::{PackageRelation, SonameV1, SonameV2};

let relation: RelationOrSoname = "example=1.0.0".parse()?;
assert_eq!(
    relation,
    RelationOrSoname::Relation(PackageRelation::new(
        "example".parse()?,
        Some("=1.0.0".parse()?)
    ))
);

let sonamev2: RelationOrSoname = "lib:example.so.1".parse()?;
assert_eq!(
    sonamev2,
    RelationOrSoname::SonameV2(SonameV2::new("lib".parse()?, "example.so.1".parse()?))
);

let sonamev1: RelationOrSoname = "example.so".parse()?;
assert_eq!(
    sonamev1,
    RelationOrSoname::SonameV1(SonameV1::new("example.so".parse()?, None, None)?)
);

type Err = Error

The associated error which can be returned from parsing.

impl PartialEq for RelationOrSoname

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

impl StructuralPartialEq for RelationOrSoname