Struct widestring::ustring::U32String

source ·
pub struct U32String { /* private fields */ }
Expand description

An owned, mutable 32-bit wide string with undefined encoding.

The string slice of a U32String is U32Str.

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

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

§FFI considerations

U32String is not aware of nul values. Strings may or may not be nul-terminated, and may contain invalid and ill-formed UTF-32. 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.

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

§Examples

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

use widestring::{u32str, U32String};
let hello = U32String::from(u32str!("Hello, world!"));

You can also convert any u32 slice or vector directly:

use widestring::{u32str, U32String};

let sparkle_heart = vec![0x1f496];
let sparkle_heart = U32String::from_vec(sparkle_heart);

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

// This UTf-16 surrogate is invalid UTF-32, but is perfectly valid in U32String
let malformed_utf32 = vec![0x0, 0xd83d]; // Note that nul values are also valid an untouched
let s = U32String::from_vec(malformed_utf32);

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

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

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§

source§

impl U32String

source

pub const fn new() -> Self

Constructs a new empty wide string.

source

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

Constructs a wide string 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);
source

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

Constructs a wide string 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.

source

pub fn with_capacity(capacity: usize) -> Self

Constructs a wide string 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.

source

pub fn capacity(&self) -> usize

Returns the capacity this wide string can hold without reallocating.

source

pub fn clear(&mut self)

Truncates the wide string to zero length.

source

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

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

More space may be reserved to avoid frequent allocations.

source

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

Reserves the minimum capacity for exactly additional more capacity to be inserted in the given wide string. 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.

source

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

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

source

pub fn as_ustr(&self) -> &U32Str

Converts to a wide string slice.

source

pub fn as_mut_ustr(&mut self) -> &mut U32Str

Converts to a mutable wide string slice.

source

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

Returns a Vec reference to the contents of this string.

source

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

Returns a mutable reference to the contents of this string.

source

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

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, or invalid encoding, 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);
let cloned = wstr.clone();
// Push the clone to the end, repeating the string twice.
wstr.push(cloned);

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

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

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, or invalid encoding, 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);
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");
source

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the wide string to match its length.

source

pub fn shrink_to(&mut self, min_capacity: usize)

Shrinks the capacity of this string 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.

source

pub fn into_boxed_ustr(self) -> Box<U32Str>

Converts this wide string into a boxed string slice.

§Examples
use widestring::{U32String, U32Str};

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

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

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.

source

pub fn insert_ustr(&mut self, idx: usize, string: &U32Str)

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.

source

pub fn split_off(&mut self, at: usize) -> U32String

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.

source

pub fn retain<F>(&mut self, f: F)
where F: FnMut(u32) -> bool,

Retains only the elements specified by the predicate.

In other words, remove all elements e such that f(e) returns false. This method operates in place, visiting each element exactly once in the original order, and preserves the order of the retained elements.

source

pub fn drain<R>(&mut self, range: R) -> Drain<'_, u32>
where R: RangeBounds<usize>,

Creates a draining iterator that removes the specified range in the string and yields the removed elements.

Note: The element range is removed even if the iterator is not consumed until the end.

§Panics

Panics if the starting point or end point are out of bounds.

source

pub fn replace_range<R>(&mut self, range: R, replace_with: impl AsRef<U32Str>)
where R: RangeBounds<usize>,

Removes the specified range in the string, and replaces it with the given string.

The given string doesn’t need to be the same length as the range.

§Panics

Panics if the starting point or end point are out of bounds.

source§

impl U32String

source

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

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

Constructs a U16String copy from a str, encoding it as UTF-32.

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

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

Constructs 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);
source

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.

source

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

Extends the string with the given string slice, encoding it at UTF-32.

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

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

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

Appends the given char encoded as UTF-32 to the end of this string.

source

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

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

This method assumes UTF-32 encoding.

Returns None if this String is empty.

source

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

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

This method assumes UTF-32 encoding.

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.

source

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

Inserts a character encoded as UTF-32 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 = U32Str>§

source

pub fn to_ustring(&self) -> U32String

Copies the string reference to a new owned wide string.

source

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

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

source

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

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

source

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

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.

source

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

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.

source

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

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++.

source

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

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++.

source

pub fn len(&self) -> usize

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

source

pub fn is_empty(&self) -> bool

Returns whether this string contains no data.

source

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

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-32 encoding, but handles ill-formed UTF-32 sequences lossily. The returned struct implements the Display trait in a way that decoding the string is lossy UTF-32 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::U32Str;

// 𝄞mus<invalid>ic<invalid>
let s = U32Str::from_slice(&[
    0x1d11e, 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::U32Str;

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

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

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

Returns a subslice of the string.

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

source

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

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.

source

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

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.

source

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

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.

source

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.

source

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.

source

pub fn repeat(&self, n: usize) -> U32String

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

§Panics

This function will panic if the capacity would overflow.

source

pub fn to_os_string(&self) -> OsString

Decodes a string 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 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));
source

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

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

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

