Struct U16Str

pub struct U16Str { /* private fields */ }

16-bit wide string slice with undefined encoding.

U16Str is to U16String as OsStr is to OsString.

U16Str are string slices that do not have a defined encoding. While it is sometimes assumed that they contain possibly invalid or ill-formed UTF-16 data, they may be used for any wide encoded string. This is because U16Str is intended to be used with FFI functions, where proper encoding cannot be guaranteed. If you need string slices that are always valid UTF-16 strings, use Utf16Str instead.

Because U16Str does not have a defined encoding, no restrictions are placed on mutating or indexing the slice. This means that even if the string contained properly encoded UTF-16 or other encoding data, mutationing or indexing may result in malformed data. Convert to a Utf16Str if retaining proper UTF-16 encoding is desired.

FFI considerations

U16Str is not aware of nul values and may or may not be nul-terminated. It is 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.

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

Examples

The easiest way to use U16Str outside of FFI is with the u16str! macro to convert string literals into UTF-16 string slices at compile time:

use widestring::u16str;
let hello = u16str!("Hello, world!");

You can also convert any u16 slice directly:

use widestring::{u16str, U16Str};

let sparkle_heart = [0xd83d, 0xdc96];
let sparkle_heart = U16Str::from_slice(&sparkle_heart);

assert_eq!(u16str!("💖"), sparkle_heart);

// This unpaired UTf-16 surrogate is invalid UTF-16, but is perfectly valid in U16Str
let malformed_utf16 = [0x0, 0xd83d]; // Note that nul values are also valid an untouched
let s = U16Str::from_slice(&malformed_utf16);

assert_eq!(s.len(), 2);

When working with a FFI, it is useful to create a U16Str from a pointer and a length:

use widestring::{u16str, U16Str};

let sparkle_heart = [0xd83d, 0xdc96];
let sparkle_heart = unsafe {
    U16Str::from_ptr(sparkle_heart.as_ptr(), sparkle_heart.len())
};
assert_eq!(u16str!("💖"), sparkle_heart);

Implementations

impl U16Str

pub fn new<S>(s: &S) -> &U16Str

where S: AsRef<U16Str> + ?Sized,

Coerces a value into a wide string slice.

pub unsafe fn from_ptr<'a>(p: *const u16, len: usize) -> &'a U16Str

Constructs a wide string slice from a pointer and a length.

The len argument is the number of elements, not the number of bytes. No copying or allocation is performed, the resulting value is a direct reference to the pointer 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. In particular, the returned string reference must not be mutated for the duration of lifetime 'a, except inside an UnsafeCell.

Panics

This function panics if p is null.

Caveat

The lifetime for the returned string is inferred from its usage. To prevent accidental misuse, it’s suggested to tie the lifetime to whichever source lifetime is safe in the context, such as by providing a helper function taking the lifetime of a host value for the string, or by explicit annotation.

pub unsafe fn from_ptr_mut<'a>(p: *mut u16, len: usize) -> &'a mut U16Str

Constructs a mutable wide string slice from a mutable pointer and a length.

The len argument is the number of elements, not the number of bytes. No copying or allocation is performed, the resulting value is a direct reference to the pointer 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_mut.

Panics

This function panics if p is null.

Caveat

The lifetime for the returned string is inferred from its usage. To prevent accidental misuse, it’s suggested to tie the lifetime to whichever source lifetime is safe in the context, such as by providing a helper function taking the lifetime of a host value for the string, or by explicit annotation.

pub const fn from_slice(slice: &[u16]) -> &U16Str

Constructs a wide string slice from a slice of character data.

No checks are performed on the slice. It may be of any encoding and may contain invalid or malformed data for that encoding.

pub fn from_slice_mut(slice: &mut [u16]) -> &mut U16Str

Constructs a mutable wide string slice from a mutable slice of character data.

No checks are performed on the slice. It may be of any encoding and may contain invalid or malformed data for that encoding.

pub fn to_ustring(&self) -> U16String

Copies the string reference to a new owned wide string.

pub const fn as_slice(&self) -> &[u16]

Converts to a slice of the underlying elements of the string.

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

Converts to a mutable slice of the underlying elements of the string.

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

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 u16

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

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

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 const fn len(&self) -> usize

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

pub const fn is_empty(&self) -> bool

Returns whether this string contains no data.

pub fn into_ustring(self: Box<U16Str>) -> U16String

Converts a boxed wide string slice into an owned wide string without copying or allocating.

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

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

This method assumes this string is intended to be UTF-16 encoding, but handles ill-formed UTF-16 sequences lossily. The returned struct implements the Display trait in a way that decoding the string is lossy UTF-16 decoding 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<&U16Str>

where I: SliceIndex<[u16], Output = [u16]>,

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

where I: SliceIndex<[u16], Output = [u16]>,

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) -> &U16Str

where I: SliceIndex<[u16], Output = [u16]>,

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 U16Str

where I: SliceIndex<[u16], Output = [u16]>,

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) -> (&U16Str, &U16Str)

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 U16Str, &mut U16Str)

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 repeat(&self, n: usize) -> U16String

Creates a new owned string by repeating this string n times.

Panics

This function will panic if the capacity would overflow.

impl U16Str

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 its encoding is UTF-16 or that the data valid UTF-16, there is no guarantee that the resulting OsString will have a valid underlying 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, Utf16Error>

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

This method assumes this string is encoded as UTF-16 and attempts to decode it as such.

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 to a String even if it is invalid UTF-16 data.

