Struct RawOsStr

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

A container providing additional functionality for OsStr.

For more information, see OsStrBytesExt.

Implementations

impl RawOsStr

pub fn new<S>(string: &S) -> &Self

where S: AsRef<OsStr> + ?Sized,

Wraps a platform-native string, without copying or encoding conversion.

Examples

use std::env;

use os_str_bytes::RawOsStr;

let os_string = env::current_exe()?.into_os_string();
println!("{:?}", RawOsStr::new(&os_string));

pub fn from_os_str(string: &OsStr) -> &Self

👎Deprecated since 7.0.0: use new instead

Wraps a platform-native string, without copying or encoding conversion.

Examples

use std::env;

use os_str_bytes::RawOsStr;

let os_string = env::current_exe()?.into_os_string();
println!("{:?}", RawOsStr::from_os_str(&os_string));

pub fn from_str(string: &str) -> &Self

👎Deprecated since 7.0.0: use new instead

Wraps a string, without copying or encoding conversion.

Examples

use os_str_bytes::RawOsStr;

let string = "foobar";
let raw = RawOsStr::from_str(string);
assert_eq!(string, raw);

pub unsafe fn from_encoded_bytes_unchecked(string: &[u8]) -> &Self

Equivalent to OsStr::from_encoded_bytes_unchecked.

Examples

use std::env;

use os_str_bytes::RawOsStr;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsStr::new(&os_string);
let raw_bytes = raw.as_encoded_bytes();
assert_eq!(raw, unsafe {
    RawOsStr::from_encoded_bytes_unchecked(raw_bytes)
});

pub fn assert_cow_from_raw_bytes(string: &[u8]) -> Cow<'_, Self>

Available on crate feature conversions only.

Equivalent to OsStrBytes::assert_from_raw_bytes.

Examples

use std::env;

use os_str_bytes::RawOsStr;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsStr::new(&os_string);
let raw_bytes = raw.to_raw_bytes();
assert_eq!(raw, &*RawOsStr::assert_cow_from_raw_bytes(&raw_bytes));

pub fn cow_from_raw_bytes(string: &[u8]) -> Result<Cow<'_, Self>, EncodingError>

Available on crate feature checked_conversions only.

Equivalent to OsStrBytes::from_raw_bytes.

Examples

use std::env;

use os_str_bytes::RawOsStr;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsStr::new(&os_string);
let raw_bytes = raw.to_raw_bytes();
assert_eq!(
    Ok(raw),
    RawOsStr::cow_from_raw_bytes(&raw_bytes).as_deref(),
);

pub unsafe fn cow_from_raw_bytes_unchecked(string: &[u8]) -> Cow<'_, Self>

👎Deprecated since 6.6.0: use assert_cow_from_raw_bytes or from_encoded_bytes_unchecked instead

Available on crate feature conversions only.

Converts and wraps a byte string.

Safety

The string must be valid for the unspecified encoding used by this crate.

Examples

use std::env;

use os_str_bytes::RawOsStr;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsStr::new(&os_string);
let raw_bytes = raw.to_raw_bytes();
assert_eq!(raw, unsafe {
    &*RawOsStr::cow_from_raw_bytes_unchecked(&raw_bytes)
});

pub fn as_encoded_bytes(&self) -> &[u8]

Equivalent to OsStr::as_encoded_bytes.

The returned string will not use the unspecified encoding. It can only be passed to methods accepting the internal encoding of OsStr, such as from_encoded_bytes_unchecked.

Examples

use os_str_bytes::RawOsStr;

let string = "foobar";
let raw = RawOsStr::new(string);
assert_eq!(string.as_bytes(), raw.as_encoded_bytes());

pub fn as_os_str(&self) -> &OsStr

Converts this representation back to a platform-native string, without copying or encoding conversion.

Examples

use std::env;

use os_str_bytes::RawOsStr;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsStr::new(&os_string);
assert_eq!(os_string, raw.as_os_str());

pub fn contains<P>(&self, pat: P) -> bool

where P: Pattern,

Equivalent to OsStrBytesExt::contains.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foobar");
assert!(raw.contains("oo"));
assert!(!raw.contains("of"));

pub fn ends_with<P>(&self, pat: P) -> bool

where P: Pattern,

Equivalent to OsStrBytesExt::ends_with.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foobar");
assert!(raw.ends_with("bar"));
assert!(!raw.ends_with("foo"));

pub fn ends_with_os(&self, pat: &Self) -> bool

Available on crate feature conversions only.

Equivalent to OsStrBytesExt::ends_with_os.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foobar");
assert!(raw.ends_with_os(RawOsStr::new("bar")));
assert!(!raw.ends_with_os(RawOsStr::new("foo")));

pub fn find<P>(&self, pat: P) -> Option<usize>

where P: Pattern,

Equivalent to OsStrBytesExt::find.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foobar");
assert_eq!(Some(1), raw.find("o"));
assert_eq!(None, raw.find("of"));

pub unsafe fn get_unchecked<I>(&self, index: I) -> &Self

where I: SliceIndex,

