Struct AbsolutePath

pub struct AbsolutePath(PathBuf);

A representation of an absolute path

AbsolutePath wraps a PathBuf, that is guaranteed to be absolute.

Examples

use std::{path::PathBuf, str::FromStr};

use alpm_types::{AbsolutePath, Error};

// Create AbsolutePath from &str
assert_eq!(
    AbsolutePath::from_str("/"),
    AbsolutePath::new(PathBuf::from("/"))
);
assert_eq!(
    AbsolutePath::from_str("./"),
    Err(Error::PathNotAbsolute(PathBuf::from("./")))
);

// Format as String
assert_eq!("/", format!("{}", AbsolutePath::from_str("/")?));

Tuple Fields

0: PathBuf

Implementations

impl AbsolutePath

pub fn new(path: PathBuf) -> Result<AbsolutePath, Error>

Create a new AbsolutePath

pub fn inner(&self) -> &Path

Return a reference to the inner type

Trait Implementations

impl Clone for AbsolutePath

fn clone(&self) -> AbsolutePath

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AbsolutePath

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

Formats the value using the given formatter.

impl Display for AbsolutePath

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

Formats the value using the given formatter.

impl FromStr for AbsolutePath

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

Parses an absolute path from a string

Errors

Returns an error if the path is not absolute

type Err = Error

The associated error which can be returned from parsing.

impl PartialEq for AbsolutePath

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

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 AbsolutePath

impl StructuralPartialEq for AbsolutePath