Struct widestring::ustring::UString

pub struct UString<C: UChar> { /* fields omitted */ }

An owned, mutable “wide” string for FFI that is not nul-aware.

UString is not aware of nul values. Strings may or may not be nul-terminated, and may contain invalid and ill-formed UTF-16 or UTF-32 data. These strings are intended to be used with FFI functions that directly use string length, where the strings are known to have proper nul-termination already, or where strings are merely being passed through without modification.

UCString should be used instead if nul-aware strings are required.

UString can be converted to and from many other standard Rust string types, including OsString and String, making proper Unicode FFI safe and easy.

Please prefer using the type aliases U16String, U32String, or WideString to using this type directly.

Examples

The following example constructs a U16String and shows how to convert a U16String to a regular Rust String.

use widestring::U16String;
let s = "Test";
// Create a wide string from the rust string
let wstr = U16String::from_str(s);
// Convert back to a rust string
let rust_str = wstr.to_string_lossy();
assert_eq!(rust_str, "Test");

The same example using U32String instead:

use widestring::U32String;
let s = "Test";
// Create a wide string from the rust string
let wstr = U32String::from_str(s);
// Convert back to a rust string
let rust_str = wstr.to_string_lossy();
assert_eq!(rust_str, "Test");

Implementations

impl<C: UChar> UString<C>

pub fn new() -> Self

Constructs a new empty UString.

pub fn from_vec(raw: impl Into<Vec<C>>) -> Self

Constructs a UString from a vector.

No checks are made on the contents of the vector. It may or may not be valid character data.

Examples

use widestring::U16String;
let v = vec![84u16, 104u16, 101u16]; // 'T' 'h' 'e'
// Create a wide string from the vector
let wstr = U16String::from_vec(v);

use widestring::U32String;
let v = vec![84u32, 104u32, 101u32]; // 'T' 'h' 'e'
// Create a wide string from the vector
let wstr = U32String::from_vec(v);

pub unsafe fn from_ptr(p: *const C, len: usize) -> Self

Constructs a UString copy from a pointer and a length.

The len argument is the number of elements, not the number of bytes.

Safety

This function is unsafe as there is no guarantee that the given pointer is valid for len elements.

In addition, the data must meet the safety conditions of std::slice::from_raw_parts.

Panics

Panics if len is greater than 0 but p is a null pointer.

pub fn with_capacity(capacity: usize) -> Self

Constructs a UString with the given capacity.

The string will be able to hold exactly capacity elements without reallocating. If capacity is set to 0, the string will not initially allocate.

pub fn capacity(&self) -> usize

Returns the capacity this UString can hold without reallocating.

pub fn clear(&mut self)

Truncates the UString to zero length.

pub fn reserve(&mut self, additional: usize)

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

More space may be reserved to avoid frequent allocations.

pub fn reserve_exact(&mut self, additional: usize)

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

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

pub fn into_vec(self) -> Vec<C>

Converts the string into a Vec, consuming the string in the process.

pub fn as_ustr(&self) -> &UStr<C>

Converts to a UStr reference.

pub fn as_mut_ustr(&mut self) -> &mut UStr<C>

Converts to a mutable UStr reference.

pub fn as_vec(&self) -> &Vec<C>

Returns a Vec reference to the contents of this string.

pub fn as_mut_vec(&mut self) -> &mut Vec<C>

Returns a mutable reference to the contents of this string.

pub fn push(&mut self, s: impl AsRef<UStr<C>>)

Extends the string with the given string slice.

No checks are performed on the strings. It is possible to end up nul values inside the string, and it is up to the caller to determine if that is acceptable.

Examples

use widestring::U16String;
let s = "MyString";
let mut wstr = U16String::from_str(s);
let cloned = wstr.clone();
// Push the clone to the end, repeating the string twice.
wstr.push(cloned);

assert_eq!(wstr.to_string().unwrap(), "MyStringMyString");

use widestring::U32String;
let s = "MyString";
let mut wstr = U32String::from_str(s);
let cloned = wstr.clone();
// Push the clone to the end, repeating the string twice.
wstr.push(cloned);

assert_eq!(wstr.to_string().unwrap(), "MyStringMyString");

pub fn push_slice(&mut self, s: impl AsRef<[C]>)

