Struct Packager

pub struct Packager { /* private fields */ }

A packager of a package

A Packager is represented by a User ID (e.g. "Foobar McFooFace <foobar@mcfooface.org>"). Internally this struct wraps a String for the name and an EmailAddress for a valid email address.

Examples

use std::str::FromStr;

use alpm_types::{Error, Packager};

// create Packager from &str
let packager = Packager::from_str("Foobar McFooface <foobar@mcfooface.org>")?;

// get name
assert_eq!("Foobar McFooface", packager.name());

// get email
assert_eq!("foobar@mcfooface.org", packager.email().to_string());

// get email domain
assert_eq!("mcfooface.org", packager.email().domain());

// format as String
assert_eq!(
    "Foobar McFooface <foobar@mcfooface.org>",
    format!("{}", packager)
);

Implementations

impl Packager

pub fn new(name: String, email: EmailAddress) -> Packager

Create a new Packager

pub fn name(&self) -> &str

Return the name of the Packager

pub fn email(&self) -> &EmailAddress

Return the email of the Packager

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

Parses a Packager from a string slice.

Consumes all of its input.

Examples

See Self::from_str for code examples.

Errors

Returns an error if input does not represent a valid Packager.

Trait Implementations

impl Clone for Packager

fn clone(&self) -> Packager

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Packager

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

Formats the value using the given formatter.

impl Display for Packager

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

Formats the value using the given formatter.

impl FromStr for Packager

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

Create a Packager from a string

type Err = Error

The associated error which can be returned from parsing.

impl PartialEq for Packager

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

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 Packager

impl StructuralPartialEq for Packager