Struct tinyvec_string::arraystring::ArrayString

#[repr(transparent)]pub struct ArrayString<A: ByteArray> { /* fields omitted */ }

A UTF-8 encoded, fixed-capacity string.

An ArrayString is similar to String, but is backed by an ArrayVec instead of a Vec. This means it has similar characteristics to ArrayVec:

• An ArrayString has a fixed capacity (in bytes), the size of the backing array.
• An ArrayString has a dynamic length; characters can be added and removed. Attempting to add characters when the capacity has been reached will cause a panic.

Like String, the contents of an ArrayString must be valid UTF-8 at all times.

ArrayString is intended to replicate the API of String as much as possible. Like ArrayVec, some methods cannot be implemented, like from_raw_parts or reserve

Examples

Creating ArrayStrings with TryFrom:

use std::convert::TryFrom;
// explicitly specifying the backing array type with a turbofish
// note that `try_from` fails if the backing array is not large enough
// to contain the string contents
let s1 = ArrayString::<[u8; 13]>::try_from("Hello, world!").unwrap();

assert_eq!(s1, "Hello, world!");

// annotate the variable type to specify the backing array
let s2: ArrayString<[u8; 13]> = ArrayString::try_from("Hello, world!").unwrap();

assert_eq!(s1, s2);

// `collect` (which uses `FromIterator`) will panic if the backing array
// is not large enough
let s3: ArrayString<[u8; 12]> =
    vec!["foo", "bar", "baz"].into_iter().collect();

assert_eq!(s3, "foobarbaz");

Creating ArrayStrings with the from convenience method:

// this panics on capacity overflow
let s = ArrayString::<[u8; 6]>::from("foobar");

Implementations

impl<A: ByteArray> ArrayString<A>

pub fn new() -> ArrayString<A>

Creates a new empty ArrayString.

This creates a new ArrayVec with a backing array of zeroes.

Examples

// create an `ArrayString` with 16 bytes of capacity
let s = ArrayString::<[u8; 16]>::new();

pub fn from<S>(s: S) -> Self where
    S: Debug,
    Self: TryFrom<S, Error = CapacityOverflowError<S>>, 

Creates a new ArrayString from another string type.

This can be used to create an ArrayString from any type with an applicable TryFrom implementation:

• &str
• &mut str
• char
• &char
• String
• &String
• Cow<str>

Because it relies on TryFrom, this method may panic (which is why it is not a From implementation).

Panics

Panics if the input string is larger than the backing array.

Examples

let s = ArrayString::<[u8; 13]>::from("Hello, world!");

assert_eq!(s, "Hello, world!");

This method panics when the string is too large:

// the following line will panic!
let s = ArrayString::<[u8; 10]>::from("This is quite a long string");

pub fn from_utf8(vec: ArrayVec<A>) -> Result<ArrayString<A>, FromUtf8Error<A>>

Converts a vector of bytes to an ArrayString.

ArrayString is backed by ArrayVec, so after ensuring valid UTF-8, this function simply constructs an ArrayString containing the provided ArrayVec.

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.

Examples

use tinyvec::{array_vec, ArrayVec};
// some bytes, in a vector
let ferris: ArrayVec<[u8; 7]> = array_vec![240, 159, 166, 128, 226, 153, 165];

// We know these bytes are valid UTF-8, so we'll use `unwrap()`.
let ferris = ArrayString::from_utf8(ferris).unwrap();

assert_eq!("🦀♥", ferris);

Incorrect bytes:

use tinyvec::{array_vec, ArrayVec};

// some invalid bytes, in a vector
let ferris: ArrayVec<[u8; 7]> = array_vec![0, 159, 166, 128, 226, 153, 165];

assert!(ArrayString::from_utf8(ferris).is_err());

See the docs for FromUtf8Error for more details on what you can do with this error.

pub unsafe fn from_utf8_unchecked(vec: ArrayVec<A>) -> ArrayString<A>