Equivalent to OsStrBytesExt::get_unchecked.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foobar");
assert_eq!("foo", unsafe { raw.get_unchecked(..3) });
assert_eq!("bar", unsafe { raw.get_unchecked(3..) });

pub fn is_empty(&self) -> bool

Equivalent to OsStr::is_empty.

Examples

use os_str_bytes::RawOsStr;

assert!(RawOsStr::new("").is_empty());
assert!(!RawOsStr::new("foobar").is_empty());

pub fn repeat(&self, n: usize) -> RawOsString

Equivalent to OsStrBytesExt::repeat.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foo");
assert_eq!("foofoofoo", raw.repeat(3));

pub fn rfind<P>(&self, pat: P) -> Option<usize>

where P: Pattern,

Equivalent to OsStrBytesExt::rfind.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foobar");
assert_eq!(Some(2), raw.rfind("o"));
assert_eq!(None, raw.rfind("of"));

pub fn rsplit<P>(&self, pat: P) -> RawRSplit<'_, P>

where P: Pattern,

Equivalent to OsStrBytesExt::rsplit.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foobar");
assert!(raw.rsplit("o").eq(["bar", "", "f"]));

pub fn rsplit_once<P>(&self, pat: P) -> Option<(&Self, &Self)>

where P: Pattern,

Equivalent to OsStrBytesExt::rsplit_once.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foobar");
assert_eq!(
    Some((RawOsStr::new("fo"), RawOsStr::new("bar"))),
    raw.rsplit_once("o"),
);
assert_eq!(None, raw.rsplit_once("of"));

pub fn split<P>(&self, pat: P) -> RawSplit<'_, P>

where P: Pattern,

Equivalent to OsStrBytesExt::split.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foobar");
assert!(raw.split("o").eq(["f", "", "bar"]));

pub fn split_at(&self, mid: usize) -> (&Self, &Self)

Equivalent to OsStrBytesExt::split_at.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foobar");
assert_eq!(
    (RawOsStr::new("fo"), RawOsStr::new("obar")),
    raw.split_at(2),
);

pub fn split_once<P>(&self, pat: P) -> Option<(&Self, &Self)>

where P: Pattern,

Equivalent to OsStrBytesExt::split_once.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foobar");
assert_eq!(
    Some((RawOsStr::new("f"), RawOsStr::new("obar"))),
    raw.split_once("o"),
);
assert_eq!(None, raw.split_once("of"));

pub fn starts_with<P>(&self, pat: P) -> bool

where P: Pattern,

Equivalent to OsStrBytesExt::starts_with.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foobar");
assert!(raw.starts_with("foo"));
assert!(!raw.starts_with("bar"));

pub fn starts_with_os(&self, pat: &Self) -> bool

Available on crate feature conversions only.

Equivalent to OsStrBytesExt::starts_with_os.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("foobar");
assert!(raw.starts_with_os(RawOsStr::new("foo")));
assert!(!raw.starts_with_os(RawOsStr::new("bar")));

pub fn strip_prefix<P>(&self, pat: P) -> Option<&Self>

where P: Pattern,

Equivalent to OsStrBytesExt::strip_prefix.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("111foo1bar111");
assert_eq!(Some(RawOsStr::new("11foo1bar111")), raw.strip_prefix("1"));
assert_eq!(None, raw.strip_prefix("o"));

pub fn strip_suffix<P>(&self, pat: P) -> Option<&Self>

where P: Pattern,

Equivalent to OsStrBytesExt::strip_suffix.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("111foo1bar111");
assert_eq!(Some(RawOsStr::new("111foo1bar11")), raw.strip_suffix("1"));
assert_eq!(None, raw.strip_suffix("o"));

pub fn to_os_str(&self) -> Cow<'_, OsStr>

👎Deprecated since 6.6.0: use as_os_str instead

Converts this representation back to a platform-native string.

When possible, use RawOsStrCow::into_os_str for a more efficient conversion on some platforms.

Examples

use std::env;

use os_str_bytes::RawOsStr;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsStr::new(&os_string);
assert_eq!(os_string, raw.to_os_str());

pub fn to_raw_bytes(&self) -> Cow<'_, [u8]>

Available on crate feature conversions only.

Equivalent to OsStrBytes::to_raw_bytes.

Examples

use os_str_bytes::RawOsStr;

let string = "foobar";
let raw = RawOsStr::new(string);
assert_eq!(string.as_bytes(), &*raw.to_raw_bytes());

pub fn to_str(&self) -> Option<&str>

Equivalent to OsStr::to_str.

Examples

use os_str_bytes::RawOsStr;

let string = "foobar";
let raw = RawOsStr::new(string);
assert_eq!(Some(string), raw.to_str());

pub fn to_str_lossy(&self) -> Cow<'_, str>

Equivalent to OsStr::to_string_lossy.

Examples

use std::env;

use os_str_bytes::RawOsStr;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsStr::new(&os_string);
println!("{}", raw.to_str_lossy());

pub fn trim_end_matches<P>(&self, pat: P) -> &Self

where P: Pattern,

