OsString in std::ffi - Rust (original) (raw)
Struct OsString
1.0.0 · Source
pub struct OsString { /* private fields */ }Expand description
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, which 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 if possible. A consequence of this is that OsString instances are not NUL terminated; in order to pass to e.g., Unix system call, you should create a CStr.
OsString is to &[OsStr](struct.OsStr.html "struct std::ffi::OsStr") as String is to &[str](../primitive.str.html "primitive str"): the former in each pair are owned strings; the latter are borrowed references.
Note, OsString and OsStr internally do not necessarily hold strings in the form native to the platform; While on Unix, strings are stored as a sequence of 8-bit values, on Windows, where strings are 16-bit value based as just discussed, strings are also actually stored as a sequence of 8-bit values, encoded in a less-strict variant of UTF-8. This is useful to understand when handling capacity and length values.
§Capacity of OsString
Capacity uses units of UTF-8 bytes for OS strings which were created from valid unicode, and uses units of bytes in an unspecified encoding for other contents. On a given target, allOsString and OsStr values use the same units for capacity, so the following will work:
use std::ffi::{OsStr, OsString};
fn concat_os_strings(a: &OsStr, b: &OsStr) -> OsString {
let mut ret = OsString::with_capacity(a.len() + b.len()); // This will allocate
ret.push(a); // This will not allocate further
ret.push(b); // This will not allocate further
ret
}§Creating an OsString
From a Rust string: OsString implements[From](../convert/trait.From.html "trait std::convert::From")<[String](../string/struct.String.html "struct std:🧵:String")>, so you can use my_string.[into](../convert/trait.Into.html#tymethod.into "method std::convert::Into::into")() to create an OsString from a normal Rust string.
From slices: Just like you can start with an empty RustString and then String::push_str some &[str](../primitive.str.html "primitive str")sub-string slices into it, you can create an empty OsString with the OsString::new method and then push string slices into it with theOsString::push method.
You can use the OsString::as_os_str method to get an &[OsStr](struct.OsStr.html "struct std::ffi::OsStr") from an OsString; this is effectively a borrowed reference to the whole string.
§Conversions
See the module’s toplevel documentation about conversions for a discussion on the traits which OsString implements for conversions from/to native representations.
1.0.0 · Source
Constructs a new empty OsString.
§Examples
use std::ffi::OsString;
let os_string = OsString::new();1.74.0 · Source
Converts bytes to an OsString without checking that the bytes contains valid OsStr-encoded data.
The byte encoding is an unspecified, platform-specific, self-synchronizing superset of UTF-8. By being a self-synchronizing superset of UTF-8, this encoding is also a superset of 7-bit ASCII.
See the module’s toplevel documentation about conversions for safe, cross-platform conversions from/to native representations.
§Safety
As the encoding is unspecified, callers must pass in bytes that originated as a mixture of validated UTF-8 and bytes from OsStr::as_encoded_bytes from within the same Rust version built for the same target platform. For example, reconstructing an OsString from bytes sent over the network or stored in a file will likely violate these safety rules.
Due to the encoding being self-synchronizing, the bytes from OsStr::as_encoded_bytes can be split either immediately before or immediately after any valid non-empty UTF-8 substring.
§Example
use std::ffi::OsStr;
let os_str = OsStr::new("Mary had a little lamb");
let bytes = os_str.as_encoded_bytes();
let words = bytes.split(|b| *b == b' ');
let words: Vec<&OsStr> = words.map(|word| {
// SAFETY:
// - Each `word` only contains content that originated from `OsStr::as_encoded_bytes`
// - Only split with ASCII whitespace which is a non-empty UTF-8 substring
unsafe { OsStr::from_encoded_bytes_unchecked(word) }
}).collect();1.0.0 · Source
Converts to an OsStr slice.
§Examples
use std::ffi::{OsString, OsStr};
let os_string = OsString::from("foo");
let os_str = OsStr::new("foo");
assert_eq!(os_string.as_os_str(), os_str);1.74.0 · Source
Converts the OsString into a byte vector. To convert the byte vector back into anOsString, use the OsString::from_encoded_bytes_unchecked function.
The byte encoding is an unspecified, platform-specific, self-synchronizing superset of UTF-8. By being a self-synchronizing superset of UTF-8, this encoding is also a superset of 7-bit ASCII.
Note: As the encoding is unspecified, any sub-slice of bytes that is not valid UTF-8 should be treated as opaque and only comparable within the same Rust version built for the same target platform. For example, sending the bytes over the network or storing it in a file will likely result in incompatible data. See OsString for more encoding details and std::ffi for platform-specific, specified conversions.
1.0.0 · Source
Converts the OsString into a String if it contains valid Unicode data.
On failure, ownership of the original OsString is returned.
§Examples
use std::ffi::OsString;
let os_string = OsString::from("foo");
let string = os_string.into_string();
assert_eq!(string, Ok(String::from("foo")));1.0.0 · Source
Extends the string with the given &[OsStr](struct.OsStr.html "struct std::ffi::OsStr") slice.
§Examples
use std::ffi::OsString;
let mut os_string = OsString::from("foo");
os_string.push("bar");
assert_eq!(&os_string, "foobar");1.9.0 · Source
Creates a new OsString with at least the given capacity.
The string will be able to hold at least capacity length units of other OS strings without reallocating. This method is allowed to allocate for more units than capacity. If capacity is 0, the string will not allocate.
See the main OsString documentation information about encoding and capacity units.
§Examples
use std::ffi::OsString;
let mut os_string = OsString::with_capacity(10);
let capacity = os_string.capacity();
// This push is done without reallocating
os_string.push("foo");
assert_eq!(capacity, os_string.capacity());1.9.0 · Source
Truncates the OsString to zero length.
§Examples
use std::ffi::OsString;
let mut os_string = OsString::from("foo");
assert_eq!(&os_string, "foo");
os_string.clear();
assert_eq!(&os_string, "");1.9.0 · Source
Returns the capacity this OsString can hold without reallocating.
See the main OsString documentation information about encoding and capacity units.
§Examples
use std::ffi::OsString;
let os_string = OsString::with_capacity(10);
assert!(os_string.capacity() >= 10);1.9.0 · Source
Reserves capacity for at least additional more capacity to be inserted in the given OsString. Does nothing if the capacity is already sufficient.
The collection may reserve more space to speculatively avoid frequent reallocations.
See the main OsString documentation information about encoding and capacity units.
§Examples
use std::ffi::OsString;
let mut s = OsString::new();
s.reserve(10);
assert!(s.capacity() >= 10);1.63.0 · Source
Tries to reserve capacity for at least additional more length units in the given OsString. The string may reserve more space to speculatively avoid frequent reallocations. After calling try_reserve, capacity will be greater than or equal to self.len() + additional if it returns Ok(()). Does nothing if capacity is already sufficient. This method preserves the contents even if an error occurs.
See the main OsString documentation information about encoding and capacity units.
§Errors
If the capacity overflows, or the allocator reports a failure, then an error is returned.
§Examples
use std::ffi::{OsStr, OsString};
use std::collections::TryReserveError;
fn process_data(data: &str) -> Result<OsString, TryReserveError> {
let mut s = OsString::new();
// Pre-reserve the memory, exiting if we can't
s.try_reserve(OsStr::new(data).len())?;
// Now we know this can't OOM in the middle of our complex work
s.push(data);
Ok(s)
}1.9.0 · Source
Reserves the minimum capacity for at least 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.
See the main OsString documentation information about encoding and capacity units.
§Examples
use std::ffi::OsString;
let mut s = OsString::new();
s.reserve_exact(10);
assert!(s.capacity() >= 10);1.63.0 · Source
Tries to reserve the minimum capacity for at least additionalmore length units in the given OsString. After callingtry_reserve_exact, capacity will be greater than or equal toself.len() + additional if it returns Ok(()). Does nothing if the capacity is already sufficient.
Note that the allocator may give the OsString more space than it requests. Therefore, capacity can not be relied upon to be precisely minimal. Prefer try_reserve if future insertions are expected.
See the main OsString documentation information about encoding and capacity units.
§Errors
If the capacity overflows, or the allocator reports a failure, then an error is returned.
§Examples
use std::ffi::{OsStr, OsString};
use std::collections::TryReserveError;
fn process_data(data: &str) -> Result<OsString, TryReserveError> {
let mut s = OsString::new();
// Pre-reserve the memory, exiting if we can't
s.try_reserve_exact(OsStr::new(data).len())?;
// Now we know this can't OOM in the middle of our complex work
s.push(data);
Ok(s)
}1.19.0 · Source
Shrinks the capacity of the OsString to match its length.
See the main OsString documentation information about encoding and capacity units.
§Examples
use std::ffi::OsString;
let mut s = OsString::from("foo");
s.reserve(100);
assert!(s.capacity() >= 100);
s.shrink_to_fit();
assert_eq!(3, s.capacity());1.56.0 · Source
Shrinks the capacity of the OsString with a lower bound.
The capacity will remain at least as large as both the length and the supplied value.
If the current capacity is less than the lower limit, this is a no-op.
See the main OsString documentation information about encoding and capacity units.
§Examples
use std::ffi::OsString;
let mut s = OsString::from("foo");
s.reserve(100);
assert!(s.capacity() >= 100);
s.shrink_to(10);
assert!(s.capacity() >= 10);
s.shrink_to(0);
assert!(s.capacity() >= 3);1.20.0 · Source
Converts this OsString into a boxed OsStr.
§Examples
use std::ffi::{OsString, OsStr};
let s = OsString::from("hello");
let b: Box<OsStr> = s.into_boxed_os_str();🔬This is a nightly-only experimental API. (os_string_pathbuf_leak #125965)
Consumes and leaks the OsString, returning a mutable reference to the contents,&'a mut OsStr.
The caller has free choice over the returned lifetime, including ’static. Indeed, this function is ideally used for data that lives for the remainder of the program’s life, as dropping the returned reference will cause a memory leak.
It does not reallocate or shrink the OsString, so the leaked allocation may include unused capacity that is not part of the returned slice. If you want to discard excess capacity, call into_boxed_os_str, and then Box::leak instead. However, keep in mind that trimming the capacity may result in a reallocation and copy.
🔬This is a nightly-only experimental API. (os_string_truncate #133262)
Truncate the OsString to the specified length.
§Panics
Panics if len does not lie on a valid OsStr boundary (as described in OsStr::slice_encoded_bytes).
1.0.0 · Source
Yields a &[str](../primitive.str.html "primitive str") slice if the OsStr is valid Unicode.
This conversion may entail doing a check for UTF-8 validity.
§Examples
use std::ffi::OsStr;
let os_str = OsStr::new("foo");
assert_eq!(os_str.to_str(), Some("foo"));1.0.0 · Source
Converts an OsStr to a [Cow](../borrow/enum.Cow.html "enum std::borrow::Cow")<[str](../primitive.str.html "primitive str")>.
Any non-UTF-8 sequences are replaced withU+FFFD REPLACEMENT CHARACTER.
§Examples
Calling to_string_lossy on an OsStr with invalid unicode:
// Note, due to differences in how Unix and Windows represent strings,
// we are forced to complicate this example, setting up example `OsStr`s
// with different source data and via different platform extensions.
// Understand that in reality you could end up with such example invalid
// sequences simply through collecting user command line arguments, for
// example.
#[cfg(unix)] {
use std::ffi::OsStr;
use std::os::unix::ffi::OsStrExt;
// Here, the values 0x66 and 0x6f correspond to 'f' and 'o'
// respectively. The value 0x80 is a lone continuation byte, invalid
// in a UTF-8 sequence.
let source = [0x66, 0x6f, 0x80, 0x6f];
let os_str = OsStr::from_bytes(&source[..]);
assert_eq!(os_str.to_string_lossy(), "fo�o");
}
#[cfg(windows)] {
use std::ffi::OsString;
use std::os::windows::prelude::*;
// Here the values 0x0066 and 0x006f correspond to 'f' and 'o'
// respectively. The value 0xD800 is a lone surrogate half, invalid
// in a UTF-16 sequence.
let source = [0x0066, 0x006f, 0xD800, 0x006f];
let os_string = OsString::from_wide(&source[..]);
let os_str = os_string.as_os_str();
assert_eq!(os_str.to_string_lossy(), "fo�o");
}1.0.0 · Source
Copies the slice into an owned OsString.
§Examples
use std::ffi::{OsStr, OsString};
let os_str = OsStr::new("foo");
let os_string = os_str.to_os_string();
assert_eq!(os_string, OsString::from("foo"));1.9.0 · Source
Checks whether the OsStr is empty.
§Examples
use std::ffi::OsStr;
let os_str = OsStr::new("");
assert!(os_str.is_empty());
let os_str = OsStr::new("foo");
assert!(!os_str.is_empty());1.9.0 · Source
Returns the length of this OsStr.
Note that this does not return the number of bytes in the string in OS string form.
The length returned is that of the underlying storage used by OsStr. As discussed in the OsString introduction, OsString and OsStrstore strings in a form best suited for cheap inter-conversion between native-platform and Rust string forms, which may differ significantly from both of them, including in storage size and encoding.
This number is simply useful for passing to other methods, likeOsString::with_capacity to avoid reallocations.
See the main OsString documentation information about encoding and capacity units.
§Examples
use std::ffi::OsStr;
let os_str = OsStr::new("");
assert_eq!(os_str.len(), 0);
let os_str = OsStr::new("foo");
assert_eq!(os_str.len(), 3);1.74.0 · Source
Converts an OS string slice to a byte slice. To convert the byte slice back into an OS string slice, use the OsStr::from_encoded_bytes_unchecked function.
The byte encoding is an unspecified, platform-specific, self-synchronizing superset of UTF-8. By being a self-synchronizing superset of UTF-8, this encoding is also a superset of 7-bit ASCII.
Note: As the encoding is unspecified, any sub-slice of bytes that is not valid UTF-8 should be treated as opaque and only comparable within the same Rust version built for the same target platform. For example, sending the slice over the network or storing it in a file will likely result in incompatible byte slices. See OsString for more encoding details and std::ffi for platform-specific, specified conversions.
🔬This is a nightly-only experimental API. (os_str_slice #118485)
Takes a substring based on a range that corresponds to the return value ofOsStr::as_encoded_bytes.
The range’s start and end must lie on valid OsStr boundaries. A valid OsStr boundary is one of:
- The start of the string
- The end of the string
- Immediately before a valid non-empty UTF-8 substring
- Immediately after a valid non-empty UTF-8 substring
§Panics
Panics if range does not lie on valid OsStr boundaries or if it exceeds the end of the string.
§Example
#![feature(os_str_slice)]
use std::ffi::OsStr;
let os_str = OsStr::new("foo=bar");
let bytes = os_str.as_encoded_bytes();
if let Some(index) = bytes.iter().position(|b| *b == b'=') {
let key = os_str.slice_encoded_bytes(..index);
let value = os_str.slice_encoded_bytes(index + 1..);
assert_eq!(key, "foo");
assert_eq!(value, "bar");
}1.53.0 · Source
Converts this string to its ASCII lower case equivalent in-place.
ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’, but non-ASCII letters are unchanged.
To return a new lowercased value without modifying the existing one, useOsStr::to_ascii_lowercase.
§Examples
use std::ffi::OsString;
let mut s = OsString::from("GRÜßE, JÜRGEN ❤");
s.make_ascii_lowercase();
assert_eq!("grÜße, jÜrgen ❤", s);1.53.0 · Source
Converts this string to its ASCII upper case equivalent in-place.
ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’, but non-ASCII letters are unchanged.
To return a new uppercased value without modifying the existing one, useOsStr::to_ascii_uppercase.
§Examples
use std::ffi::OsString;
let mut s = OsString::from("Grüße, Jürgen ❤");
s.make_ascii_uppercase();
assert_eq!("GRüßE, JüRGEN ❤", s);1.53.0 · Source
Returns a copy of this string where each character is mapped to its ASCII lower case equivalent.
ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’, but non-ASCII letters are unchanged.
To lowercase the value in-place, use OsStr::make_ascii_lowercase.
§Examples
use std::ffi::OsString;
let s = OsString::from("Grüße, Jürgen ❤");
assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase());1.53.0 · Source
Returns a copy of this string where each character is mapped to its ASCII upper case equivalent.
ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’, but non-ASCII letters are unchanged.
To uppercase the value in-place, use OsStr::make_ascii_uppercase.
§Examples
use std::ffi::OsString;
let s = OsString::from("Grüße, Jürgen ❤");
assert_eq!("GRüßE, JüRGEN ❤", s.to_ascii_uppercase());1.53.0 · Source
Checks if all characters in this string are within the ASCII range.
§Examples
use std::ffi::OsString;
let ascii = OsString::from("hello!\n");
let non_ascii = OsString::from("Grüße, Jürgen ❤");
assert!(ascii.is_ascii());
assert!(!non_ascii.is_ascii());1.53.0 · Source
Checks that two strings are an ASCII case-insensitive match.
Same as to_ascii_lowercase(a) == to_ascii_lowercase(b), but without allocating and copying temporaries.
§Examples
use std::ffi::OsString;
assert!(OsString::from("Ferris").eq_ignore_ascii_case("FERRIS"));
assert!(OsString::from("Ferrös").eq_ignore_ascii_case("FERRöS"));
assert!(!OsString::from("Ferrös").eq_ignore_ascii_case("FERRÖS"));🔬This is a nightly-only experimental API. (os_str_display #120048)
Returns an object that implements Display for safely printing anOsStr that may contain non-Unicode data. This may perform lossy conversion, depending on the platform. If you would like an implementation which escapes the OsStr please use Debuginstead.
§Examples
#![feature(os_str_display)]
use std::ffi::OsStr;
let s = OsStr::new("Hello, world!");
println!("{}", s.display());Converts this type into a shared reference of the (usually inferred) input type.
Converts this type into a shared reference of the (usually inferred) input type.
Clones the contents of source into self.
This method is preferred over simply assigning source.clone() to self, as it avoids reallocation if possible.
Returns a copy of the value. Read more
Constructs an empty OsString.
The resulting type after dereferencing.
Dereferences the value.
Mutably dereferences the value.
Extends a collection with the contents of an iterator. Read more
🔬This is a nightly-only experimental API. (extend_one #72631)
Extends a collection with exactly one element.
🔬This is a nightly-only experimental API. (extend_one #72631)
Reserves capacity in a collection for the given number of additional elements. Read more
Extends a collection with the contents of an iterator. Read more
🔬This is a nightly-only experimental API. (extend_one #72631)
Extends a collection with exactly one element.
🔬This is a nightly-only experimental API. (extend_one #72631)
Reserves capacity in a collection for the given number of additional elements. Read more
Extends a collection with the contents of an iterator. Read more
🔬This is a nightly-only experimental API. (extend_one #72631)
Extends a collection with exactly one element.
🔬This is a nightly-only experimental API. (extend_one #72631)
Reserves capacity in a collection for the given number of additional elements. Read more
Converts a Cow<'a, OsStr> into an OsString, by copying the contents if they are borrowed.
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
The returned type after indexing.
Performs the indexing (container[index]) operation. Read more
Available on Unix only.
Available on WASI only.
Available on Windows only.
Creates an OsString from a potentially ill-formed UTF-16 slice of 16-bit code units. Read more
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
Writes a string slice into this writer, returning whether the write succeeded. Read more
Writes a char into this writer, returning whether the write succeeded. Read more
Glue for usage of the write! macro with implementors of this trait. Read more