Struct os_str_bytes::RawOsString

pub struct RawOsString(_);

A container for owned byte strings converted by this crate.

For more information, see RawOsStr.

Implementations

impl RawOsString

pub fn new(string: OsString) -> Self

Converts a platform-native string into a representation that can be more easily manipulated.

For more information, see RawOsStr::new.

Examples

use std::env;

use os_str_bytes::RawOsString;

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

pub fn from_string(string: String) -> Self

Wraps a string, without copying or encoding conversion.

This method is much more efficient than RawOsString::new, since the encoding used by this crate is compatible with UTF-8.

Examples

use os_str_bytes::RawOsString;

let string = "foobar".to_owned();
let raw = RawOsString::from_string(string.clone());
assert_eq!(string, raw);

pub fn assert_from_raw_vec(string: Vec<u8>) -> Self

Wraps a byte string, without copying or encoding conversion.

Panics

Panics if the string is not valid for the unspecified encoding used by this crate.

Examples

use std::env;

use os_str_bytes::RawOsString;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsString::new(os_string);
let raw_bytes = raw.clone().into_raw_vec();
assert_eq!(raw, RawOsString::assert_from_raw_vec(raw_bytes));

pub unsafe fn from_raw_vec_unchecked(string: Vec<u8>) -> Self

Wraps a byte string, without copying or encoding conversion.

Safety

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

Examples

use std::env;

use os_str_bytes::RawOsString;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsString::new(os_string);
let raw_bytes = raw.clone().into_raw_vec();
assert_eq!(raw, unsafe {
    RawOsString::from_raw_vec_unchecked(raw_bytes)
});

pub fn clear(&mut self)

Equivalent to String::clear.

Examples

use std::env;

use os_str_bytes::RawOsString;

let os_string = env::current_exe()?.into_os_string();
let mut raw = RawOsString::new(os_string);
raw.clear();
assert!(raw.is_empty());

pub fn into_box(self) -> Box<RawOsStr>

Equivalent to String::into_boxed_str.

Examples

use os_str_bytes::RawOsString;

let string = "foobar".to_owned();
let raw = RawOsString::from_string(string.clone());
assert_eq!(string, *raw.into_box());

pub fn into_os_string(self) -> OsString

Converts this representation back to a platform-native string.

Examples

use std::env;

use os_str_bytes::RawOsString;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsString::new(os_string.clone());
assert_eq!(os_string, raw.into_os_string());

pub fn into_raw_vec(self) -> Vec<u8>

Returns the byte string stored by this container.

The returned string will use an unspecified encoding.

Examples

use os_str_bytes::RawOsString;

let string = "foobar".to_owned();
let raw = RawOsString::from_string(string.clone());
assert_eq!(string.into_bytes(), raw.into_raw_vec());

pub fn into_string(self) -> Result<String, Self>

Equivalent to OsString::into_string.

Examples

use os_str_bytes::RawOsString;

let string = "foobar".to_owned();
let raw = RawOsString::from_string(string.clone());
assert_eq!(Ok(string), raw.into_string());

pub fn shrink_to_fit(&mut self)

Equivalent to String::shrink_to_fit.

Examples

use os_str_bytes::RawOsString;

let string = "foobar".to_owned();
let mut raw = RawOsString::from_string(string.clone());
raw.shrink_to_fit();
assert_eq!(string, raw);

pub fn split_off(&mut self, at: usize) -> Self

Equivalent to String::split_off.

Panics

Panics if the index is not a valid boundary.

Examples

use os_str_bytes::RawOsString;

let mut raw = RawOsString::from_string("foobar".to_owned());
assert_eq!("bar", raw.split_off(3));
assert_eq!("foo", raw);

pub fn truncate(&mut self, new_len: usize)

Equivalent to String::truncate.

Panics

Panics if the index is not a valid boundary.

Examples

use os_str_bytes::RawOsString;

let mut raw = RawOsString::from_string("foobar".to_owned());
raw.truncate(3);
assert_eq!("foo", raw);

Methods from Deref<Target = RawOsStr>

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

Returns the byte string stored by this container.

The returned string will use an unspecified encoding.

Examples

use os_str_bytes::RawOsStr;

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

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

Equivalent to str::contains.

Examples

use os_str_bytes::RawOsStr;

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

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

Equivalent to str::ends_with.

Examples

use os_str_bytes::RawOsStr;

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

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

Equivalent to str::ends_with but accepts this type for the pattern.