Converts a vector of bytes to an ArrayString 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 ArrayString, as the rest of this library and the standard library assumes that strs are valid UTF-8.

Examples

use tinyvec::{array_vec, ArrayVec};
// some bytes, in a vector
let ferris: ArrayVec<[u8; 7]> = array_vec![240, 159, 166, 128, 226, 153, 165];

let ferris = unsafe {
	// we know these bytes are valid UTF-8, so this is sound.
	ArrayString::from_utf8_unchecked(ferris)
};

assert_eq!("🦀♥", ferris);

pub fn into_bytes(self) -> ArrayVec<A>

Returns an ArrayString's backing ArrayVec.

Examples

let s = ArrayString::<[u8; 5]>::from("hello");
let bytes = s.into_bytes();

assert_eq!(&[104, 101, 108, 108, 111][..], &bytes[..]);

pub fn as_str(&self) -> &str

Extracts a string slice containing the entire ArrayString.

Examples

let s = ArrayString::<[u8; 3]>::from("foo");

assert_eq!("foo", s.as_str());

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

Extracts a mutable string slice containing the entire ArrayString.

Examples

let mut s = ArrayString::<[u8; 6]>::from("foobar");
let s_mut_str = s.as_mut_str();

s_mut_str.make_ascii_uppercase();

assert_eq!("FOOBAR", s_mut_str);

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

Returns a byte slice of this ArrayString's contents.

The inverse of this method is from_utf8.

Examples

let s = ArrayString::<[u8; 5]>::from("hello");

assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());

pub unsafe fn as_mut_vec(&mut self) -> &mut ArrayVec<A>

Returns a mutable reference to the contents of this ArrayString.

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 ArrayString, as the rest of the standard library assumes that ArrayStrings are valid UTF-8.

Examples

let mut s = ArrayString::<[u8; 5]>::from("hello");

unsafe {
    let vec = s.as_mut_vec();
    assert_eq!(&[104, 101, 108, 108, 111][..], &vec[..]);

    vec.reverse();
}
assert_eq!(s, "olleh");

pub fn capacity(&self) -> usize

Returns this ArrayString's capacity, in bytes.

This always returns a constant, the size of the backing array.

Examples

let s = ArrayString::<[u8; 16]>::new();

assert!(s.capacity() == 16);

pub fn len(&self) -> usize

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

Examples

let plain_f = ArrayString::<[u8; 3]>::from("foo");
assert_eq!(plain_f.len(), 3);

let fancy_f = ArrayString::<[u8; 4]>::from("ƒoo");
assert_eq!(fancy_f.len(), 4);
assert_eq!(fancy_f.chars().count(), 3);

let s = ArrayString::<[u8; 16]>::from("hello");
assert_eq!(s.len(), 5);

pub fn is_empty(&self) -> bool

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

Examples

let mut s = ArrayString::<[u8; 5]>::new();
assert!(s.is_empty());

s.push('a');
assert!(!s.is_empty());

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

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

Panics

Panics if the new length would be longer than the capacity of the backing array.

Examples

let mut s = ArrayString::<[u8; 6]>::from("foo");

s.push_str("bar");

assert_eq!("foobar", s);

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

Appends the given char to the end of this String.

Panics

Panics if the new length would be longer than the capacity of the backing array.

Examples

let mut s = ArrayString::<[u8; 6]>::from("abc");

s.push('1');
s.push('2');
s.push('3');

assert_eq!("abc123", s);

pub fn truncate(&mut self, new_len: usize)

Shortens this ArrayString 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 maximum capacity of the string

Panics

Panics if new_len does not lie on a char boundary.

Examples

let mut s = ArrayString::<[u8; 5]>::from("hello");

s.truncate(2);

assert_eq!("he", s);

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.

Examples

let mut s = ArrayString::<[u8; 3]>::from("foo");

assert_eq!(s.pop(), Some('o'));
assert_eq!(s.pop(), Some('o'));
assert_eq!(s.pop(), Some('f'));