Extends the string with the given slice.

No checks are performed on the strings. It is possible to end up nul values inside the string, and it is up to the caller to determine if that is acceptable.

Examples

use widestring::U16String;
let s = "MyString";
let mut wstr = U16String::from_str(s);
let cloned = wstr.clone();
// Push the clone to the end, repeating the string twice.
wstr.push_slice(cloned);

assert_eq!(wstr.to_string().unwrap(), "MyStringMyString");

use widestring::U32String;
let s = "MyString";
let mut wstr = U32String::from_str(s);
let cloned = wstr.clone();
// Push the clone to the end, repeating the string twice.
wstr.push_slice(cloned);

assert_eq!(wstr.to_string().unwrap(), "MyStringMyString");

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the UString to match its length.

Examples

use widestring::U16String;

let mut s = U16String::from_str("foo");

s.reserve(100);
assert!(s.capacity() >= 100);

s.shrink_to_fit();
assert_eq!(3, s.capacity());

use widestring::U32String;

let mut s = U32String::from_str("foo");

s.reserve(100);
assert!(s.capacity() >= 100);

s.shrink_to_fit();
assert_eq!(3, s.capacity());

pub fn into_boxed_ustr(self) -> Box<UStr<C>>

Converts this UString into a boxed UStr.

Examples

use widestring::{U16String, U16Str};

let s = U16String::from_str("hello");

let b: Box<U16Str> = s.into_boxed_ustr();

use widestring::{U32String, U32Str};

let s = U32String::from_str("hello");

let b: Box<U32Str> = s.into_boxed_ustr();

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

Shortens this string to the specified length.

If new_len is greater than the string’s current length, this has no effect.

Note that this method has no effect on the allocated capacity of the string.

pub fn insert_ustr(&mut self, idx: usize, string: &UStr<C>)

Inserts a string slice into this string at a specified position.

This is an O(n) operation as it requires copying every element in the buffer.

Panics

Panics if idx is larger than the string’s length.

pub fn split_off(&mut self, at: usize) -> UString<C>

Splits the string into two at the given index.

Returns a newly allocated string. self contains values [0, at), and the returned string contains values [at, len).

Note that the capacity of self does not change.

Panics

Panics if at is equal to or greater than the length of the string.

impl UString<u16>

pub fn from_str<S: AsRef<str> + ?Sized>(s: &S) -> Self

Encodes a U16String copy from a str.

This makes a string copy of the str. Since str will always be valid UTF-8, the resulting U16String will also be valid UTF-16.

Examples

use widestring::U16String;
let s = "MyString";
// Create a wide string from the string
let wstr = U16String::from_str(s);

assert_eq!(wstr.to_string().unwrap(), s);

pub fn from_os_str<S: AsRef<OsStr> + ?Sized>(s: &S) -> Self

Encodes a U16String copy from an OsStr.

This makes a string copy of the OsStr. Since OsStr makes no guarantees that it is valid data, there is no guarantee that the resulting U16String will be valid UTF-16.

Note that the encoding of OsStr is platform-dependent, so on some platforms this may make an encoding conversions, while on other platforms (such as windows) no changes to the string will be made.

Examples

use widestring::U16String;
let s = "MyString";
// Create a wide string from the string
let wstr = U16String::from_os_str(s);

assert_eq!(wstr.to_string().unwrap(), s);

pub fn push_str(&mut self, s: impl AsRef<str>)

Extends the string with the given string slice.

No checks are performed on the strings. It is possible to end up nul values inside the string, and it is up to the caller to determine if that is acceptable.

Examples

use widestring::U16String;
let s = "MyString";
let mut wstr = U16String::from_str(s);
// Push the original to the end, repeating the string twice.
wstr.push_str(s);

assert_eq!(wstr.to_string().unwrap(), "MyStringMyString");

pub fn push_os_str(&mut self, s: impl AsRef<OsStr>)

Extends the string with the given string slice.

No checks are performed on the strings. It is possible to end up nul values inside the string, and it is up to the caller to determine if that is acceptable.

Examples

use widestring::U16String;
let s = "MyString";
let mut wstr = U16String::from_str(s);
// Push the original to the end, repeating the string twice.
wstr.push_os_str(s);

