Struct byte_str::ByteString

pub struct ByteString { /* fields omitted */ }

and Vec<u8>.

Methods

impl ByteString

fn new() -> Self

Creates a new empty ByteString without allocating any memory.

fn from_vec(vec: Vec<u8>) -> Self

Converts a vector of bytes into a ByteString without clones or allocation.

fn from_slice(slice: &[u8]) -> Self

Creates a ByteString from a slice.

fn as_vec(&self) -> &Vec<u8>

Returns a reference to the underlying byte vector.

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

Returns a mutable reference to the underlying byte vector.

fn into_vec(self) -> Vec<u8>

Converts self into a vector without clones or allocation.

fn into_boxed_slice(self) -> Box<[u8]>

Converts self into a boxed slice, dropping any excess capacity.

fn into_boxed_byte_str(self) -> Box<ByteStr>

Converts self into a boxed ByteStr, dropping any excess capacity.

fn as_byte_str(&self) -> &ByteStr

Returns a ByteStr containing the entiere string.

fn as_mut_byte_str(&mut self) -> &mut ByteStr

Returns a mutable ByteStr containing the entiere string.

fn capacity(&self) -> usize

Returns the number of byte the string can hold without reallocating.

fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more bytes to be inserted into self.

fn reserve_exact(&mut self, additional: usize)

Reserves the minimum capacity for exactly additional more elements to be inserted into self.

fn shrink_to_fit(&mut self)

Shrinks the capacity of the string as much as possible.

fn truncate(&mut self, len: usize)

Shortens the string, keeping the first len bytes.

fn clear(&mut self)

Clears the vector, removing all values and keeping the capacity of the string.

unsafe fn set_len(&mut self, len: usize)

Sets the length of a vector.

This will explicitly set the size of the vector, without actually modifying its buffers, so it is up to the caller to ensure that the vector is actually the specified size.

fn swap_remove(&mut self, index: usize) -> u8

Removes an element from the vector and returns it.

The removed element is replaced by the last element of the vector.

This does not preserve ordering, but is O(1).

Panics

Panics if index is out of bounds.

fn insert(&mut self, index: usize, element: u8)

Inserts an element at position index within the string, shifting all elements after it to the right.

Panics

Panics if index is out of bounds.

fn remove(&mut self, index: usize) -> u8

Removes and returns the element at position index within the string, shifting all elements after it to the left.

Panics

Panics if index is out of bounds.

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

Retains only the elements specified by the predicate.

fn dedup_by_key<F, K>(&mut self, key: F) where
    F: FnMut(&mut u8) -> K,
    K: PartialEq<K>, 

Removes all but the first of consecutive elements in the string that resolve to the same key.

Similar to Vec::dedup_by_key().

fn dedup_by<F>(&mut self, same_bucket: F) where
    F: FnMut(&mut u8, &mut u8) -> bool, 

Removes all but the first of consecutive elements in the string satisfying a given equality relation.

Similar to Vec::dedup_by().

fn dedup(&mut self)

Removes consecutive repeated elements in the vector.

If the vector is sorted, this removes all duplicates.

fn push(&mut self, element: u8)

Appends an element to the back of the string.

fn pop(&mut self) -> Option<u8>

Removes the last element from a string and returns it, or None if it is empty.

fn push_slice(&mut self, other: &[u8])

Appends a slice to the back of the string.

fn push_byte_str(&mut self, other: &ByteStr)

Appends a ByteStr to the back of the string.

fn insert_slice(&mut self, index: usize, other: &[u8])

Inserts a slice at position index within the string, shifting all elements after it to the right.

Panics

Panics if index is out of bounds.

fn insert_byte_str(&mut self, index: usize, other: &ByteStr)

Inserts a ByteStr at position index within the string, shifting all elements after it to the right.

Panics

Panics if index is out of bounds.

fn drain(&mut self, start: Option<usize>, end: Option<usize>) -> Drain<u8>