Examples

use os_str_bytes::RawOsStr;

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

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

Equivalent to str::find.

Examples

use os_str_bytes::RawOsStr;

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

pub fn is_empty(&self) -> bool

Equivalent to str::is_empty.

Examples

use os_str_bytes::RawOsStr;

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

pub fn raw_len(&self) -> usize

Returns the length of the byte string stored by this container.

Only the following assumptions can be made about the result:

• The length of any Unicode character is the length of its UTF-8 representation (i.e., char::len_utf8).
• Splitting a string at a UTF-8 boundary will return two strings with lengths that sum to the length of the original string.

This method may return a different result than would OsStr::len when called on same string, since OsStr uses an unspecified encoding.

Examples

use os_str_bytes::RawOsStr;

assert_eq!(6, RawOsStr::from_str("foobar").raw_len());
assert_eq!(0, RawOsStr::from_str("").raw_len());

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

Equivalent to str::rfind.

Examples

use os_str_bytes::RawOsStr;

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

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

Equivalent to str::rsplit_once.

Examples

use os_str_bytes::RawOsStr;

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

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

Equivalent to str::split, but empty patterns are not accepted.

Panics

Panics if the pattern is empty.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("foobar");
assert_eq!(["f", "", "bar"], *raw.split("o").collect::<Vec<_>>());

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

Equivalent to str::split_at.

Panics

Panics if the index is not a valid boundary.

Examples

use os_str_bytes::RawOsStr;

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

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

Equivalent to str::split_once.

Examples

use os_str_bytes::RawOsStr;

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

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

Equivalent to str::starts_with.

Examples

use os_str_bytes::RawOsStr;

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

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

Equivalent to str::starts_with but accepts this type for the pattern.

Examples

use os_str_bytes::RawOsStr;

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

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

Equivalent to str::strip_prefix.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("111foo1bar111");
assert_eq!(
    Some(RawOsStr::from_str("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 str::strip_suffix.

Examples

use os_str_bytes::RawOsStr;

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

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

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_str(&self) -> Option<&str>

Equivalent to OsStr::to_str.

Examples

use os_str_bytes::RawOsStr;

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

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

Converts this string to the best UTF-8 representation possible.

Invalid sequences will be replaced with char::REPLACEMENT_CHARACTER.

This method may return a different result than would OsStr::to_string_lossy when called on same string, since OsStr uses an unspecified encoding.

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) -> &Selfwhere P: Pattern,

Equivalent to str::trim_end_matches.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("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) -> &Selfwhere P: Pattern,

Equivalent to str::trim_matches.

Examples

use os_str_bytes::RawOsStr;

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

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

Equivalent to str::trim_start_matches.

Examples

use os_str_bytes::RawOsStr;

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

Trait Implementations

impl AsRef<RawOsStr> for RawOsString

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 Clone for RawOsString

fn clone(&self) -> RawOsString

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RawOsString

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

Formats the value using the given formatter.

impl Default for RawOsString

fn default() -> RawOsString

Returns the “default value” for a type.

impl Deref for RawOsString

type Target = RawOsStr

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl From<Box<RawOsStr, Global>> for RawOsString

fn from(value: Box<RawOsStr>) -> 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 From<RawOsString> for Cow<'_, RawOsStr>

fn from(value: RawOsString) -> Self

Converts to this type from the input type.

impl From<String> for RawOsString

fn from(value: String) -> Self

Converts to this type from the input type.

impl Hash for RawOsString

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 Index<Range<usize>> for RawOsString

type Output = RawOsStr

The returned type after indexing.

fn index(&self, idx: Range<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RangeFrom<usize>> for RawOsString

type Output = RawOsStr

The returned type after indexing.

fn index(&self, idx: RangeFrom<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RangeFull> for RawOsString

type Output = RawOsStr

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl Index<RangeInclusive<usize>> for RawOsString

type Output = RawOsStr

The returned type after indexing.

fn index(&self, idx: RangeInclusive<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RangeTo<usize>> for RawOsString

type Output = RawOsStr

The returned type after indexing.

fn index(&self, idx: RangeTo<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RangeToInclusive<usize>> for RawOsString

type Output = RawOsStr

The returned type after indexing.

fn index(&self, idx: RangeToInclusive<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Ord for RawOsString

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

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

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

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

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

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

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

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

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

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

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

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

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

impl StructuralEq for RawOsString

impl StructuralPartialEq for RawOsString