Enum RelationOrSoname 

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

Provides either a PackageRelation, a SonameV1 or a SonameV2.

This enum is used for alpm-package-relations of type run-time dependency and provision e.g. in PKGINFO, SRCINFO or alpm-db-desc files.

Variants

Relation(PackageRelation)

A package relation (as PackageRelation).

SonameV1(SonameV1)

A shared object name following alpm-sonamev1.

SonameV2(SonameV2)

A shared object name following alpm-sonamev2.

Trait Implementations

impl AlpmParser for RelationOrSoname

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.

Errors

Returns an error if input does not begin with a valid SonameV2, SonameV1 or PackageRelation.

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 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<'de> Deserialize<'de> for RelationOrSoname

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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_types::{PackageRelation, RelationOrSoname, 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<PackageRelation> for RelationOrSoname

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

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

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

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 RelationOrSoname

impl StructuralPartialEq for RelationOrSoname