Struct calf_vec::string::SmallCowString

pub struct SmallCowString<'a, M: Meta, const N: usize> { /* fields omitted */ }

Implementations

impl<'a, M: Meta, const N: usize> SmallCowString<'a, M, N>

pub fn from_utf8<V: Into<SmallCowVec<'a, M, u8, N>>>(
    vec: V
) -> Result<SmallCowString<'a, M, N>, FromUtf8Error<'a, M, N>>

Converts a vector of bytes to a SmallCowString.

A string (String) is made of bytes (u8), and a vector of bytes (Vec<u8>) is made of bytes, so this function converts between the two. Not all byte slices are valid Strings, however: String requires that it is valid UTF-8. from_utf8() checks to ensure that the bytes are valid UTF-8, and then does the conversion.

If you are sure that the byte slice is valid UTF-8, and you don't want to incur the overhead of the validity check, there is an unsafe version of this function, [from_utf8_unchecked], which has the same behavior but skips the check.

This method will take care to not copy the vector, for efficiency's sake.

The inverse of this method is [into_bytes].

Errors

Returns Err if the slice is not UTF-8 with a description as to why the provided bytes are not UTF-8. The vector you moved in is also included.

pub fn len(&self) -> usize

Returns this String's size, in bytes.

pub fn capacity(&self) -> Option<usize>

Returns this String's capacity, in bytes.

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

Ensures that this SmallCowString's capacity is at least additional bytes larger than its length.

The capacity may be increased by more than additional bytes if it chooses, to prevent frequent reallocations.

If you do not want this "at least" behavior, see the reserve_exact method.

Panics

Panics if the new capacity overflows usize.

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

Appends the given char to the end of this SmallCowString.

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.

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

Panics

Panics if new_len does not lie on a char boundary.

Trait Implementations

impl<'a, M: Meta, const N: usize> Deref for SmallCowString<'a, M, N>

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &str

Dereferences the value.

impl<'a, M: Meta, const N: usize> DerefMut for SmallCowString<'a, M, N>

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

Mutably dereferences the value.