§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);
source

pub fn to_string_lossy(&self) -> String

Decodes the string reference to a String even if it is invalid UTF-32 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::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);
source

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

Returns an iterator over the chars of a string slice.

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

source

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

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-32. Since it may consist of invalid UTF-32, 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.

source

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

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-32. Since it may consist of invalid UTF-32, the iterator returned by this method is an iterator over Result<char, DecodeUtf32Error> 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.

source

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

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

As this string slice may consist of invalid UTF-32, the iterator returned by this method will replace invalid values 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§

source§

impl Add<&U32CStr> for U32String

§

type Output = U32String

The resulting type after applying the + operator.
source§

fn add(self, rhs: &U32CStr) -> Self::Output

Performs the + operation. Read more
source§

impl Add<&U32Str> for U32String

§

type Output = U32String

The resulting type after applying the + operator.
source§

fn add(self, rhs: &U32Str) -> Self::Output

Performs the + operation. Read more
source§

impl Add<&Utf32Str> for U32String

§

type Output = U32String

The resulting type after applying the + operator.
source§

fn add(self, rhs: &Utf32Str) -> Self::Output

Performs the + operation. Read more
source§

impl Add<&str> for U32String

§

type Output = U32String

The resulting type after applying the + operator.
source§

fn add(self, rhs: &str) -> Self::Output

Performs the + operation. Read more
source§

impl AddAssign<&U32CStr> for U32String

source§

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

Performs the += operation. Read more
source§

impl AddAssign<&U32Str> for U32String

source§

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

Performs the += operation. Read more
source§

impl AddAssign<&Utf32Str> for U32String

source§

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

Performs the += operation. Read more
source§

impl AddAssign<&str> for U32String

source§

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

Performs the += operation. Read more
source§

impl AsMut<[u32]> for U32String

source§

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

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

impl AsMut<U32Str> for U32String

source§

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

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

impl AsRef<[u32]> for U32String

source§

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

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

impl AsRef<U32Str> for U32String

source§

fn as_ref(&self) -> &U32Str

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

impl Borrow<U32Str> for U32String

source§

fn borrow(&self) -> &U32Str

Immutably borrows from an owned value. Read more
source§

impl BorrowMut<U32Str> for U32String

source§

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

Mutably borrows from an owned value. Read more
source§

impl Clone for U32String

source§

fn clone(&self) -> U32String

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for U32String

source§

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

Formats the value using the given formatter. Read more
source§

impl Default for U32String

source§

fn default() -> U32String

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

impl Deref for U32String

§

type Target = U32Str

The resulting type after dereferencing.
source§

fn deref(&self) -> &U32Str

Dereferences the value.
source§

impl DerefMut for U32String

source§

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

Mutably dereferences the value.
source§

impl<'a> Extend<&'a U32CStr> for U32String

source§

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

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

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. Read more
source§

impl<'a> Extend<&'a U32Str> for U32String

source§

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

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

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. Read more
source§

impl<'a> Extend<&'a Utf32Str> for U32String

source§

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

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

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. Read more
source§

impl<'a> Extend<&'a char> for U32String

source§

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

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

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. Read more
source§

impl<'a> Extend<&'a str> for U32String

source§

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

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

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. Read more
source§

impl Extend<Box<U32Str>> for U32String

source§

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

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

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. Read more
source§

impl<'a> Extend<Cow<'a, U32Str>> for U32String

source§

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

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

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. Read more
source§

impl Extend<String> for U32String

source§

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

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

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. Read more
source§

impl Extend<U32CString> for U32String

source§

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

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

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. Read more
source§

impl Extend<U32String> for U32String

source§

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

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

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. Read more
source§

impl Extend<Utf32String> for U32String

source§

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

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

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. Read more
source§

impl Extend<char> for U32String

source§

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

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

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. Read more
source§

impl From<&[char]> for U32String

source§

fn from(value: &[char]) -> Self

Converts to this type from the input type.
source§

impl<'a, T: ?Sized + AsRef<U32Str>> From<&'a T> for U32String

source§

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

Converts to this type from the input type.
source§

impl From<&str> for U32String

source§

fn from(s: &str) -> Self

Converts to this type from the input type.
source§

impl From<Box<U32Str>> for U32String

source§

fn from(boxed: Box<U32Str>) -> Self

Converts to this type from the input type.
source§

impl From<OsString> for U32String

source§

fn from(s: OsString) -> Self

Converts to this type from the input type.
source§

impl From<String> for U32String

source§

fn from(s: String) -> Self

Converts to this type from the input type.
source§

impl From<U32CString> for U32String

source§

fn from(s: U32CString) -> Self

Converts to this type from the input type.
source§

impl From<U32String> for Box<U32Str>

source§

fn from(s: U32String) -> Self

Converts to this type from the input type.
source§

impl<'a> From<U32String> for Cow<'a, U32Str>

source§

fn from(s: U32String) -> Self

Converts to this type from the input type.
source§

impl From<U32String> for OsString

