# Struct std::ffi::OsString 1.0.0 [−] [src]

    pub struct OsString {
        // some fields omitted
    }

A type that can represent owned, mutable platform-native strings, but is cheaply inter-convertible with Rust strings.

The need for this type arises from the fact that:

- On Unix systems, strings are often arbitrary sequences of non-zero bytes, in many cases interpreted as UTF-8.

- On Windows, strings are often arbitrary sequences of non-zero 16-bit values, interpreted as UTF-16 when it is valid to do so.

- In Rust, strings are always valid UTF-8, but may contain zeros.

`OsString` and `OsStr` bridge this gap by simultaneously representing Rust and platform-native string values, and in particular allowing a Rust string to be converted into an "OS" string with no cost.

## Methods

### `impl OsString`
[src]

#### `fn new() -> OsString`

Constructs a new empty `OsString`.

#### `fn as_os_str(&self) -> &OsStr`

Converts to an `OsStr` slice.

#### `fn into_string(self) -> Result<String, OsString>`

Converts the `OsString` into a `String` if it contains valid Unicode data.

On failure, ownership of the original `OsString` is returned.

#### `fn push<T: AsRef<OsStr>>(&mut self, s: T)`

Extends the string with the given `&OsStr` slice.

#### `fn with_capacity(capacity: usize) -> OsString`
1.9.0

Creates a new `OsString` with the given capacity.

The string will be able to hold exactly `capacity` lenth units of other OS strings without reallocating. If `capacity` is 0, the string will not allocate.

See main `OsString` documentation information about encoding.

#### `fn clear(&mut self)`
1.9.0

Truncates the `OsString` to zero length.

#### `fn capacity(&self) -> usize`
1.9.0

Returns the capacity this `OsString` can hold without reallocating.

See `OsString` introduction for information about encoding.

#### `fn reserve(&mut self, additional: usize)`
1.9.0

Reserves capacity for at least `additional` more capacity to be inserted in the given `OsString`.

The collection may reserve more space to avoid frequent reallocations.

#### `fn reserve_exact(&mut self, additional: usize)`
1.9.0

Reserves the minimum capacity for exactly `additional` more capacity to be inserted in the given `OsString`. Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore capacity can not be relied upon to be precisely minimal. Prefer reserve if future insertions are expected.

## Methods from Deref<Target=OsStr>

#### `fn to_str(&self) -> Option<&str>`

Yields a `&str` slice if the `OsStr` is valid Unicode.

This conversion may entail doing a check for UTF-8 validity.

#### `fn to_string_lossy(&self) -> Cow<str>`

Converts an `OsStr` to a `Cow<str>`.

Any non-Unicode sequences are replaced with U+FFFD REPLACEMENT CHARACTER.

#### `fn to_os_string(&self) -> OsString`

Copies the slice into an owned `OsString`.

#### `fn is_empty(&self) -> bool`
1.9.0

Checks whether the `OsStr` is empty.

#### `fn len(&self) -> usize`
1.9.0

Returns the length of this `OsStr`.

Note that this does not return the number of bytes in this string as, for example, OS strings on Windows are encoded as a list of `u16` rather than a list of bytes. This number is simply useful for passing to other methods like `OsString::with_capacity` to avoid reallocations.

See `OsStr` introduction for more information about encoding.

## Trait Implementations

### `impl From<String> for OsString`
[src]

#### `fn from(s: String) -> OsString`

### `impl<'a, T: ?Sized + AsRef<OsStr>> From<&'a T> for OsString`
[src]

#### `fn from(s: &'a T) -> OsString`

### `impl Index<RangeFull> for OsString`
[src]

#### `type Output = OsStr`

#### `fn index(&self, _index: RangeFull) -> &OsStr`

### `impl Deref for OsString`
[src]

#### `type Target = OsStr`

#### `fn deref(&self) -> &OsStr`

### `impl Default for OsString`
1.9.0
[src]

#### `fn default() -> OsString`

### `impl Debug for OsString`
[src]

#### `fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>`

### `impl PartialEq for OsString`
[src]

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

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

### `impl PartialEq<str> for OsString`
[src]

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

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

### `impl Eq for OsString`
[src]

### `impl PartialOrd for OsString`
[src]

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

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

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

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

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

### `impl PartialOrd<str> for OsString`
[src]

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

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

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

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

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

### `impl Ord for OsString`
[src]

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

### `impl Hash for OsString`
[src]

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

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

### `impl<'a, 'b> PartialEq<OsStr> for OsString`
1.8.0
[src]

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

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

### `impl<'a, 'b> PartialOrd<OsStr> for OsString`
1.8.0
[src]

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

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

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

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

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

### `impl<'a, 'b> PartialEq<&'a OsStr> for OsString`
1.8.0
[src]

#### `fn eq(&self, other: &&'a OsStr) -> bool`

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

### `impl<'a, 'b> PartialOrd<&'a OsStr> for OsString`
1.8.0
[src]

#### `fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>`

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

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

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

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

### `impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for OsString`
1.8.0
[src]

#### `fn eq(&self, other: &Cow<'a, OsStr>) -> bool`

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

### `impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsString`
1.8.0
[src]

#### `fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>`

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

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

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

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

### `impl Borrow<OsStr> for OsString`
[src]

#### `fn borrow(&self) -> &OsStr`

### `impl AsRef<OsStr> for OsString`
[src]

#### `fn as_ref(&self) -> &OsStr`

### `impl OsStringExt for OsString`
[src]

#### `fn from_vec(vec: Vec<u8>) -> OsString`

#### `fn into_vec(self) -> Vec<u8>`

### `impl AsRef<Path> for OsString`
[src]

#### `fn as_ref(&self) -> &Path`

### `impl<'a, 'b> PartialEq<PathBuf> for OsString`
1.8.0
[src]

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

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

### `impl<'a, 'b> PartialOrd<PathBuf> for OsString`
1.8.0
[src]

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

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

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

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

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

### `impl<'a, 'b> PartialEq<Path> for OsString`
1.8.0
[src]

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

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

### `impl<'a, 'b> PartialOrd<Path> for OsString`
1.8.0
[src]

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

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

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

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

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

### `impl<'a, 'b> PartialEq<&'a Path> for OsString`
1.8.0
[src]

#### `fn eq(&self, other: &&'a Path) -> bool`

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

### `impl<'a, 'b> PartialOrd<&'a Path> for OsString`
1.8.0
[src]

#### `fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>`

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

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

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

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

### `impl<'a, 'b> PartialEq<Cow<'a, Path>> for OsString`
1.8.0
[src]

#### `fn eq(&self, other: &Cow<'a, Path>) -> bool`

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

### `impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsString`
1.8.0
[src]

#### `fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>`

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

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

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

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

### Derived Implementations

### `impl Clone for OsString`
[src]

#### `fn clone(&self) -> OsString`

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

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)