assert_eq!(s.pop(), None);

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

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

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 ArrayString's length, or if it does not lie on a char boundary.

Examples

let mut s = ArrayString::<[u8; 3]>::from("foo");

assert_eq!(s.remove(0), 'f');
assert_eq!(s.remove(1), 'o');
assert_eq!(s.remove(0), 'o');

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.

Examples

let mut s = ArrayString::<[u8; 9]>::from("f_o_ob_ar");

s.retain(|c| c != '_');

assert_eq!(s, "foobar");

The exact order may be useful for tracking external state, like an index.

let mut s = ArrayString::<[u8; 5]>::from("abcde");
let keep = [false, true, true, false, true];
let mut i = 0;
s.retain(|_| (keep[i], i += 1).0);
assert_eq!(s, "bce");

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

Inserts a character into this ArrayString at a byte position.

This is an O(n) operation as it requires copying every element in the buffer.

Panics

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

Panics if the new length would be longer than the capacity of the backing array.

Examples

let mut s = ArrayString::<[u8; 3]>::new();

s.insert(0, 'f');
s.insert(1, 'o');
s.insert(2, 'o');

assert_eq!("foo", s);

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

Inserts a string slice into this ArrayString at a byte 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, or if it does not lie on a char boundary.

Panics if the new length would be longer than the capacity of the backing array.

Examples

let mut s = ArrayString::<[u8; 6]>::from("bar");

s.insert_str(0, "foo");

assert_eq!("foobar", s);

pub fn clear(&mut self)

Truncates this ArrayString, removing all contents.

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

Examples

let mut s = ArrayString::<[u8; 3]>::from("foo");

s.clear();

assert!(s.is_empty());
assert_eq!(0, s.len());
assert_eq!(3, s.capacity());

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

Creates a draining iterator that removes the specified range in the ArrayString 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.

Examples

let mut s = ArrayString::<[u8; 23]>::from("α is alpha, β is beta");
let beta_offset = s.find('β').unwrap_or(s.len());

// Remove the range up until the β from the string
let t: ArrayString<[u8; 23]> = s.drain(..beta_offset).collect();
assert_eq!(t, "α is alpha, ");
assert_eq!(s, "β is beta");

// A full range clears the string
s.drain(..);
assert_eq!(s, "");

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.

Examples

Basic usage:

let mut s = ArrayString::<[u8; 32]>::from("α is alpha, β is beta");
let beta_offset = s.find('β').unwrap_or(s.len());

// Replace the range up until the β from the string
s.replace_range(..beta_offset, "Α is capital alpha; ");
assert_eq!(s, "Α is capital alpha; β is beta");

#[must_use = "use `.truncate()` if you don't need the other half"]pub fn split_off(&mut self, at: usize) -> ArrayString<A>

Splits the string into two at the given index.

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

Both self and the returned ArrayString will have the same capacity as self did before this was called.

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.

Examples

let mut hello = ArrayString::<[u8; 13]>::from("Hello, World!");
let world = hello.split_off(7);
assert_eq!(hello, "Hello, ");
assert_eq!(world, "World!");

impl ArrayString<[u8; 4]>

pub fn from_char_infallible(c: char) -> Self

Creates an ArrayString from a char infallibly.

Without const generics, this method is limited to ArrayStrings with backing arrays of size 4 only.

Examples

let s = ArrayString::<[u8; 4]>::from_char_infallible('c');
assert_eq!(s, "c");

Trait Implementations

impl<A: ByteArray> Add<&'_ str> for ArrayString<A>

Implements the + operator for concatenating two strings.

Panics

Panics if the new length would be longer than the capacity of the backing array.

Examples

use std::convert::TryFrom;
let a = ArrayString::<[u8; 13]>::from("Hello, ");
let b = "World!";
let c = a + b;
assert_eq!(c, "Hello, World!");

type Output = ArrayString<A>

The resulting type after applying the + operator.