Equivalent to OsStrBytesExt::trim_end_matches.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("111foo1bar111");
assert_eq!("111foo1bar", raw.trim_end_matches("1"));
assert_eq!("111foo1bar111", raw.trim_end_matches("o"));

pub fn trim_matches<P>(&self, pat: P) -> &Self

where P: Pattern,

Equivalent to OsStrBytesExt::trim_matches.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("111foo1bar111");
assert_eq!("foo1bar", raw.trim_matches("1"));
assert_eq!("111foo1bar111", raw.trim_matches("o"));

pub fn trim_start_matches<P>(&self, pat: P) -> &Self

where P: Pattern,

Equivalent to OsStrBytesExt::trim_start_matches.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::new("111foo1bar111");
assert_eq!("foo1bar111", raw.trim_start_matches("1"));
assert_eq!("111foo1bar111", raw.trim_start_matches("o"));

pub fn utf8_chunks(&self) -> Utf8Chunks<'_>

Equivalent to OsStrBytesExt::utf8_chunks.

Examples

use os_str_bytes::RawOsStr;

fn to_str_lossy<F>(raw: &RawOsStr, mut push: F)
where
    F: FnMut(&str),
{
    for (invalid, string) in raw.utf8_chunks() {
        if !invalid.as_os_str().is_empty() {
            push("\u{FFFD}");
        }

        push(string);
    }
}

Trait Implementations

impl AsRef<OsStr> for RawOsStr

fn as_ref(&self) -> &OsStr

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

impl AsRef<RawOsStr> for OsStr

fn as_ref(&self) -> &RawOsStr

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

impl AsRef<RawOsStr> for OsString

fn as_ref(&self) -> &RawOsStr

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

impl AsRef<RawOsStr> for RawOsStr

fn as_ref(&self) -> &Self

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

impl AsRef<RawOsStr> for RawOsString

fn as_ref(&self) -> &RawOsStr

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

impl AsRef<RawOsStr> for String

fn as_ref(&self) -> &RawOsStr

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

impl AsRef<RawOsStr> for str

fn as_ref(&self) -> &RawOsStr

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

impl Borrow<RawOsStr> for RawOsString

fn borrow(&self) -> &RawOsStr

Immutably borrows from an owned value.

impl Debug for RawOsStr

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

Formats the value using the given formatter.

impl Default for &RawOsStr

fn default() -> Self

Returns the “default value” for a type.

impl<'a> From<&'a RawOsStr> for Cow<'a, RawOsStr>

fn from(value: &'a RawOsStr) -> Self

Converts to this type from the input type.

impl From<Box<str>> for Box<RawOsStr>

fn from(value: Box<str>) -> Self

Converts to this type from the input type.

impl From<RawOsString> for Box<RawOsStr>

fn from(value: RawOsString) -> Self

Converts to this type from the input type.

impl Hash for RawOsStr

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

Feeds this value into the given Hasher.

impl<Idx> Index<Idx> for RawOsStr

where Idx: SliceIndex,

type Output = RawOsStr

The returned type after indexing.

fn index(&self, index: Idx) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Ord for RawOsStr

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

This method returns an Ordering between self and other.

impl PartialEq<&RawOsStr> for OsString

fn eq(&self, other: &&RawOsStr) -> 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 PartialEq<&RawOsStr> for RawOsString

fn eq(&self, other: &&RawOsStr) -> 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 PartialEq<&RawOsStr> for String

fn eq(&self, other: &&RawOsStr) -> 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 PartialEq<OsStr> for RawOsStr

fn eq(&self, other: &OsStr) -> 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 PartialEq<OsString> for &RawOsStr

fn eq(&self, other: &OsString) -> 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 PartialEq<OsString> for RawOsStr

fn eq(&self, other: &OsString) -> 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 PartialEq<RawOsStr> for OsStr

fn eq(&self, other: &RawOsStr) -> 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 PartialEq<RawOsStr> for OsString

fn eq(&self, other: &RawOsStr) -> 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 PartialEq<RawOsStr> for RawOsString

fn eq(&self, other: &RawOsStr) -> 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 PartialEq<RawOsStr> for String

fn eq(&self, other: &RawOsStr) -> 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 PartialEq<RawOsStr> for str

fn eq(&self, other: &RawOsStr) -> 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 PartialEq<RawOsString> for &RawOsStr

fn eq(&self, other: &RawOsString) -> 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 PartialEq<RawOsString> for RawOsStr

fn eq(&self, other: &RawOsString) -> 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 PartialEq<String> for &RawOsStr

fn eq(&self, other: &String) -> 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 PartialEq<String> for RawOsStr

fn eq(&self, other: &String) -> 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 PartialEq<str> for RawOsStr

fn eq(&self, other: &str) -> 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 PartialEq for RawOsStr

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

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

type Owned = RawOsString

The resulting type after obtaining ownership.

fn to_owned(&self) -> Self::Owned

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

Uses borrowed data to replace owned data, usually by cloning.

impl Eq for RawOsStr

impl StructuralPartialEq for RawOsStr