Creates a draining iterator that removes the specified range in the vector and yields the removed items.

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

Splits the string into two at the given index.

Returns a newly allocated ByteString. self contains elements [0, at), and the returned ByteString contains elements [at, len).

Panics

Panics if at > len.

Methods from Deref<Target = ByteStr>

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

Converts self into a byte slice.

fn as_mut_slice(&mut self) -> &mut [u8]

Converts self into a mutable byte slice.

fn to_vec(&self) -> Vec<u8>

Copies the self into a Vec.

fn to_byte_string(&self) -> ByteString

Copies the self into a ByteString.

fn len(&self) -> usize

Returns the length of self.

fn is_empty(&self) -> bool

Returns true if the length of self is zero.

fn as_ptr(&self) -> *const u8

Converts self into a raw pointer that points to the first byte of the string.

fn as_mut_ptr(&mut self) -> *mut u8

Converts self into a mutable raw pointer that points to the first byte of the string.

fn get(&self, index: usize) -> Option<&u8>

Returns a reference to an element of the slice, or None if the index is out of bounds.

fn get_mut(&mut self, index: usize) -> Option<&mut u8>

Returns a mutable reference to an element of the slice, or None if the index is out of bounds.

fn first(&self) -> Option<&u8>

Returns a reference to the first byte of the string, or None if it is empty.

fn first_mut(&mut self) -> Option<&mut u8>

Returns a mutable reference to the first byte of the string, or None if it is empty.

fn last(&self) -> Option<&u8>

Returns a reference to the last byte of the string, or None if it is empty.

fn last_mut(&mut self) -> Option<&mut u8>

Returns a mutable reference to the last byte of the string, or None if it is empty.

fn split_first(&self) -> Option<(&u8, &ByteStr)>

Returns the first and all the rest of the bytes of the slice, or None if it is empty.

fn split_first_mut(&mut self) -> Option<(&mut u8, &mut ByteStr)>

Returns the first and all the rest of the bytes of the slice, or None if it is empty.

fn split_last(&self) -> Option<(&u8, &ByteStr)>

Returns the last and all the rest of the bytes of the slice, or None if it is empty.

fn split_last_mut(&mut self) -> Option<(&mut u8, &mut ByteStr)>

Returns the last and all the rest of the bytes of the slice, or None if it is empty.

fn iter<'a>(&'a self) -> Iter<'a, u8>

Returns an iterator over the string.

fn iter_mut<'a>(&'a mut self) -> IterMut<'a, u8>

Returns an iterator that allows modifying each value.

fn windows<'a>(&'a self, size: usize) -> Windows<'a>

Returns an iterator over all contiguous windows of length size. The windows overlap. If the string is shorter than size, the iterator returns no values.

Similar to slice::windows().

fn chunks<'a>(&'a self, size: usize) -> Chunks<'a>

Returns an iterator over size bytes of the string at a time. The chunks do not overlap. If size does not divide the length of the slice, then the last chunk will not have length size.

Similar to slice::chunks().

fn chunks_mut<'a>(&'a mut self, size: usize) -> ChunksMut<'a>

Returns an iterator over size elements of the slice at a time. The chunks are mutable strings and do not overlap. If size does not divide the length of the slice, then the last chunk will not have length size.

Similar to slice::chunks_mut().

fn split_at(&self, mid: usize) -> (&ByteStr, &ByteStr)

Divides one string into two at an index.

The first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

Similar to slice::split_at().

Panics

Panics if mid > len.

fn split_at_mut(&mut self, mid: usize) -> (&mut ByteStr, &mut ByteStr)

Divides one &mut string into two at an index.

The first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

Similar to slice::split_at_mut().

Panics

Panics if mid > len.

fn split<'a, M: IntoMatcher>(&'a self, m: M) -> Split<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ForwardSearcher, 

Returns an iterator over substrings of this string, separated by a matcher.

fn split_mut<'a, M: IntoMatcher>(&'a mut self, m: M) -> SplitMut<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ForwardSearcher, 