assert_eq!(wstr.to_string().unwrap(), "MyStringMyString");

pub fn push_char(&mut self, c: char)

Appends the given char to the end of this string.

pub fn pop(&mut self) -> Option<u32>

Removes the last character or unpaired surrogate from the string buffer and returns it.

Returns None if this String is empty. Otherwise, returns the character cast to a u32 or the value of the unpaired surrogate as a u32 value.

pub fn remove(&mut self, idx: usize) -> u32

Removes a char or unpaired surrogate from this string at a position and returns it as a u32.

This is an O(n) operation, as it requires copying every element in the buffer.

Panics

Panics if idx is larger than or equal to the string’s length.

pub fn insert(&mut self, idx: usize, c: char)

Inserts a character into this string at a specified position.

This is an O(n) operation as it requires copying every element in the buffer.

Panics

Panics if idx is larger than the string’s length.

impl UString<u32>

pub fn from_chars(raw: impl Into<Vec<char>>) -> Self

Constructs a U32String from a char vector.

No checks are made on the contents of the vector.

Examples

use widestring::U32String;
let v: Vec<char> = "Test".chars().collect();
// Create a wide string from the vector
let wstr = U32String::from_chars(v);

pub fn from_str<S: AsRef<str> + ?Sized>(s: &S) -> Self

Encodes a U32String copy from a str.

This makes a string copy of the str. Since str will always be valid UTF-8, the resulting U32String will also be valid UTF-32.

Examples

use widestring::U32String;
let s = "MyString";
// Create a wide string from the string
let wstr = U32String::from_str(s);

assert_eq!(wstr.to_string().unwrap(), s);

pub fn from_os_str<S: AsRef<OsStr> + ?Sized>(s: &S) -> Self

Encodes a U32String copy from an OsStr.

This makes a string copy of the OsStr. Since OsStr makes no guarantees that it is valid data, there is no guarantee that the resulting U32String will be valid UTF-32.

Note that the encoding of OsStr is platform-dependent, so on some platforms this may make an encoding conversions, while on other platforms no changes to the string will be made.

Examples

use widestring::U32String;
let s = "MyString";
// Create a wide string from the string
let wstr = U32String::from_os_str(s);

assert_eq!(wstr.to_string().unwrap(), s);

pub unsafe fn from_char_ptr(p: *const char, len: usize) -> Self

Constructs a U32String from a char pointer and a length.

The len argument is the number of char elements, not the number of bytes.

Safety

This function is unsafe as there is no guarantee that the given pointer is valid for len elements.

In addition, the data must meet the safety conditions of std::slice::from_raw_parts.

Panics

Panics if len is greater than 0 but p is a null pointer.

pub fn push_str(&mut self, s: impl AsRef<str>)

Extends the string with the given string slice.

No checks are performed on the strings. It is possible to end up nul values inside the string, and it is up to the caller to determine if that is acceptable.

Examples

use widestring::U32String;
let s = "MyString";
let mut wstr = U32String::from_str(s);
// Push the original to the end, repeating the string twice.
wstr.push_str(s);

assert_eq!(wstr.to_string().unwrap(), "MyStringMyString");

pub fn push_os_str(&mut self, s: impl AsRef<OsStr>)

Extends the string with the given string slice.

No checks are performed on the strings. It is possible to end up nul values inside the string, and it is up to the caller to determine if that is acceptable.

Examples

use widestring::U32String;
let s = "MyString";
let mut wstr = U32String::from_str(s);
// Push the original to the end, repeating the string twice.
wstr.push_os_str(s);

assert_eq!(wstr.to_string().unwrap(), "MyStringMyString");

pub fn push_char(&mut self, c: char)

Appends the given char to the end of this string.

pub fn pop(&mut self) -> Option<u32>

Removes the last value from the string buffer and returns it.

Returns None if this String is empty.

pub fn remove(&mut self, idx: usize) -> u32

Removes a value from this string at a position and returns it.

This is an O(n) operation, as it requires copying every element in the buffer.

Panics

Panics if idx is larger than or equal to the string’s length.

pub fn insert(&mut self, idx: usize, c: char)

Inserts a character into this string at a specified position.

This is an O(n) operation as it requires copying every element in the buffer.

Panics

