Enum typed_path::unix::Utf8UnixComponent

pub enum Utf8UnixComponent<'a> {
    RootDir,
    CurDir,
    ParentDir,
    Normal(&'a str),
}

str slice version of std::path::Component that represents a Unix-specific component

Variants

RootDir

CurDir

ParentDir

Normal(&'a str)

Implementations

impl<'a> Utf8UnixComponent<'a>

pub fn from_utf8(component: &UnixComponent<'a>) -> Result<Self, Utf8Error>

Converts a non-UTF-8 UnixComponent to a UTF-8 Utf8UnixComponent by checking that the component contains valid UTF-8.

Errors

Returns Err if the component is not UTF-8 with a description as to why the provided component is not UTF-8.

Examples

Basic usage:

use typed_path::{Utf8Component, unix::{UnixComponent, Utf8UnixComponent}};

// some bytes, in a vector
let component = UnixComponent::Normal(&[240, 159, 146, 150]);

// We know these bytes are valid, so just use `unwrap()`.
let utf8_component = Utf8UnixComponent::from_utf8(&component).unwrap();

assert_eq!("💖", utf8_component.as_str());

Incorrect bytes:

use typed_path::unix::{UnixComponent, Utf8UnixComponent};

// some invalid bytes, in a vector
let component = UnixComponent::Normal(&[0, 159, 146, 150]);

assert!(Utf8UnixComponent::from_utf8(&component).is_err());

See the docs for Utf8Error for more details on the kinds of errors that can be returned.

pub unsafe fn from_utf8_unchecked(component: &UnixComponent<'a>) -> Self

Converts a non-UTF-8 UnixComponent to a UTF-8 Utf8UnixComponent without checking that the string contains valid UTF-8.

See the safe version, from_utf8, for more information.

Safety

The bytes passed in must be valid UTF-8.

Examples

Basic usage:

use typed_path::{Utf8Component, unix::{UnixComponent, Utf8UnixComponent}};

// some bytes, in a vector
let component = UnixComponent::Normal(&[240, 159, 146, 150]);

let utf8_component = unsafe {
    Utf8UnixComponent::from_utf8_unchecked(&component)
};

assert_eq!("💖", utf8_component.as_str());

impl<'a> Utf8UnixComponent<'a>

pub fn as_path<T>(&self) -> &Utf8Path<T>where
    T: for<'enc> Utf8Encoding<'enc>,

Returns path representing this specific component

Trait Implementations

impl AsRef<[u8]> for Utf8UnixComponent<'_>

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> AsRef<Utf8Path<T>> for Utf8UnixComponent<'_>where
    T: for<'enc> Utf8Encoding<'enc>,

fn as_ref(&self) -> &Utf8Path<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<str> for Utf8UnixComponent<'_>

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for Utf8UnixComponent<'a>

fn clone(&self) -> Utf8UnixComponent<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Utf8UnixComponent<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for Utf8UnixComponent<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for Utf8UnixComponent<'a>

fn cmp(&self, other: &Utf8UnixComponent<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<'a> PartialEq<Utf8UnixComponent<'a>> for Utf8UnixComponent<'a>

fn eq(&self, other: &Utf8UnixComponent<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd<Utf8UnixComponent<'a>> for Utf8UnixComponent<'a>

fn partial_cmp(&self, other: &Utf8UnixComponent<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> TryFrom<&'a str> for Utf8UnixComponent<'a>

fn try_from(path: &'a str) -> Result<Self, Self::Error>

Parses the str slice into a Utf8UnixComponent

Examples

use typed_path::unix::Utf8UnixComponent;
use std::convert::TryFrom;

// Supports parsing standard unix path components
assert_eq!(Utf8UnixComponent::try_from("/"), Ok(Utf8UnixComponent::RootDir));
assert_eq!(Utf8UnixComponent::try_from("."), Ok(Utf8UnixComponent::CurDir));
assert_eq!(Utf8UnixComponent::try_from(".."), Ok(Utf8UnixComponent::ParentDir));
assert_eq!(Utf8UnixComponent::try_from("file.txt"), Ok(Utf8UnixComponent::Normal("file.txt")));
assert_eq!(Utf8UnixComponent::try_from("dir/"), Ok(Utf8UnixComponent::Normal("dir")));

// Parsing more than one component will fail
assert!(Utf8UnixComponent::try_from("/file").is_err());

type Error = &'static str

The type returned in the event of a conversion error.

impl<'a> TryFrom<UnixComponent<'a>> for Utf8UnixComponent<'a>

type Error = Utf8Error

The type returned in the event of a conversion error.

fn try_from(component: UnixComponent<'a>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> Utf8Component<'a> for Utf8UnixComponent<'a>

fn as_str(&self) -> &'a str

Extracts the underlying str slice

Examples

use typed_path::{Utf8Component, Utf8UnixPath};

let path = Utf8UnixPath::new("/tmp/foo/../bar.txt");
let components: Vec<_> = path.components().map(|comp| comp.as_str()).collect();
assert_eq!(&components, &["/", "tmp", "foo", "..", "bar.txt"]);

fn is_root(&self) -> bool

Returns true if is the root dir component

Examples

use typed_path::{Utf8Component, unix::Utf8UnixComponent};
use std::convert::TryFrom;

let root_dir = Utf8UnixComponent::try_from("/").unwrap();
assert!(root_dir.is_root());

let normal = Utf8UnixComponent::try_from("file.txt").unwrap();
assert!(!normal.is_root());

fn is_normal(&self) -> bool

Returns true if is a normal component

Examples

use typed_path::{Utf8Component, unix::Utf8UnixComponent};
use std::convert::TryFrom;

let normal = Utf8UnixComponent::try_from("file.txt").unwrap();
assert!(normal.is_normal());

let root_dir = Utf8UnixComponent::try_from("/").unwrap();
assert!(!root_dir.is_normal());

fn len(&self) -> usize

Returns size of component in bytes

fn is_empty(&self) -> bool

Returns true if component represents an empty str

impl<'a> Copy for Utf8UnixComponent<'a>

impl<'a> Eq for Utf8UnixComponent<'a>

impl<'a> StructuralEq for Utf8UnixComponent<'a>

impl<'a> StructuralPartialEq for Utf8UnixComponent<'a>