Returns an iterator over mutable substrings of this string, separated by a matcher.

fn rsplit<'a, M: IntoMatcher>(&'a self, m: M) -> RSplit<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ReverseSearcher, 

Returns an iterator over substrings of this string, separated by a matcher, starting at the end of the slice and working backwards.

fn rsplit_mut<'a, M: IntoMatcher>(
    &'a mut self,
    m: M
) -> RSplitMut<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ReverseSearcher, 

Returns an iterator over mutable substrings of this string, separated by a matcher, starting at the end of the slice and working backwards.

fn splitn<'a, M: IntoMatcher>(
    &'a self,
    n: usize,
    m: M
) -> SplitN<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ForwardSearcher, 

Returns an iterator over substrings of this string, separated by a matcher, returning at most n items.

If n substrings are returned, the last substring will contain the remainder of the string.

fn splitn_mut<'a, M: IntoMatcher>(
    &'a mut self,
    n: usize,
    m: M
) -> SplitNMut<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ForwardSearcher, 

Returns an iterator over mutable substrings of this string, separated by a matcher, returning at most n items.

If n substrings are returned, the last substring will contain the remainder of the string.

fn rsplitn<'a, M: IntoMatcher>(
    &'a self,
    n: usize,
    m: M
) -> RSplitN<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ReverseSearcher, 

Returns an iterator over substrings of this string, separated by a matcher and stating from the end of the string, returning at most n items.

If n substrings are returned, the last substring will contain the remainder of the string.

fn rsplitn_mut<'a, M: IntoMatcher>(
    &'a mut self,
    n: usize,
    m: M
) -> RSplitNMut<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ReverseSearcher, 

Returns an iterator over mutable substrings of this string, separated by a matcher and stating from the end of the string, returning at most n items.

If n substrings are returned, the last substring will contain the remainder of the string.

fn matches<'a, M: IntoMatcher>(&'a self, m: M) -> Matches<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ForwardSearcher, 

Returns an iterator over the disjoint matches within the given string.

fn matches_mut<'a, M: IntoMatcher>(
    &'a mut self,
    m: M
) -> MatchesMut<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ForwardSearcher, 

Returns an iterator over the mutable disjoint matches within the given string.

fn rmatches<'a, M: IntoMatcher>(&'a self, m: M) -> RMatches<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ReverseSearcher, 

Returns an iterator over the disjoint matches within the given string, yielded in reverse order.

fn rmatches_mut<'a, M: IntoMatcher>(
    &'a mut self,
    m: M
) -> RMatchesMut<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ReverseSearcher, 

Returns an iterator over the mutable disjoint matches within the given string, yielded in reverse order.

fn match_indices<'a, M: IntoMatcher>(
    &'a self,
    m: M
) -> MatchIndices<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ForwardSearcher, 

Returns an iterator over the disjoint matches within the given string, as well as the index that the match starts at.

fn match_indices_mut<'a, M: IntoMatcher>(
    &'a mut self,
    m: M
) -> MatchIndicesMut<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ForwardSearcher, 

Returns an iterator over the mutable disjoint matches within the given string, as well as the index that the match starts at.

fn rmatch_indices<'a, M: IntoMatcher>(
    &'a self,
    m: M
) -> RMatchIndices<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ReverseSearcher, 

Returns an iterator over the disjoint matches within the given string, yielded in reverse order, as well as the index that the match starts at.

fn rmatch_indices_mut<'a, M: IntoMatcher>(
    &'a mut self,
    m: M
) -> RMatchIndicesMut<'a, M::Matcher> where
    <M as IntoMatcher>::Matcher: ReverseSearcher, 

Returns an iterator over the mutable disjoint matches within the given string, yielded in reverse order, as well as the index that the match starts at.

fn contains<M: IntoMatcher>(&self, m: M) -> bool where
    <M as IntoMatcher>::Matcher: ForwardSearcher, 

Returns true if the string contains a substring that matches the given matcher.

