Struct UnixStr

pub struct UnixStr(/* private fields */);

Implementations

impl UnixStr

pub const EMPTY: &'static UnixStr

pub const unsafe fn from_str_unchecked(s: &str) -> &UnixStr

Safety

&str needs to be null terminated or downstream UB may occur

pub const unsafe fn from_bytes_unchecked(s: &[u8]) -> &UnixStr

Safety

&[u8] needs to be null terminated or downstream UB may occur

pub const fn from_str_checked(s: &str) -> &UnixStr

Const instantiation of a &UnixStr from a &str. Should only be used in a const-context, although rustc does not let me enforce this.

Panics

This method panics since it’s supposed to produce a comptime error, it’s not particularly efficient.

pub fn try_from_str(s: &str) -> Result<&UnixStr, Error>

Create a &UnixStr from a &str.

Errors

String isn’t properly null terminated.

pub fn try_from_bytes(s: &[u8]) -> Result<&UnixStr, Error>

Create a &UnixStr from a &[u8].

Errors

Slice isn’t properly null terminated.

pub unsafe fn from_ptr<'a>(s: *const u8) -> &'a UnixStr

Safety

s needs to be null terminated

pub fn as_str(&self) -> Result<&str, Error>

Try to convert this &UnixStr to a utf8 &str

Errors

Not utf8

pub const fn as_slice(&self) -> &[u8]

Get this &UnixStr as a slice, including the null byte

pub fn len(&self) -> usize

Get the length of this &UnixStr, including the null byte

pub fn as_ptr(&self) -> *const u8

Get the length of this &UnixStr, including the null byte

pub fn match_up_to(&self, other: &UnixStr) -> usize

pub fn match_up_to_str(&self, other: &str) -> usize

pub fn find(&self, other: &UnixStr) -> Option<usize>

pub fn find_buf(&self, other: &[u8]) -> Option<usize>

pub fn ends_with(&self, other: &UnixStr) -> bool

pub fn path_file_name(&self) -> Option<&UnixStr>

Get the last component of a path, if possible.

Example

use rusl::string::unix_str::UnixStr;
use rusl::unix_lit;
fn get_file_paths() {
    // Has no filename, just a root path
    let a = unix_lit!("/");
    assert_eq!(None, a.path_file_name());
    // Has a 'filename'
    let a = unix_lit!("/etc");
    assert_eq!(Some(unix_lit!("etc")), a.path_file_name());
}

pub fn path_join(&self, ext: &UnixStr) -> UnixString

Joins this UnixStr with some other UnixStr adding a slash if necessary. Will make sure that there’s at most one slash at the boundary but won’t check either string for “path validity” in any other case

Example

use rusl::string::unix_str::UnixStr;
fn join_paths() {
    // Combines slash
    let a = UnixStr::try_from_str("path/").unwrap();
    let b = UnixStr::try_from_str("/ext").unwrap();
    let combined = a.path_join(b);
    assert_eq!("path/ext", combined.as_str().unwrap());
    // Adds slash
    let combined_other_way = b.path_join(a);
    assert_eq!("/ext/path/", combined_other_way.as_str().unwrap());
    // Doesn't truncate other slashes, only works at the boundary between the two paths
    let a = UnixStr::try_from_str("path//").unwrap();
    let combined_many_slashes = a.path_join(b);
    assert_eq!("path//ext", combined_many_slashes.as_str().unwrap());
}

pub fn path_join_fmt(&self, args: Arguments<'_>) -> UnixString

Joins this UnixStr with some format string adding a slash if necessary. Follows the same rules as UnixStr::path_join.

Example

use rusl::string::unix_str::UnixStr;
fn join_paths() {
    // Combines slash
    let a = UnixStr::try_from_str("path/").unwrap();
    let combined = a.path_join_fmt(format_args!("ext"));
    assert_eq!("path/ext", combined.as_str().unwrap());
}

pub fn parent_path(&self) -> Option<UnixString>

Treats this UnixStr as a path, then tries to find its parent. Will treat any double slash as a path with no parent

Example

use rusl::string::unix_str::UnixStr;
fn find_parent() {
    let well_formed = UnixStr::try_from_str("/home/gramar/code/").unwrap();
    let up_one = well_formed.parent_path().unwrap();
    assert_eq!("/home/gramar", up_one.as_str().unwrap());
    let up_two = up_one.parent_path().unwrap();
    assert_eq!("/home", up_two.as_str().unwrap());
    let up_three = up_two.parent_path().unwrap();
    assert_eq!("/", up_three.as_str().unwrap());
    assert!(up_three.parent_path().is_none());
    let ill_formed = UnixStr::try_from_str("/home/gramar/code//").unwrap();
    assert!(ill_formed.parent_path().is_none());
}

Trait Implementations

impl AsRef<UnixStr> for UnixString

fn as_ref(&self) -> &UnixStr

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

impl Debug for &UnixStr

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

Formats the value using the given formatter.

impl From<&UnixStr> for UnixString

fn from(s: &UnixStr) -> UnixString

Converts to this type from the input type.

impl Hash for &UnixStr

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

where H: Hasher,

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 Ord for UnixStr

fn cmp(&self, other: &UnixStr) -> Ordering

This method returns an Ordering between self and other.

impl PartialEq for UnixStr

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

fn partial_cmp(&self, other: &UnixStr) -> 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 Eq for UnixStr

impl StructuralPartialEq for UnixStr