pub fn add(self, other: &str) -> Self

Performs the + operation.

impl<A: ByteArray> AddAssign<&'_ str> for ArrayString<A>

Implements the += operator for appending to a String.

This has the same behavior as the push_str method.

Panics

Panics if the new length would be longer than the capacity of the backing array.

Examples

use std::convert::TryFrom;
let mut a = ArrayString::<[u8; 13]>::from("Hello, ");
let b = "World!";
a += b;
assert_eq!(a, "Hello, World!");

pub fn add_assign(&mut self, other: &str)

Performs the += operation.

impl<A: ByteArray> AsMut<str> for ArrayString<A>

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

Performs the conversion.

impl<A: ByteArray> AsRef<[u8]> for ArrayString<A>

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

Performs the conversion.

impl<A: ByteArray> AsRef<str> for ArrayString<A>

pub fn as_ref(&self) -> &str

Performs the conversion.

impl<A: ByteArray + Clone> Clone for ArrayString<A>

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Copy + ByteArray> Copy for ArrayString<A>

impl<A: ByteArray> Debug for ArrayString<A>

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

Formats the value using the given formatter.

impl<A: ByteArray> Default for ArrayString<A>

pub fn default() -> Self

Returns the "default value" for a type.

impl<A: ByteArray> Deref for ArrayString<A>

type Target = str

The resulting type after dereferencing.

pub fn deref(&self) -> &str

Dereferences the value.

impl<A: ByteArray> DerefMut for ArrayString<A>

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

Mutably dereferences the value.

impl<A: ByteArray> Display for ArrayString<A>

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

Formats the value using the given formatter.

impl<A: Eq + ByteArray> Eq for ArrayString<A>

impl<'a, A: ByteArray> Extend<&'a char> for ArrayString<A>

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

Panics

Panics if the new length would be longer than the capacity of the backing array.

pub fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

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

impl<'a, A: ByteArray> Extend<&'a str> for ArrayString<A>

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

Panics

Panics if the new length would be longer than the capacity of the backing array.

pub fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

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

impl<A: ByteArray, A2: ByteArray> Extend<ArrayString<A2>> for ArrayString<A>

pub fn extend<I: IntoIterator<Item = ArrayString<A2>>>(&mut self, iter: I)

Panics

Panics if the new length would be longer than the capacity of the backing array.

pub fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

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

impl<'a, A: ByteArray> Extend<Cow<'a, str>> for ArrayString<A>

This is supported with target feature alloc only.

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

Panics

Panics if the new length would be longer than the capacity of the backing array.

pub fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

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

impl<A: ByteArray> Extend<String> for ArrayString<A>

This is supported with target feature alloc only.

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

Panics

Panics if the new length would be longer than the capacity of the backing array.

pub fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

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

impl<A: ByteArray> Extend<char> for ArrayString<A>

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

Panics

Panics if the new length would be longer than the capacity of the backing array.

pub fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

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

impl<'a, A: ByteArray> FromIterator<&'a char> for ArrayString<A>

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

Panics

Panics if the length would be longer than the capacity of the backing array.

impl<'a, A: ByteArray> FromIterator<&'a str> for ArrayString<A>

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

Panics

Panics if the length would be longer than the capacity of the backing array.

impl<A: ByteArray, A2: ByteArray> FromIterator<ArrayString<A2>> for ArrayString<A>

pub fn from_iter<I: IntoIterator<Item = ArrayString<A2>>>(iter: I) -> Self

Panics

Panics if the new length would be longer than the capacity of the backing array.

impl<'a, A: ByteArray> FromIterator<Cow<'a, str>> for ArrayString<A>

This is supported with target feature alloc only.

pub fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> Self

Panics

Panics if the length would be longer than the capacity of the backing array.

impl<'a, A: ByteArray> FromIterator<String> for ArrayString<A>

This is supported with target feature alloc only.

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

Panics

Panics if the length would be longer than the capacity of the backing array.

