# Struct os_str_bytes::RawOsString

source · [−]

    pub struct RawOsString(_);

Expand description

A container for owned byte strings converted by this crate.

For more information, see `RawOsStr`.

## Implementations

source

### impl RawOsString

source

#### 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));

source

#### 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);

source

#### 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));

source

#### 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)
    });

source

#### 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());

source

#### 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());

source

#### 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());

source

#### 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());

source

#### 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());

source

#### 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);

source

#### 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);

source

#### 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>

source

#### pub fn as_raw_bytes(&self) -> &[u8]ⓘNotable traits for &[u8]`impl Read for &[u8]impl Write for &mut [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());

source

#### pub fn contains<P>(&self, pat: P) -> bool where
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"));

source

#### pub fn ends_with<P>(&self, pat: P) -> bool where
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"));

source

#### 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")));

source

#### 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"));

source

#### 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());

source

#### 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());

source

#### 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"));

source

#### 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"));

source

#### pub fn split<P>(&self, pat: P) -> Split<'_, P>ⓘNotable traits for Split<'a, P>`impl<'a, P> Iterator for Split<'a, P> where
P: Pattern, type Item = &'a RawOsStr;` 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<_>>());

source

#### 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),
    );

source

#### 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"));

source

#### pub fn starts_with<P>(&self, pat: P) -> bool where
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"));

source

#### 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")));

source

#### 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"));

source

#### 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"));

source

#### 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());

source

#### 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());

source

#### 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());

source

#### pub fn trim_end_matches<P>(&self, pat: P) -> &Self where
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"));

source

#### pub fn trim_matches<P>(&self, pat: P) -> &Self where
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"));

source

#### pub fn trim_start_matches<P>(&self, pat: P) -> &Self where
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

source

### impl AsRef<RawOsStr> for RawOsString

source

#### fn as_ref(&self) -> &RawOsStr

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

source

### impl Borrow<RawOsStr> for RawOsString

source

#### fn borrow(&self) -> &RawOsStr

Immutably borrows from an owned value. Read more

source

### impl Clone for RawOsString

source

#### fn clone(&self) -> RawOsString

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from `source`. Read more

source

### impl Debug for RawOsString

source

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

Formats the value using the given formatter. Read more

source

### impl Default for RawOsString

source

#### fn default() -> RawOsString

Returns the “default value” for a type. Read more

source

### impl Deref for RawOsString

#### type Target = RawOsStr

The resulting type after dereferencing.

source

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

Dereferences the value.

source

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

source

#### fn from(value: Box<RawOsStr>) -> Self

Converts to this type from the input type.

source

### impl From<RawOsString> for Box<RawOsStr>

source

#### fn from(value: RawOsString) -> Self

Converts to this type from the input type.

source

### impl From<RawOsString> for Cow<'_, RawOsStr>

source

#### fn from(value: RawOsString) -> Self

Converts to this type from the input type.

source

### impl From<String> for RawOsString

source

#### fn from(value: String) -> Self

Converts to this type from the input type.

source

### impl Hash for RawOsString

source

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

Feeds this value into the given `Hasher`. Read more

1.3.0 · source

#### fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,

Feeds a slice of this type into the given `Hasher`. Read more

source

### impl Index<Range<usize>> for RawOsString

#### type Output = RawOsStr

The returned type after indexing.

source

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

Performs the indexing (`container[index]`) operation. Read more

source

### impl Index<RangeFrom<usize>> for RawOsString

#### type Output = RawOsStr

The returned type after indexing.

source

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

Performs the indexing (`container[index]`) operation. Read more

source

### impl Index<RangeFull> for RawOsString

#### type Output = RawOsStr

The returned type after indexing.

source

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

Performs the indexing (`container[index]`) operation. Read more

source

### impl Index<RangeInclusive<usize>> for RawOsString

#### type Output = RawOsStr

The returned type after indexing.

source

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

Performs the indexing (`container[index]`) operation. Read more

source

### impl Index<RangeTo<usize>> for RawOsString

#### type Output = RawOsStr

The returned type after indexing.

source

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

Performs the indexing (`container[index]`) operation. Read more

source

### impl Index<RangeToInclusive<usize>> for RawOsString

#### type Output = RawOsStr

The returned type after indexing.

source

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

Performs the indexing (`container[index]`) operation. Read more

source

### impl Ord for RawOsString

source

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

This method returns an `Ordering` between `self` and `other`. Read more

1.21.0 · source

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

Compares and returns the maximum of two values. Read more

1.21.0 · source

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

Compares and returns the minimum of two values. Read more

1.50.0 · source

#### fn clamp(self, min: Self, max: Self) -> Self where
Self: PartialOrd<Self>,

Restrict a value to a certain interval. Read more

source

### impl PartialEq<&RawOsStr> for RawOsString

source

#### fn eq(&self, other: &&RawOsStr) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

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

This method tests for `!=`.

source

### impl PartialEq<&str> for RawOsString

source

#### fn eq(&self, other: &&str) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

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

This method tests for `!=`.

source

### impl PartialEq<RawOsStr> for RawOsString

source

#### fn eq(&self, other: &RawOsStr) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

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

This method tests for `!=`.

source

### impl PartialEq<RawOsString> for &RawOsStr

source

#### fn eq(&self, other: &RawOsString) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

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

This method tests for `!=`.

source

### impl PartialEq<RawOsString> for &str

source

#### fn eq(&self, other: &RawOsString) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

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

This method tests for `!=`.

source

### impl PartialEq<RawOsString> for RawOsStr

source

#### fn eq(&self, other: &RawOsString) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

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

This method tests for `!=`.

source

### impl PartialEq<RawOsString> for RawOsString

source

#### fn eq(&self, other: &RawOsString) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

source

#### fn ne(&self, other: &RawOsString) -> bool

This method tests for `!=`.

source

### impl PartialEq<RawOsString> for String

source

#### fn eq(&self, other: &RawOsString) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

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

This method tests for `!=`.

source

### impl PartialEq<RawOsString> for str

source

#### fn eq(&self, other: &RawOsString) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

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

This method tests for `!=`.

source

### impl PartialEq<String> for RawOsString

source

#### fn eq(&self, other: &String) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

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

This method tests for `!=`.

source

### impl PartialEq<str> for RawOsString

source

#### fn eq(&self, other: &str) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

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

This method tests for `!=`.

source

### impl PartialOrd<RawOsString> for RawOsString

source

#### fn partial_cmp(&self, other: &RawOsString) -> Option<Ordering>

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

1.0.0 · source

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

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

1.0.0 · source

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

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

1.0.0 · source

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

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

1.0.0 · source

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

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

source

### impl Eq for RawOsString

source

### impl StructuralEq for RawOsString

source

### impl StructuralPartialEq for RawOsString

## Auto Trait Implementations

### impl RefUnwindSafe for RawOsString

### impl Send for RawOsString

### impl Sync for RawOsString

### impl Unpin for RawOsString

### impl UnwindSafe for RawOsString

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T> ToOwned for T where
T: Clone,

#### type Owned = T

The resulting type after obtaining ownership.

source

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

#### fn clone_into(&self, target: &mut T)

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

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.