Enum Utf8WindowsComponent

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

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

Variants

Prefix(Utf8WindowsPrefixComponent<'a>)

RootDir

CurDir

ParentDir

Normal(&'a str)

Implementations

impl<'a> Utf8WindowsComponent<'a>

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

where T: Utf8Encoding,

Returns path representing this specific component

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

Converts a non-UTF-8 WindowsComponent to a UTF-8 Utf8WindowsComponent 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, WindowsComponent, Utf8WindowsComponent};

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

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

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

Incorrect bytes:

use typed_path::{WindowsComponent, Utf8WindowsComponent};

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

assert!(Utf8WindowsComponent::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: &WindowsComponent<'a>) -> Self

Converts a non-UTF-8 WindowsComponent to a UTF-8 Utf8WindowsComponent 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, WindowsComponent, Utf8WindowsComponent};

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

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

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

pub fn is_prefix(&self) -> bool

Returns true if represents a prefix

pub fn prefix(self) -> Option<Utf8WindowsPrefixComponent<'a>>

Converts from Utf8WindowsComponent to Option<Utf8WindowsPrefixComponent>

Converts self into an Option<Utf8WindowsPrefixComponent>, consuming self, and discarding if not a Utf8WindowsPrefixComponent

pub fn prefix_kind(self) -> Option<Utf8WindowsPrefix<'a>>

Converts from Utf8WindowsComponent to Option<Utf8WindowsPrefix>

Converts self into an Option<Utf8WindowsPrefix>, consuming self, and discarding if not a Utf8WindowsPrefixComponent whose kind method we invoke

Trait Implementations

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

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

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

impl<T> AsRef<Utf8Path<T>> for Utf8WindowsComponent<'_>

where T: Utf8Encoding,

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

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

impl AsRef<str> for Utf8WindowsComponent<'_>

fn as_ref(&self) -> &str

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

impl<'a> Clone for Utf8WindowsComponent<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Utf8WindowsComponent<'a>

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

Formats the value using the given formatter.

impl Display for Utf8WindowsComponent<'_>

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

Formats the value using the given formatter.

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

fn cmp(&self, other: &Utf8WindowsComponent<'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 Utf8WindowsComponent<'a>

fn eq(&self, other: &Utf8WindowsComponent<'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 Utf8WindowsComponent<'a>

fn partial_cmp(&self, other: &Utf8WindowsComponent<'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 str> for Utf8WindowsComponent<'a>

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

Parses the byte slice into a Utf8WindowsComponent

Examples

use typed_path::{Utf8WindowsComponent, Utf8WindowsPrefix};
use std::convert::TryFrom;

// Supports parsing Windows prefixes
let component = Utf8WindowsComponent::try_from("c:").unwrap();
assert_eq!(component.prefix_kind(), Some(Utf8WindowsPrefix::Disk('C')));

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

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

type Error = &'static str

The type returned in the event of a conversion error.

impl<'a> Utf8Component<'a> for Utf8WindowsComponent<'a>

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

Extracts the underlying str slice

Examples

use typed_path::{Utf8Component, Utf8WindowsPath};

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

fn is_root(&self) -> bool

Root is one of two situations

• Is the root separator, e.g. \windows
• Is a non-disk prefix, e.g. \\server\share

Examples

use typed_path::{Utf8Component, Utf8WindowsComponent};
use std::convert::TryFrom;

let root_dir = Utf8WindowsComponent::try_from(r"\").unwrap();
assert!(root_dir.is_root());

let non_disk_prefix = Utf8WindowsComponent::try_from(r"\\?\pictures").unwrap();
assert!(non_disk_prefix.is_root());

let disk_prefix = Utf8WindowsComponent::try_from("C:").unwrap();
assert!(!disk_prefix.is_root());

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

fn is_normal(&self) -> bool

Returns true if component is normal

Examples

use typed_path::{Utf8Component, Utf8WindowsComponent};
use std::convert::TryFrom;

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

let root_dir = Utf8WindowsComponent::try_from(r"\").unwrap();
assert!(!root_dir.is_normal());

fn is_parent(&self) -> bool

Returns true if is a parent directory component

Examples

use typed_path::{Utf8Component, Utf8WindowsComponent};
use std::convert::TryFrom;

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

let root_dir = Utf8WindowsComponent::try_from(r"\").unwrap();
assert!(!root_dir.is_parent());

fn is_current(&self) -> bool

Returns true if is the current directory component

Examples

use typed_path::{Utf8Component, Utf8WindowsComponent};
use std::convert::TryFrom;

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

let root_dir = Utf8WindowsComponent::try_from(r"\").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 characters that are disallowed by the encoding.

Examples

use typed_path::{Utf8Component, Utf8WindowsComponent};
use std::convert::TryFrom;

assert!(Utf8WindowsComponent::try_from("c:").unwrap().is_valid());
assert!(Utf8WindowsComponent::RootDir.is_valid());
assert!(Utf8WindowsComponent::ParentDir.is_valid());
assert!(Utf8WindowsComponent::CurDir.is_valid());
assert!(Utf8WindowsComponent::Normal("abc").is_valid());
assert!(!Utf8WindowsComponent::Normal("|").is_valid());

fn root() -> Self

Returns the root directory component.

Examples

use typed_path::{Utf8Component, Utf8WindowsComponent};

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

fn parent() -> Self

Returns the parent directory component.

Examples

use typed_path::{Utf8Component, Utf8WindowsComponent};

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

fn current() -> Self

Returns the current directory component.

Examples

use typed_path::{Utf8Component, Utf8WindowsComponent};

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

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 Utf8WindowsComponent<'a>

impl<'a> Eq for Utf8WindowsComponent<'a>

impl<'a> StructuralPartialEq for Utf8WindowsComponent<'a>