impl<'a, A: ByteArray> FromIterator<char> for ArrayString<A>

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

Panics

Panics if the length would be longer than the capacity of the backing array.

impl<A: ByteArray> FromStr for ArrayString<A>

type Err = CapacityOverflowError<()>

Because of lifetime restrictions, the error type can't return the provided string like the TryFrom implementations do.

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

Parses a string s to return a value of this type.

impl<A: ByteArray> Hash for ArrayString<A>

pub fn hash<H: Hasher>(&self, hasher: &mut H)

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<A: ByteArray> Index<Range<usize>> for ArrayString<A>

type Output = str

The returned type after indexing.

pub fn index(&self, index: Range<usize>) -> &str

Performs the indexing (container[index]) operation.

impl<A: ByteArray> Index<RangeFrom<usize>> for ArrayString<A>

type Output = str

The returned type after indexing.

pub fn index(&self, index: RangeFrom<usize>) -> &str

Performs the indexing (container[index]) operation.

impl<A: ByteArray> Index<RangeFull> for ArrayString<A>

type Output = str

The returned type after indexing.

pub fn index(&self, _index: RangeFull) -> &str

Performs the indexing (container[index]) operation.

impl<A: ByteArray> Index<RangeInclusive<usize>> for ArrayString<A>

type Output = str

The returned type after indexing.

pub fn index(&self, index: RangeInclusive<usize>) -> &str

Performs the indexing (container[index]) operation.

impl<A: ByteArray> Index<RangeTo<usize>> for ArrayString<A>

type Output = str

The returned type after indexing.

pub fn index(&self, index: RangeTo<usize>) -> &str

Performs the indexing (container[index]) operation.

impl<A: ByteArray> Index<RangeToInclusive<usize>> for ArrayString<A>

type Output = str

The returned type after indexing.

pub fn index(&self, index: RangeToInclusive<usize>) -> &str

Performs the indexing (container[index]) operation.

impl<A: ByteArray> IndexMut<Range<usize>> for ArrayString<A>

pub fn index_mut(&mut self, index: Range<usize>) -> &mut str

Performs the mutable indexing (container[index]) operation.

impl<A: ByteArray> IndexMut<RangeFrom<usize>> for ArrayString<A>

pub fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut str

Performs the mutable indexing (container[index]) operation.

impl<A: ByteArray> IndexMut<RangeFull> for ArrayString<A>

pub fn index_mut(&mut self, _index: RangeFull) -> &mut str

Performs the mutable indexing (container[index]) operation.

impl<A: ByteArray> IndexMut<RangeInclusive<usize>> for ArrayString<A>

pub fn index_mut(&mut self, index: RangeInclusive<usize>) -> &mut str

Performs the mutable indexing (container[index]) operation.

impl<A: ByteArray> IndexMut<RangeTo<usize>> for ArrayString<A>

pub fn index_mut(&mut self, index: RangeTo<usize>) -> &mut str

Performs the mutable indexing (container[index]) operation.

impl<A: ByteArray> IndexMut<RangeToInclusive<usize>> for ArrayString<A>

pub fn index_mut(&mut self, index: RangeToInclusive<usize>) -> &mut str

Performs the mutable indexing (container[index]) operation.

impl<A: Ord + ByteArray> Ord for ArrayString<A>