Panics if idx is larger than the string’s length.

Methods from Deref<Target = UStr<C>>

pub fn to_ustring(&self) -> UString<C>

Copies the string reference to a new owned UString.

pub fn as_slice(&self) -> &[C]

Converts to a slice of the string.

pub fn as_mut_slice(&mut self) -> &mut [C]

Converts to a mutable slice of the string.

pub fn as_ptr(&self) -> *const C

Returns a raw pointer to the string.

The caller must ensure that the string outlives the pointer this function returns, or else it will end up pointing to garbage.

The caller must also ensure that the memory the pointer (non-transitively) points to is never written to (except inside an UnsafeCell) using this pointer or any pointer derived from it. If you need to mutate the contents of the string, use as_mut_ptr.

Modifying the container referenced by this string may cause its buffer to be reallocated, which would also make any pointers to it invalid.

pub fn as_mut_ptr(&mut self) -> *mut C

Returns an unsafe mutable raw pointer to the string.

The caller must ensure that the string outlives the pointer this function returns, or else it will end up pointing to garbage.

Modifying the container referenced by this string may cause its buffer to be reallocated, which would also make any pointers to it invalid.

pub fn as_ptr_range(&self) -> Range<*const C>

Returns the two raw pointers spanning the string slice.

The returned range is half-open, which means that the end pointer points one past the last element of the slice. This way, an empty slice is represented by two equal pointers, and the difference between the two pointers represents the size of the slice.

See as_ptr for warnings on using these pointers. The end pointer requires extra caution, as it does not point to a valid element in the slice.

This function is useful for interacting with foreign interfaces which use two pointers to refer to a range of elements in memory, as is common in C++.

pub fn as_mut_ptr_range(&mut self) -> Range<*mut C>

Returns the two unsafe mutable pointers spanning the string slice.

The returned range is half-open, which means that the end pointer points one past the last element of the slice. This way, an empty slice is represented by two equal pointers, and the difference between the two pointers represents the size of the slice.

See as_mut_ptr for warnings on using these pointers. The end pointer requires extra caution, as it does not point to a valid element in the slice.

This function is useful for interacting with foreign interfaces which use two pointers to refer to a range of elements in memory, as is common in C++.

pub fn len(&self) -> usize

Returns the length of the string as number of elements (not number of bytes).

pub fn is_empty(&self) -> bool

Returns whether this string contains no data.

pub fn display(&self) -> Display<'_, C>

Returns an object that implements Display for printing strings that may contain non-Unicode data.

A UStr might contain ill-formed UTF encoding. This struct implements the Display trait in a way that decoding the string is lossy but no heap allocations are performed, such as by to_string_lossy.

