Enum UnixComponent

pub enum UnixComponent<'a> {
    RootDir,
    CurDir,
    ParentDir,
    Normal(&'a [u8]),
}

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

Variants

RootDir

CurDir

ParentDir

Normal(&'a [u8])

Implementations

impl UnixComponent<'_>

pub fn as_path<T>(&self) -> &Path<T>

where T: Encoding,

Returns path representing this specific component

Trait Implementations

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

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

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

impl<T> AsRef<Path<T>> for UnixComponent<'_>

where T: Encoding,

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

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

impl<'a> Clone for UnixComponent<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Component<'a> for UnixComponent<'a>

fn as_bytes(&self) -> &'a [u8]

Extracts the underlying [[u8]] slice

Examples

use typed_path::{Component, UnixPath};

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

fn is_root(&self) -> bool

Returns true if is the root dir component

Examples

use typed_path::{Component, UnixComponent};
use std::convert::TryFrom;

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

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

fn is_normal(&self) -> bool

Returns true if is a normal component

Examples

use typed_path::{Component, UnixComponent};
use std::convert::TryFrom;

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

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

fn is_parent(&self) -> bool

Returns true if is a parent directory component

Examples

use typed_path::{Component, UnixComponent};
use std::convert::TryFrom;

let parent = UnixComponent::try_from("..").unwrap();
assert!(parent.is_parent());

let root_dir = UnixComponent::try_from("/").unwrap();
assert!(!root_dir.is_parent());

fn is_current(&self) -> bool

Returns true if is the current directory component

Examples

use typed_path::{Component, UnixComponent};
use std::convert::TryFrom;

let current = UnixComponent::try_from(".").unwrap();
assert!(current.is_current());

let root_dir = UnixComponent::try_from("/").unwrap();
assert!(!root_dir.is_current());

fn is_valid(&self) -> bool

Returns true if this component is valid.

A component can only be invalid if it represents a normal component with bytes that are disallowed by the encoding.

Examples

use typed_path::{Component, UnixComponent};

assert!(UnixComponent::RootDir.is_valid());
assert!(UnixComponent::ParentDir.is_valid());
assert!(UnixComponent::CurDir.is_valid());
assert!(UnixComponent::Normal(b"abc").is_valid());
assert!(!UnixComponent::Normal(b"\0").is_valid());

fn root() -> Self

Returns the root directory component.

Examples

use typed_path::{Component, UnixComponent};

assert_eq!(UnixComponent::root(), UnixComponent::RootDir);

fn parent() -> Self

Returns the parent directory component.

Examples

use typed_path::{Component, UnixComponent};

assert_eq!(UnixComponent::parent(), UnixComponent::ParentDir);

fn current() -> Self

Returns the current directory component.

Examples

use typed_path::{Component, UnixComponent};

assert_eq!(UnixComponent::current(), UnixComponent::CurDir);

fn len(&self) -> usize

Returns size of component in bytes

fn is_empty(&self) -> bool

Returns true if component represents an empty byte slice

impl<'a> Debug for UnixComponent<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for UnixComponent<'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 UnixComponent<'a>

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for UnixComponent<'a>

fn eq(&self, other: &UnixComponent<'a>) -> 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<'a> PartialOrd for UnixComponent<'a>

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> TryFrom<&'a [u8]> for UnixComponent<'a>

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

Parses the byte slice into a UnixComponent

Examples

use typed_path::UnixComponent;
use std::convert::TryFrom;

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

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

type Error = &'static str

The type returned in the event of a conversion error.

impl<'a, const N: usize> TryFrom<&'a [u8; N]> for UnixComponent<'a>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(path: &'a [u8; N]) -> Result<Self, Self::Error>

Performs the conversion.

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

type Error = &'static str

The type returned in the event of a conversion error.

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

Performs the conversion.

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

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

Attempts to convert a std::path::Component into a UnixComponent, returning a result containing the new component when successful or the original component when failed

Examples

use std::convert::TryFrom;
use std::ffi::OsStr;
use std::path::Component;
use typed_path::UnixComponent;

let component = UnixComponent::try_from(Component::RootDir).unwrap();
assert_eq!(component, UnixComponent::RootDir);

let component = UnixComponent::try_from(Component::CurDir).unwrap();
assert_eq!(component, UnixComponent::CurDir);

let component = UnixComponent::try_from(Component::ParentDir).unwrap();
assert_eq!(component, UnixComponent::ParentDir);

let component = UnixComponent::try_from(Component::Normal(OsStr::new("file.txt"))).unwrap();
assert_eq!(component, UnixComponent::Normal(b"file.txt"));

type Error = Component<'a>

The type returned in the event of a conversion error.

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

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

Attempts to convert a UnixComponent into a std::path::Component, returning a result containing the new path when successful or the original path when failed

Examples

use std::convert::TryFrom;
use std::ffi::OsStr;
use std::path::Component;
use typed_path::UnixComponent;

let component = Component::try_from(UnixComponent::RootDir).unwrap();
assert_eq!(component, Component::RootDir);

let component = Component::try_from(UnixComponent::CurDir).unwrap();
assert_eq!(component, Component::CurDir);

let component = Component::try_from(UnixComponent::ParentDir).unwrap();
assert_eq!(component, Component::ParentDir);

let component = Component::try_from(UnixComponent::Normal(b"file.txt")).unwrap();
assert_eq!(component, Component::Normal(OsStr::new("file.txt")));

type Error = UnixComponent<'a>

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> Copy for UnixComponent<'a>

impl<'a> Eq for UnixComponent<'a>

impl<'a> StructuralPartialEq for UnixComponent<'a>