pub fn cmp(&self, other: &ArrayString<A>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<'a, 'b, A: ByteArray> PartialEq<&'a str> for ArrayString<A>

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

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

pub fn ne(&self, other: &&'a str) -> bool

This method tests for !=.

impl<'a, 'b, A: ByteArray> PartialEq<ArrayString<A>> for str

pub fn eq(&self, other: &ArrayString<A>) -> bool

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

pub fn ne(&self, other: &ArrayString<A>) -> bool

This method tests for !=.

impl<'a, 'b, A: ByteArray> PartialEq<ArrayString<A>> for &'a str

pub fn eq(&self, other: &ArrayString<A>) -> bool

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

pub fn ne(&self, other: &ArrayString<A>) -> bool

This method tests for !=.

impl<'a, 'b, A: ByteArray> PartialEq<ArrayString<A>> for Cow<'a, str>

This is supported with target feature alloc only.

pub fn eq(&self, other: &ArrayString<A>) -> bool

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

pub fn ne(&self, other: &ArrayString<A>) -> bool

This method tests for !=.

impl<'a, 'b, A: ByteArray> PartialEq<ArrayString<A>> for String

This is supported with target feature alloc only.

pub fn eq(&self, other: &ArrayString<A>) -> bool

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

pub fn ne(&self, other: &ArrayString<A>) -> bool

This method tests for !=.

impl<A1, A2> PartialEq<ArrayString<A1>> for ArrayString<A2> where
    A1: ByteArray,
    A2: ByteArray, 

pub fn eq(&self, other: &ArrayString<A1>) -> bool

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

pub fn ne(&self, other: &ArrayString<A1>) -> bool

This method tests for !=.

impl<'a, 'b, A: ByteArray> PartialEq<Cow<'a, str>> for ArrayString<A>

This is supported with target feature alloc only.

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

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

pub fn ne(&self, other: &Cow<'a, str>) -> bool

This method tests for !=.

impl<'a, 'b, A: ByteArray> PartialEq<String> for ArrayString<A>

This is supported with target feature alloc only.

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

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

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

This method tests for !=.

impl<'a, 'b, A: ByteArray> PartialEq<str> for ArrayString<A>

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

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

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

This method tests for !=.

impl<A: PartialOrd + ByteArray> PartialOrd<ArrayString<A>> for ArrayString<A>

pub fn partial_cmp(&self, other: &ArrayString<A>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

pub fn lt(&self, other: &ArrayString<A>) -> bool

This method tests less than (for self and other) and is used by the < operator.

pub fn le(&self, other: &ArrayString<A>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

pub fn gt(&self, other: &ArrayString<A>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

pub fn ge(&self, other: &ArrayString<A>) -> bool

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

impl<A: ByteArray> StructuralEq for ArrayString<A>

impl<'a, A: ByteArray> TryFrom<&'a String> for ArrayString<A>

This is supported with target feature alloc only.

type Error = CapacityOverflowError<&'a String>

The type returned in the event of a conversion error.

pub fn try_from(s: &'a String) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, A: ByteArray> TryFrom<&'a mut str> for ArrayString<A>

type Error = CapacityOverflowError<&'a mut str>

The type returned in the event of a conversion error.

pub fn try_from(s: &'a mut str) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, A: ByteArray> TryFrom<&'a str> for ArrayString<A>

type Error = CapacityOverflowError<&'a str>

The type returned in the event of a conversion error.

pub fn try_from(s: &'a str) -> Result<Self, Self::Error>

Performs the conversion.

impl<'c, A: ByteArray> TryFrom<&'c char> for ArrayString<A>

type Error = CapacityOverflowError<&'c char>

The type returned in the event of a conversion error.

pub fn try_from(c: &'c char) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, A: ByteArray> TryFrom<Cow<'a, str>> for ArrayString<A>

This is supported with target feature alloc only.

type Error = CapacityOverflowError<Cow<'a, str>>

The type returned in the event of a conversion error.

pub fn try_from(s: Cow<'a, str>) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: ByteArray> TryFrom<String> for ArrayString<A>

This is supported with target feature alloc only.

type Error = CapacityOverflowError<String>

The type returned in the event of a conversion error.

pub fn try_from(s: String) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: ByteArray> TryFrom<char> for ArrayString<A>

type Error = CapacityOverflowError<char>

The type returned in the event of a conversion error.

pub fn try_from(c: char) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: ByteArray> Write for ArrayString<A>

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

Writes a string slice into this writer, returning whether the write succeeded.

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

Writes a char into this writer, returning whether the write succeeded.

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

Glue for usage of the write! macro with implementors of this trait.