By default, invalid Unicode data is replaced with U+FFFD REPLACEMENT CHARACTER (�). If you wish to simply skip any invalid Uncode data and forego the replacement, you may use the alternate formatting with {:#}.

Examples

Basic usage:

use widestring::U16Str;

// 𝄞mus<invalid>ic<invalid>
let s = U16Str::from_slice(&[
    0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834,
]);

assert_eq!(format!("{}", s.display()),
"𝄞mus�ic�"
);

Using alternate formatting style to skip invalid values entirely:

use widestring::U16Str;

// 𝄞mus<invalid>ic<invalid>
let s = U16Str::from_slice(&[
    0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834,
]);

assert_eq!(format!("{:#}", s.display()),
"𝄞music"
);

pub fn get<I>(&self, i: I) -> Option<&Self> where
    I: SliceIndex<[C], Output = [C]>, 

Returns a subslice of the string.

This is the non-panicking alternative to indexing the string. Returns None whenever equivalent indexing operation would panic.

pub fn get_mut<I>(&mut self, i: I) -> Option<&mut Self> where
    I: SliceIndex<[C], Output = [C]>, 

Returns a mutable subslice of the string.

This is the non-panicking alternative to indexing the string. Returns None whenever equivalent indexing operation would panic.

pub unsafe fn get_unchecked<I>(&self, i: I) -> &Self where
    I: SliceIndex<[C], Output = [C]>, 

Returns an unchecked subslice of the string.

This is the unchecked alternative to indexing the string.

Safety

Callers of this function are responsible that these preconditions are satisfied:

• The starting index must not exceed the ending index;
• Indexes must be within bounds of the original slice.

Failing that, the returned string slice may reference invalid memory.

pub unsafe fn get_unchecked_mut<I>(&mut self, i: I) -> &mut Self where
    I: SliceIndex<[C], Output = [C]>, 

Returns aa mutable, unchecked subslice of the string.

This is the unchecked alternative to indexing the string.

Safety

Callers of this function are responsible that these preconditions are satisfied:

• The starting index must not exceed the ending index;
• Indexes must be within bounds of the original slice.

Failing that, the returned string slice may reference invalid memory.

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

Divide one string slice into two at an index.

The argument, mid, should be an offset from the start of the string.

The two slices returned go from the start of the string slice to mid, and from mid to the end of the string slice.

To get mutable string slices instead, see the split_at_mut method.

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

Divide one mutable string slice into two at an index.

The argument, mid, should be an offset from the start of the string.

The two slices returned go from the start of the string slice to mid, and from mid to the end of the string slice.

To get immutable string slices instead, see the split_at method.

pub fn to_os_string(&self) -> OsString

Decodes a string reference to an owned OsString.

This makes a string copy of the U16Str. Since U16Str makes no guarantees that it is valid UTF-16, there is no guarantee that the resulting OsString will be valid encoding either.

Note that the encoding of OsString is platform-dependent, so on some platforms this may make an encoding conversions, while on other platforms (such as windows) no changes to the string will be made.

Examples

use widestring::U16String;
use std::ffi::OsString;
let s = "MyString";
// Create a wide string from the string
let wstr = U16String::from_str(s);
// Create an OsString from the wide string
let osstr = wstr.to_os_string();

assert_eq!(osstr, OsString::from(s));

pub fn to_string(&self) -> Result<String, FromUtf16Error>

Decodes the string reference to a String if it contains valid UTF-16 data.

Failures

Returns an error if the string contains any invalid UTF-16 data.

Examples

use widestring::U16String;
let s = "MyString";
// Create a wide string from the string
let wstr = U16String::from_str(s);
// Create a regular string from the wide string
let s2 = wstr.to_string().unwrap();

assert_eq!(s2, s);

pub fn to_string_lossy(&self) -> String

Decodes the string reference to a String even if it is invalid UTF-16 data.

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

Examples

use widestring::U16String;
let s = "MyString";
// Create a wide string from the string
let wstr = U16String::from_str(s);
// Create a regular string from the wide string
let lossy = wstr.to_string_lossy();

assert_eq!(lossy, s);

pub fn chars(&self) -> Utf16Chars<'_>

Returns an iterator over the chars of a string slice.

As this string slice may consist of invalid UTF-16, the iterator returned by this method is an iterator over Result<char, DecodeUtf16Error> instead of chars directly. If you would like a lossy iterator over charss directly, instead use chars_lossy.

It’s important to remember that char represents a Unicode Scalar Value, and may not match your idea of what a ‘character’ is. Iteration over grapheme clusters may be what you actually want. That functionality is not provided by by this crate.

pub fn chars_lossy(&self) -> CharsLossy<'_>

Returns a lossy iterator over the chars of a string slice.

As this string slice may consist of invalid UTF-16, the iterator returned by this method will replace unpaired surrogates with U+FFFD REPLACEMENT CHARACTER (�). This is a lossy version of chars.

It’s important to remember that char represents a Unicode Scalar Value, and may not match your idea of what a ‘character’ is. Iteration over grapheme clusters may be what you actually want. That functionality is not provided by by this crate.

pub fn char_indices(&self) -> Utf16CharIndices<'_>

Returns an iterator over the chars of a string slice, and their positions.

As this string slice may consist of invalid UTF-16, the iterator returned by this method is an iterator over Result<char, DecodeUtf16Error> as well as their positions, instead of chars directly. If you would like a lossy indices iterator over charss directly, instead use char_indices_lossy.

The iterator yields tuples. The position is first, the char is second.

pub fn char_indices_lossy(&self) -> Utf16CharIndicesLossy<'_>

Returns a lossy iterator over the chars of a string slice, and their positions.

As this string slice may consist of invalid UTF-16, the iterator returned by this method will replace unpaired surrogates with U+FFFD REPLACEMENT CHARACTER (�), as well as the positions of all characters. This is a lossy version of char_indices.

The iterator yields tuples. The position is first, the char is second.

pub fn to_os_string(&self) -> OsString

Decodes a string to an owned OsString.

This makes a string copy of the U32Str. Since U32Str makes no guarantees that it is valid UTF-32, there is no guarantee that the resulting OsString will be valid data.

Note that the encoding of OsString is platform-dependent, so on some platforms this may make an encoding conversions, while on other platforms no changes to the string will be made.

Examples

use widestring::U32String;
use std::ffi::OsString;
let s = "MyString";
// Create a wide string from the string
let wstr = U32String::from_str(s);
// Create an OsString from the wide string
let osstr = wstr.to_os_string();

assert_eq!(osstr, OsString::from(s));

pub fn to_string(&self) -> Result<String, FromUtf32Error>

Decodes the string to a String if it contains valid UTF-32 data.

Failures

Returns an error if the string contains any invalid UTF-32 data.

Examples

use widestring::U32String;
let s = "MyString";
// Create a wide string from the string
let wstr = U32String::from_str(s);
// Create a regular string from the wide string
let s2 = wstr.to_string().unwrap();

assert_eq!(s2, s);

pub fn to_string_lossy(&self) -> String

Decodes the string reference to a String even if it is invalid UTF-32 data.

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

Examples

use widestring::U32String;
let s = "MyString";
// Create a wide string from the string
let wstr = U32String::from_str(s);
// Create a regular string from the wide string
let lossy = wstr.to_string_lossy();

assert_eq!(lossy, s);

pub fn chars(&self) -> Utf32Chars<'_>

Returns an iterator over the chars of a string slice.

As this string slice may consist of invalid UTF-32, the iterator returned by this method is an iterator over Result<char, DecodeUtf32Error> instead of chars directly. If you would like a lossy iterator over charss directly, instead use chars_lossy.

It’s important to remember that char represents a Unicode Scalar Value, and may not match your idea of what a ‘character’ is. Iteration over grapheme clusters may be what you actually want. That functionality is not provided by by this crate.

pub fn chars_lossy(&self) -> CharsLossy<'_>

Returns a lossy iterator over the chars of a string slice.

As this string slice may consist of invalid UTF-32, the iterator returned by this method will replace surrogate values or invalid code points with U+FFFD REPLACEMENT CHARACTER (�). This is a lossy version of chars.

It’s important to remember that char represents a Unicode Scalar Value, and may not match your idea of what a ‘character’ is. Iteration over grapheme clusters may be what you actually want. That functionality is not provided by by this crate.

Trait Implementations

impl<C: UChar> Add<&'_ UCStr<C>> for UString<C>

type Output = UString<C>

The resulting type after applying the + operator.

fn add(self, rhs: &UCStr<C>) -> Self::Output

Performs the + operation.

impl<C: UChar> Add<&'_ UStr<C>> for UString<C>

type Output = UString<C>

The resulting type after applying the + operator.

fn add(self, rhs: &UStr<C>) -> Self::Output

Performs the + operation.

impl<C: UChar> AddAssign<&'_ UCStr<C>> for UString<C>

fn add_assign(&mut self, rhs: &UCStr<C>)

Performs the += operation.

impl<C: UChar> AddAssign<&'_ UStr<C>> for UString<C>

fn add_assign(&mut self, rhs: &UStr<C>)

Performs the += operation.

impl<C: UChar> AsMut<[C]> for UString<C>

fn as_mut(&mut self) -> &mut [C]

Performs the conversion.

impl<C: UChar> AsMut<UStr<C>> for UString<C>

fn as_mut(&mut self) -> &mut UStr<C>

Performs the conversion.

impl<C: UChar> AsRef<[C]> for UString<C>

fn as_ref(&self) -> &[C]

Performs the conversion.

impl<C: UChar> AsRef<UStr<C>> for UString<C>

fn as_ref(&self) -> &UStr<C>

Performs the conversion.

impl<C: UChar> Borrow<UStr<C>> for UString<C>

fn borrow(&self) -> &UStr<C>

Immutably borrows from an owned value.

impl<C: UChar> BorrowMut<UStr<C>> for UString<C>

fn borrow_mut(&mut self) -> &mut UStr<C>

Mutably borrows from an owned value.

impl<C: Clone + UChar> Clone for UString<C>

fn clone(&self) -> UString<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Default + UChar> Default for UString<C>

fn default() -> UString<C>

Returns the “default value” for a type.

impl<C: UChar> Deref for UString<C>

type Target = UStr<C>

The resulting type after dereferencing.

fn deref(&self) -> &UStr<C>

Dereferences the value.

impl<C: UChar> DerefMut for UString<C>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, C: UChar> Extend<&'a UCStr<C>> for UString<C>

fn extend<T: IntoIterator<Item = &'a UCStr<C>>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, C: UChar> Extend<&'a UStr<C>> for UString<C>

fn extend<T: IntoIterator<Item = &'a UStr<C>>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<C: UChar> Extend<Box<UStr<C>, Global>> for UString<C>

fn extend<T: IntoIterator<Item = Box<UStr<C>>>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, C: UChar> Extend<Cow<'a, UStr<C>>> for UString<C>

fn extend<T: IntoIterator<Item = Cow<'a, UStr<C>>>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<C: UChar> Extend<UCString<C>> for UString<C>

fn extend<T: IntoIterator<Item = UCString<C>>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<C: UChar> Extend<UString<C>> for UString<C>

fn extend<T: IntoIterator<Item = UString<C>>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl From<&'_ str> for UString<u16>

fn from(s: &str) -> Self

Performs the conversion.

impl From<&'_ str> for UString<u32>

fn from(s: &str) -> Self

Performs the conversion.

impl<'a, C: UChar, T: ?Sized + AsRef<UStr<C>>> From<&'a T> for UString<C>

fn from(s: &'a T) -> Self

Performs the conversion.

impl<C: UChar> From<Box<UStr<C>, Global>> for UString<C>

fn from(boxed: Box<UStr<C>>) -> Self

Performs the conversion.

impl From<OsString> for UString<u16>

fn from(s: OsString) -> Self

Performs the conversion.

impl From<OsString> for UString<u32>

fn from(s: OsString) -> Self

Performs the conversion.

impl From<String> for UString<u16>

fn from(s: String) -> Self

Performs the conversion.

impl From<String> for UString<u32>

fn from(s: String) -> Self

Performs the conversion.

impl<C: UChar> From<UCString<C>> for UString<C>

fn from(s: UCString<C>) -> Self

Performs the conversion.

impl<C: UChar> From<UString<C>> for Vec<C>

fn from(value: UString<C>) -> Self

Performs the conversion.

impl<C: UChar> From<UString<C>> for Box<UStr<C>>

fn from(s: UString<C>) -> Self

Performs the conversion.

impl<'a> From<UString<u16>> for Cow<'a, UStr<u16>>

fn from(s: UString<u16>) -> Self

Performs the conversion.

impl From<UString<u16>> for OsString

fn from(s: UString<u16>) -> Self

Performs the conversion.

impl<'a> From<UString<u32>> for Cow<'a, UStr<u32>>

fn from(s: UString<u32>) -> Self

Performs the conversion.

impl From<UString<u32>> for OsString

fn from(s: UString<u32>) -> Self

Performs the conversion.

impl From<Vec<char, Global>> for UString<u32>

fn from(value: Vec<char>) -> Self

Performs the conversion.

impl From<Vec<u16, Global>> for UString<u16>

fn from(value: Vec<u16>) -> Self

Performs the conversion.

impl From<Vec<u32, Global>> for UString<u32>

fn from(value: Vec<u32>) -> Self

Performs the conversion.

impl<'a, C: UChar + 'a> FromIterator<&'a UCStr<C>> for UString<C>

fn from_iter<T: IntoIterator<Item = &'a UCStr<C>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a, C: UChar + 'a> FromIterator<&'a UStr<C>> for UString<C>

fn from_iter<T: IntoIterator<Item = &'a UStr<C>>>(iter: T) -> Self

Creates a value from an iterator.

impl<C: UChar> FromIterator<Box<UStr<C>, Global>> for UString<C>

fn from_iter<T: IntoIterator<Item = Box<UStr<C>>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a, C: UChar + 'a> FromIterator<Cow<'a, UStr<C>>> for UString<C>

fn from_iter<T: IntoIterator<Item = Cow<'a, UStr<C>>>>(iter: T) -> Self

Creates a value from an iterator.

impl<C: UChar> FromIterator<UCString<C>> for UString<C>

fn from_iter<T: IntoIterator<Item = UCString<C>>>(iter: T) -> Self

Creates a value from an iterator.

impl<C: UChar> FromIterator<UString<C>> for UString<C>

fn from_iter<T: IntoIterator<Item = UString<C>>>(iter: T) -> Self

Creates a value from an iterator.

impl<C: Hash + UChar> Hash for UString<C>

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, 

Feeds a slice of this type into the given Hasher.

impl<C: UChar, I> Index<I> for UString<C> where
    I: SliceIndex<[C], Output = [C]>, 

type Output = UStr<C>

The returned type after indexing.

fn index(&self, index: I) -> &UStr<C>

Performs the indexing (container[index]) operation.

impl<C: UChar, I> IndexMut<I> for UString<C> where
    I: SliceIndex<[C], Output = [C]>, 

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<C: Ord + UChar> Ord for UString<C>

fn cmp(&self, other: &UString<C>) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<'a, C: UChar> PartialEq<&'a UCStr<C>> for UString<C>

fn eq(&self, other: &&'a UCStr<C>) -> 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 !=.

impl<'a, C: UChar> PartialEq<&'a UStr<C>> for UString<C>

fn eq(&self, other: &&'a UStr<C>) -> 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 !=.

impl<'a, C: UChar> PartialEq<Cow<'a, UCStr<C>>> for UString<C>

fn eq(&self, other: &Cow<'a, UCStr<C>>) -> 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 !=.

impl<'a, C: UChar> PartialEq<Cow<'a, UStr<C>>> for UString<C>

fn eq(&self, other: &Cow<'a, UStr<C>>) -> 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 !=.

impl<C: UChar> PartialEq<UCStr<C>> for UString<C>

fn eq(&self, other: &UCStr<C>) -> 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 !=.

impl<C: UChar> PartialEq<UCString<C>> for UString<C>

fn eq(&self, other: &UCString<C>) -> 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 !=.

impl<C: UChar> PartialEq<UStr<C>> for UString<C>

fn eq(&self, other: &UStr<C>) -> 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 !=.

impl<C: UChar> PartialEq<UString<C>> for UCString<C>

fn eq(&self, other: &UString<C>) -> 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 !=.

impl<C: PartialEq + UChar> PartialEq<UString<C>> for UString<C>

fn eq(&self, other: &UString<C>) -> bool

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

fn ne(&self, other: &UString<C>) -> bool

This method tests for !=.

impl<'a, C: UChar> PartialOrd<&'a UCStr<C>> for UString<C>

fn partial_cmp(&self, other: &&'a UCStr<C>) -> 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<'a, C: UChar> PartialOrd<&'a UStr<C>> for UString<C>

fn partial_cmp(&self, other: &&'a UStr<C>) -> 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<'a, C: UChar> PartialOrd<Cow<'a, UCStr<C>>> for UString<C>

fn partial_cmp(&self, other: &Cow<'a, UCStr<C>>) -> 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<'a, C: UChar> PartialOrd<Cow<'a, UStr<C>>> for UString<C>

fn partial_cmp(&self, other: &Cow<'a, UStr<C>>) -> 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<C: UChar> PartialOrd<UCStr<C>> for UString<C>

fn partial_cmp(&self, other: &UCStr<C>) -> 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<C: UChar> PartialOrd<UCString<C>> for UString<C>

fn partial_cmp(&self, other: &UCString<C>) -> 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<C: UChar> PartialOrd<UStr<C>> for UString<C>

fn partial_cmp(&self, other: &UStr<C>) -> 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<C: UChar> PartialOrd<UString<C>> for UCString<C>

fn partial_cmp(&self, other: &UString<C>) -> 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<C: PartialOrd + UChar> PartialOrd<UString<C>> for UString<C>

fn partial_cmp(&self, other: &UString<C>) -> 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<C: Eq + UChar> Eq for UString<C>

impl<C: UChar> StructuralEq for UString<C>

impl<C: UChar> StructuralPartialEq for UString<C>