Struct FsString

Source

pub struct FsString { /* private fields */ }

Expand description

A type that represents a mutable and owned VEXos filesystem string, while being cheaply inter-convertible with Rust strings.

FsString is NOT null terminated. If you need to pass this to VEX SDK filesystem functions, create a CStr.

An FsString is to &FsStr as String is to &str; the former are owned, while the latter are borrowed references.

Implementations§

Source §

impl FsString

Source

pub const fn new() -> Self

Allocates a new, empty, FsString.

Source

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

Creates a new FsString from the raw encoded bytes.

§Safety

This function does not check if there are nul bytes withing or terminating the string. Passing an invalid FsString to VEX SDK functions can have unintended consequences, including undefined behavior.

Source

pub fn as_fs_str(&self) -> &FsStr

Borrows an FsString as an FsStr.

This is akin to taking a slice of the entire FsString

Source

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

Returns the raw encoded bytes of the FsString

Source

pub fn into_string(self) -> Result<String, FsString>

Converts the FsString to a String, or returns the original FsString on failure.

§Errors

This function will return the original string in the Err variant if the FsString was not valid UTF-8

Source

pub fn push<S: AsRef<FsStr>>(&mut self, s: S)

Extends the FsString with the given string.

As an example, the stored data in this example will be equivalent to “foobarbaz”:

let mut foo = FsString::new();
foo.push("foo");
foo.push("bar");
foo.push("baz");

Source

pub fn with_capacity(capacity: usize) -> Self

Creates a new FsString with the given capacity. For more information on capacity, look at the Vec::with_capacity documentation.

Source

pub fn clear(&mut self)

Clears all data from the FsString. This has no effect on the capacity of the FsString

§Examples

let mut string = FsString::with_capacity(100);
string.push("hello :3");
assert!(string.capacity() >= 100);
string.clear();
assert!(string.capacity() >= 100)

Source

pub fn capacity(&self) -> usize

Returns the capacity of the FsString. The capacity of the string will be equivalent to the maximum number of characters unless special characters are used.

Source

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

Reserves at least additional bytes in the FsString.

In order to reduce allocations, this function will often reserve more than additional bytes. For more information on the logic behind reserving bytes, see the Vec::reserve documentation.

Source

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

Attempts to reserve at least additional bytes in the FsString.

In order to reduce allocations, this function will often reserve more than additional bytes. For more information on the logic behind reserving bytes, see the Vec::reserve documentation.

§Errors

This function will error under the following conditions:

The capacity of the FsString has surpasses isize::MAX bytes
An allocation error occured while reserving space.

Source

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

Reserves additional bytes in the FsString.

§Note

Reserving an exact amount of times can often negatively impact performace. you most likely want to use FsString::reserve

Source

pub fn try_reserve_exact( &mut self, additional: usize, ) -> Result<(), TryReserveError>

Attempts to reserve additional bytes in the FsString.

§Note

Reserving an exact amount of times can often negatively impact performace. you most likely want to use FsString::reserve

§Errors

This function will error under the following conditions:

The capacity of the FsString has surpasses isize::MAX bytes
An allocation error occured while reserving space.

Source

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the FsString as much as possible.

Depending on the allocator implementation, the FsString may still have extra capacity. See core::alloc::Allocator::shrink for more info.

Source

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

Shrinks the capacity of the FsString to a lower bound.

Source

pub fn into_boxed_fs_str(self) -> Box<FsStr>

Consumes and converts this FsString into a Box<FsStr>. Excess capacity is discarded.

Source

pub fn leak<'a>(self) -> &'a mut FsStr

Consumes and leaks this FsString and converts it to a &FsStr.

Methods from Deref<Target = FsStr>§

Source

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

Converts an FS string slice to a byte slice. To convert the byte slice back into an FS string slice, use the FsStr::from_encoded_bytes_unchecked function.

§Note

As the encoding is unspecified, any sub-slice of bytes that is not valid UTF-8 should be treated as opaque and only comparable within the same Rust version built for the same target platform. For example, sending the slice over the network or storing it in a file will likely result in incompatible byte slices.

Source

pub fn to_fs_string(&self) -> FsString

Copies this FsStr into an owned FsString.

§Examples

let fs_str = FsStr::new("foo");
let fs_string = fs_str.to_fs_string();
assert_eq!(ofs_string.as_encoded_bytes(), fs_str.as_encoded_bytes());

Source

pub fn to_string_lossy(&self) -> Cow<'_, str>

Converts an FsStr into a UTF-8 encoded string.

Any non-UTF-8 sequences are replaced with the unicode U+FFFD REPLACEMENT CHARACTER.

Source

pub fn is_empty(&self) -> bool

Checks whether or not the FsStr is empty.

§Examples

let fs_str = FsStr::new("");
assert!(fs_str.is_empty());

let fs_str = FsStr::new("foo");
assert!(!fs_str.is_empty());

Source

pub fn len(&self) -> usize

Returns the length of the FsStr.

§Examples

let fs_str = FsStr::new("");
assert_eq!(fs_str.len(), 0);

let fs_str = FsStr::new("foo");
assert_eq!(fs_str.len(), 3);

Source

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

Returns a Display which can be used to display FsStrs that may contain non-UTF-8 data. This may perform lossy conversions. For an implementation that escapes the data, use Debug.