fn starts_with<M: IntoMatcher>(&self, m: M) -> bool where
    <M as IntoMatcher>::Matcher: PrefixMatcher, 

Returns true if the string beginning a matches the given matcher.

fn ends_with<M: IntoMatcher>(&self, m: M) -> bool where
    <M as IntoMatcher>::Matcher: SufixMatcher, 

Returns true if the string ending a matches the given matcher.

fn find<M: IntoMatcher>(&self, m: M) -> Option<usize> where
    <M as IntoMatcher>::Matcher: ForwardSearcher, 

Returns the byte index of the first character of self that matches the matcher or None it it doesn't match.

fn rfind<M: IntoMatcher>(&self, m: M) -> Option<usize> where
    <M as IntoMatcher>::Matcher: ReverseSearcher, 

Returns the byte index of the last character of self that matches the matcher or None it it doesn't match.

fn swap(&mut self, a: usize, b: usize)

Swaps two bytes in the string, indexed by a and b.

Panics

Panics if a or b are out of bounds.

fn reverse(&mut self)

Reverses the order of bytes in the slice.

fn copy_from_slice(&mut self, src: &[u8])

Copies all elements from src into self, using a memcpy.

The length of src must be the same as self.

fn copy_from_byte_str(&mut self, src: &ByteStr)

Copies all elements from src into self, using a memcpy.

The length of src must be the same as self.

Trait Implementations

impl Clone for ByteString

fn clone(&self) -> ByteString

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for ByteString

fn default() -> ByteString

Returns the "default value" for a type.

impl PartialEq for ByteString

fn eq(&self, __arg_0: &ByteString) -> bool

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

fn ne(&self, __arg_0: &ByteString) -> bool

This method tests for !=.

impl Eq for ByteString

impl<'a> From<&'a [u8]> for ByteString

fn from(src: &'a [u8]) -> Self

Performs the conversion.

impl<'a> From<&'a ByteStr> for ByteString

fn from(src: &'a ByteStr) -> Self

Performs the conversion.

impl<'a> From<&'a str> for ByteString

fn from(src: &'a str) -> Self

Performs the conversion.

impl From<Vec<u8>> for ByteString

fn from(src: Vec<u8>) -> Self

Performs the conversion.

impl From<Box<[u8]>> for ByteString

fn from(src: Box<[u8]>) -> Self

Performs the conversion.

impl From<Box<ByteStr>> for ByteString

fn from(src: Box<ByteStr>) -> Self

Performs the conversion.

impl From<Box<str>> for ByteString

fn from(src: Box<str>) -> Self

Performs the conversion.

impl From<String> for ByteString

fn from(src: String) -> Self

Performs the conversion.

impl FromIterator<u8> for ByteString

fn from_iter<T>(iter: T) -> Self where
    T: IntoIterator<Item = u8>, 

Creates a value from an iterator.

impl Debug for ByteString

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

Formats the value using the given formatter.

impl Deref for ByteString

type Target = ByteStr

The resulting type after dereferencing.

fn deref(&self) -> &ByteStr

Dereferences the value.

impl DerefMut for ByteString

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

Mutably dereferences the value.

impl Borrow<ByteStr> for ByteString

fn borrow(&self) -> &ByteStr

Immutably borrows from an owned value.

impl BorrowMut<ByteStr> for ByteString

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

Mutably borrows from an owned value.

impl Borrow<[u8]> for ByteString

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

Immutably borrows from an owned value.

impl BorrowMut<[u8]> for ByteString

fn borrow_mut(&mut self) -> &mut [u8]

Mutably borrows from an owned value.

impl AsRef<ByteStr> for ByteString

fn as_ref(&self) -> &ByteStr

Performs the conversion.

impl AsRef<[u8]> for ByteString

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

Performs the conversion.

impl AsMut<ByteStr> for ByteString

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

Performs the conversion.

impl AsMut<[u8]> for ByteString

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

Performs the conversion.