Struct roblox::data_type::string::String

pub struct String {}

A UTF-8–encoded, growable string.

The String type is the most common string type that has ownership over the contents of the string. It has a close relationship with its borrowed counterpart, the primitive str.

This type is equivalent to the normal Rust string type, but is not actually functional, and also implements the Copy trait.

Implementations

impl String

pub fn new() -> Self

Creates a new empty String.

This will compile into an empty string literal.

pub fn with_capacity(capacity: usize) -> Self

Creates a new empty String with a particular capacity.

Note that Strings in Luau do not have a capacity in the same way as Rust, so this is equivalent to new() and is only present for compatibility with the normal Rust String type.

pub fn from_utf8(vec: Vec<u8>) -> Result<Self, FromUtf8Error>

Converts a vector of bytes to a String.

pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str>

Converts a slice of bytes to a string, including invalid characters.

pub fn from_utf16(v: &[u16]) -> Result<Self, FromUtf16Error>

Decode a UTF-16–encoded vector v into a String, returning Err if v contains any invalid data.

pub fn from_utf16_lossy(v: &[u16]) -> Self

Decode a UTF-16–encoded slice v into a String, replacing invalid data with the replacement character (U+FFFD).

Unlike from_utf8_lossy which returns a Cow<'a, str>, from_utf16_lossy returns a String since the UTF-16 to UTF-8 conversion requires a memory allocation.

pub unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> Self

Converts a vector of bytes to a String without checking that the string contains valid UTF-8.

See the safe version, from_utf8, for more details.

Safety

This function is unsafe because it does not check that the bytes passed to it are valid UTF-8. If this constraint is violated, it may cause memory unsafety issues with future users of the String, as the rest of the standard library assumes that Strings are valid UTF-8.

pub fn into_bytes(self) -> Vec<u8>

Converts a String into a byte vector.

This consumes the String, so we do not need to copy its contents.

pub fn as_str(&self) -> &str

Extracts a string slice containing the entire String.

pub fn as_mut_str(&mut self) -> &mut str

Converts a String into a mutable string slice.

pub fn push_str(&mut self, string: &str)

Appends a given string slice onto the end of this String.

pub fn capacity(&self) -> usize

Returns this String’s capacity, in bytes.

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

Ensures that this String’s capacity is at least additional bytes larger than its length.

This function actually does nothing in Luau, and will not be transpiled.

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

Ensures that this String’s capacity is additional bytes larger than its length.

This function does nothing in Luau and will not be transpiled.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of this String to match its length.

This function does nothing in Luau and will not be transpiled.

pub fn push(&mut self, ch: char)

Appends the given char to the end of this String.

pub fn as_bytes(&self) -> &[u8]

Returns a byte slice of this String’s contents.

The inverse of this method is from_utf8.

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.

Panics

Panics if new_len does not lie on a char boundary.

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

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

Returns None if this String is empty.

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

Removes a char from this String at a byte position and returns it.

Panics

Panics if idx is larger than or equal to the String’s length, or if it does not lie on a char boundary.

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

Retains only the characters specified by the predicate.

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

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

Inserts a character into this String at a byte position.

Panics

Panics if idx is larger than the String’s length, or if it does not lie on a char boundary.

pub fn insert_str(&mut self, idx: usize, string: &str)

Inserts a string slice into this String at a byte position.

Panics

Panics if idx is larger than the String’s length, or if it does not lie on a char boundary.

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

Returns a mutable reference to the contents of this String.

pub fn len(&self) -> usize

Returns the length of this String, in bytes, not chars or graphemes. In other words, it may not be what a human considers the length of the string.

pub fn is_empty(&self) -> bool

Returns true if this String has a length of zero, and false otherwise.

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

Splits the string into two at the given byte index.

Returns a newly allocated String. self contains bytes [0, at), and the returned String contains bytes [at, len). at must be on the boundary of a UTF-8 code point.

Panics

Panics if at is not on a UTF-8 code point boundary, or if it is beyond the last code point of the string.

pub fn clear(&mut self)

Truncates this String, removing all contents.

While this means the String will have a length of zero, it does not touch its capacity.

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

Creates a draining iterator that removes the specified range in the String and yields the removed chars.

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 do not lie on a char boundary, or if they’re out of bounds.

pub fn replace_range<R>(&mut self, range: R, replace_with: &str) 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 do not lie on a char boundary, or if they’re out of bounds.

pub fn into_boxed_str(self) -> Box<str>

Converts this String into a Box<str>.

Trait Implementations

impl Add<&'_ str> for String

type Output = String

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&'_ str> for String

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

Performs the += operation.

impl AsMut<str> for String

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

Performs the conversion.

impl AsRef<[u8]> for String

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

Performs the conversion.

impl AsRef<OsStr> for String

fn as_ref(&self) -> &OsStr

Performs the conversion.

impl AsRef<Path> for String

fn as_ref(&self) -> &Path

Performs the conversion.

impl AsRef<str> for String

fn as_ref(&self) -> &str

Performs the conversion.

impl Borrow<str> for String

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl BorrowMut<str> for String

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

Mutably borrows from an owned value.

impl Clone for String

fn clone(&self) -> String

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for String

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

Formats the value using the given formatter.

impl Default for String

fn default() -> Self

Returns the “default value” for a type.

impl Deref for String

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for String

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

Mutably dereferences the value.

impl Display for String

Implements display for the String type.

This would never run in normal Rust, so anything can be written out.

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

Formats the value using the given formatter.

impl From<&'_ str> for String

Implement from for &str, but don’t do anything other than returning an empty instance of itself.

fn from(string: &str) -> Self

Performs the conversion.

impl From<String> for String

Convert from Rust’s String type to this String type automatically.

fn from(string: String) -> Self

Performs the conversion.

impl PartialEq<String> for String

fn eq(&self, other: &String) -> 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 Copy for String

impl StructuralPartialEq for String