This method assumes this string is encoded as UTF-16 and attempts to decode it as such. Any invalid sequences are replaced with U+FFFD REPLACEMENT CHARACTER, which looks like this: �

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) -> CharsUtf16<'_>

Returns an iterator over the chars of a string slice.

As this string has no defined encoding, this method assumes the string is UTF-16. Since it 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) -> CharsLossyUtf16<'_>

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

As this string has no defined encoding, this method assumes the string is UTF-16. Since it 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) -> CharIndicesUtf16<'_>

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

As this string has no defined encoding, this method assumes the string is UTF-16. Since it 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) -> CharIndicesLossyUtf16<'_>

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.

Trait Implementations

impl Add<&U16Str> for U16String

type Output = U16String

The resulting type after applying the + operator.

fn add(self, rhs: &U16Str) -> <U16String as Add<&U16Str>>::Output

Performs the + operation.

impl AddAssign<&U16Str> for U16String

fn add_assign(&mut self, rhs: &U16Str)

Performs the += operation.

impl AsMut<[u16]> for U16Str

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

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

impl AsMut<U16Str> for U16Str

fn as_mut(&mut self) -> &mut U16Str

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

impl AsMut<U16Str> for U16String

fn as_mut(&mut self) -> &mut U16Str

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

impl AsRef<[u16]> for U16Str

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

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

impl AsRef<U16Str> for U16CStr

fn as_ref(&self) -> &U16Str

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

impl AsRef<U16Str> for U16Str

fn as_ref(&self) -> &U16Str

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

impl AsRef<U16Str> for U16String

fn as_ref(&self) -> &U16Str

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

impl AsRef<U16Str> for Utf16Str

fn as_ref(&self) -> &U16Str

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

impl Borrow<U16Str> for U16String

fn borrow(&self) -> &U16Str

Immutably borrows from an owned value.

impl BorrowMut<U16Str> for U16String

fn borrow_mut(&mut self) -> &mut U16Str

Mutably borrows from an owned value.

impl Debug for U16Str

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

Formats the value using the given formatter.

impl Default for &U16Str

fn default() -> &U16Str

Returns the “default value” for a type.

impl Default for &mut U16Str

fn default() -> &mut U16Str

Returns the “default value” for a type.

impl<'a> Extend<&'a U16Str> for U16String

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = &'a U16Str>,

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> From<&'a [u16]> for &'a U16Str

fn from(value: &'a [u16]) -> &'a U16Str

Converts to this type from the input type.

impl<'a> From<&'a U16Str> for &'a [u16]

fn from(value: &'a U16Str) -> &'a [u16]

Converts to this type from the input type.

impl<'a> From<&'a Utf16Str> for &'a U16Str

fn from(value: &'a Utf16Str) -> &'a U16Str

Converts to this type from the input type.

impl<'a> From<&'a mut [u16]> for &'a U16Str

fn from(value: &'a mut [u16]) -> &'a U16Str

Converts to this type from the input type.

impl<'a> From<&'a mut [u16]> for &'a mut U16Str

fn from(value: &'a mut [u16]) -> &'a mut U16Str

Converts to this type from the input type.

impl<'a> From<&'a mut U16Str> for &'a mut [u16]

fn from(value: &'a mut U16Str) -> &'a mut [u16]

Converts to this type from the input type.

impl<'a> FromIterator<&'a U16Str> for U16String

fn from_iter<T>(iter: T) -> U16String

where T: IntoIterator<Item = &'a U16Str>,

Creates a value from an iterator.

impl Hash for U16Str

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

where __H: Hasher,

Feeds this value into the given Hasher.

impl<I> Index<I> for U16Str

where I: SliceIndex<[u16], Output = [u16]>,

type Output = U16Str

The returned type after indexing.

fn index(&self, index: I) -> &<U16Str as Index<I>>::Output

Performs the indexing (container[index]) operation.

impl<I> IndexMut<I> for U16Str

where I: SliceIndex<[u16], Output = [u16]>,

fn index_mut(&mut self, index: I) -> &mut <U16Str as Index<I>>::Output

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

impl<'a> IntoParameter for &'a U16Str

type Parameter = VarCell<&'a [u16], WideText>

fn into_parameter(self) -> Self::Parameter

impl Ord for U16Str

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

This method returns an Ordering between self and other.

impl PartialEq<&U16CStr> for U16Str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&U16Str> for U16CStr

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&U16Str> for U16Str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<&'a U16Str> for U16String

fn eq(&self, other: &&'a U16Str) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<U16CStr> for &U16Str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<U16CStr> for U16Str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<U16CString> for &U16Str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<U16CString> for U16Str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<U16Str> for &U16CStr

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<U16Str> for &U16Str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<U16Str> for U16CStr

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<U16Str> for U16String

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<U16Str> for Utf16Str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<U16String> for &U16Str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<U16String> for U16Str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Utf16Str> for U16Str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Utf16String> for U16Str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for U16Str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd<&'a U16Str> for U16String

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<U16CStr> for U16Str

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<U16Str> for U16CStr

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<U16Str> for U16String

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd for U16Str

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl ToOwned for U16Str

type Owned = U16String

The resulting type after obtaining ownership.

fn to_owned(&self) -> U16String

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

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

impl<'a> TryFrom<&'a U16Str> for &'a Utf16Str

type Error = Utf16Error

The type returned in the event of a conversion error.

fn try_from( value: &'a U16Str, ) -> Result<&'a Utf16Str, <&'a Utf16Str as TryFrom<&'a U16Str>>::Error>

Performs the conversion.

impl Eq for U16Str

impl StructuralPartialEq for U16Str