source§

fn from(s: U32String) -> Self

Converts to this type from the input type.
source§

impl From<U32String> for Vec<u32>

source§

fn from(value: U32String) -> Self

Converts to this type from the input type.
source§

impl From<Utf32String> for U32String

source§

fn from(value: Utf32String) -> Self

Converts to this type from the input type.
source§

impl From<Vec<char>> for U32String

source§

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

Converts to this type from the input type.
source§

impl From<Vec<u32>> for U32String

source§

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

Converts to this type from the input type.
source§

impl<'a> FromIterator<&'a U32CStr> for U32String

source§

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

Creates a value from an iterator. Read more
source§

impl<'a> FromIterator<&'a U32Str> for U32String

source§

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

Creates a value from an iterator. Read more
source§

impl<'a> FromIterator<&'a Utf32Str> for U32String

source§

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

Creates a value from an iterator. Read more
source§

impl<'a> FromIterator<&'a char> for U32String

source§

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

Creates a value from an iterator. Read more
source§

impl<'a> FromIterator<&'a str> for U32String

source§

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

Creates a value from an iterator. Read more
source§

impl FromIterator<Box<U32Str>> for U32String

source§

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

Creates a value from an iterator. Read more
source§

impl<'a> FromIterator<Cow<'a, U32Str>> for U32String

source§

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

Creates a value from an iterator. Read more
source§

impl FromIterator<String> for U32String

source§

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

Creates a value from an iterator. Read more
source§

impl FromIterator<U32CString> for U32String

source§

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

Creates a value from an iterator. Read more
source§

impl FromIterator<U32String> for U32String

source§

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

Creates a value from an iterator. Read more
source§

impl FromIterator<Utf32String> for U32String

source§

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

Creates a value from an iterator. Read more
source§

impl FromIterator<char> for U32String

source§

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

Creates a value from an iterator. Read more
source§

impl FromStr for U32String

§

type Err = Infallible

The associated error which can be returned from parsing.
source§

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type. Read more
source§

impl Hash for U32String

source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · source§

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

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

impl<I> Index<I> for U32String
where I: SliceIndex<[u32], Output = [u32]>,

§

type Output = U32Str

The returned type after indexing.
source§

fn index(&self, index: I) -> &U32Str

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

impl<I> IndexMut<I> for U32String
where I: SliceIndex<[u32], Output = [u32]>,

source§

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

Performs the mutable indexing (container[index]) operation. Read more
source§

impl Ord for U32String

source§

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

This method returns an Ordering between self and other. Read more
1.21.0 · source§

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

Compares and returns the maximum of two values. Read more
1.21.0 · source§

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

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

impl<'a> PartialEq<&'a U32CStr> for U32String

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a> PartialEq<&'a U32Str> for U32String

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a> PartialEq<Cow<'a, U32CStr>> for U32String

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a> PartialEq<Cow<'a, U32Str>> for U32String

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq<U32CStr> for U32String

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq<U32CString> for U32String

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq<U32Str> for U32String

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq<U32String> for &U32CStr

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq<U32String> for &U32Str

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq<U32String> for U32CStr

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq<U32String> for U32CString

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq<U32String> for U32Str

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq<U32String> for Utf32Str

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq<U32String> for Utf32String

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq<Utf32Str> for U32String

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq<Utf32String> for U32String

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq for U32String

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a> PartialOrd<&'a U32CStr> for U32String

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

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

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

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

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

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

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

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

impl<'a> PartialOrd<&'a U32Str> for U32String

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

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

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

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

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

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

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

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

impl<'a> PartialOrd<Cow<'a, U32CStr>> for U32String

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

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

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

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

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

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

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

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

impl<'a> PartialOrd<Cow<'a, U32Str>> for U32String

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

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

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

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

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

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

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

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

impl PartialOrd<U32CStr> for U32String

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

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

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

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

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

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

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

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

impl PartialOrd<U32CString> for U32String

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

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

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

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

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

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

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

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

impl PartialOrd<U32Str> for U32String

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

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

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

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

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

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

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

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

impl PartialOrd<U32String> for U32CString

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

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

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

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

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

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

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

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

impl PartialOrd for U32String

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

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

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

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

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

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

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

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

impl TryFrom<U32String> for Utf32String

§

type Error = Utf32Error

The type returned in the event of a conversion error.
source§

fn try_from(value: U32String) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl Write for U32String

source§

fn write_str(&mut self, s: &str) -> Result

Writes a string slice into this writer, returning whether the write succeeded. Read more
source§

fn write_char(&mut self, c: char) -> Result

Writes a char into this writer, returning whether the write succeeded. Read more
1.0.0 · source§

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait. Read more
source§

impl Eq for U32String

source§

impl StructuralPartialEq for U32String

Auto Trait Implementations§

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

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

source§

fn into(self) -> U

Calls U::from(self).

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

source§

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

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

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

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

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

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

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

§

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

The type returned in the event of a conversion error.
source§

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

Performs the conversion.