# [−][src]Struct arrayvec::ArrayString

    pub struct ArrayString<A: Array<Item = u8>> { /* fields omitted */ }

A string with a fixed capacity.

The `ArrayString` is a string backed by a fixed size array. It keeps track of its length.

The string is a contiguous value that you can store directly on the stack if needed.

## Methods

### `impl<A: Array<Item = u8>> ArrayString<A>`[src]

#### `pub fn new() -> ArrayString<A>`[src]

Create a new empty `ArrayString`.

Capacity is inferred from the type parameter.

    use arrayvec::ArrayString;

    let mut string = ArrayString::<[_; 16]>::new();
    string.push_str("foo");
    assert_eq!(&string[..], "foo");
    assert_eq!(string.capacity(), 16);

#### `pub fn from(s: &str) -> Result<Self, CapacityError<&str>>`[src]

Create a new `ArrayString` from a `str`.

Capacity is inferred from the type parameter.

Errors if the backing array is not large enough to fit the string.

    use arrayvec::ArrayString;

    let mut string = ArrayString::<[_; 3]>::from("foo").unwrap();
    assert_eq!(&string[..], "foo");
    assert_eq!(string.len(), 3);
    assert_eq!(string.capacity(), 3);

#### `pub fn from_byte_string(b: &A) -> Result<Self, Utf8Error>`[src]

Create a new `ArrayString` from a byte string literal.

Errors if the byte string literal is not valid UTF-8.

    use arrayvec::ArrayString;

    let string = ArrayString::from_byte_string(b"hello world").unwrap();

#### `pub fn capacity(&self) -> usize`[src]

Return the capacity of the `ArrayString`.

    use arrayvec::ArrayString;

    let string = ArrayString::<[_; 3]>::new();
    assert_eq!(string.capacity(), 3);

#### `pub fn is_full(&self) -> bool`[src]

Return if the `ArrayString` is completely filled.

    use arrayvec::ArrayString;

    let mut string = ArrayString::<[_; 1]>::new();
    assert!(!string.is_full());
    string.push_str("A");
    assert!(string.is_full());

#### `pub fn push(&mut self, c: char)`[src]

Adds the given char to the end of the string.

Panics if the backing array is not large enough to fit the additional char.

    use arrayvec::ArrayString;

    let mut string = ArrayString::<[_; 2]>::new();

    string.push('a');
    string.push('b');

    assert_eq!(&string[..], "ab");

#### `pub fn try_push(&mut self, c: char) -> Result<(), CapacityError<char>>`[src]

Adds the given char to the end of the string.

Returns `Ok` if the push succeeds.

Errors if the backing array is not large enough to fit the additional char.

    use arrayvec::ArrayString;

    let mut string = ArrayString::<[_; 2]>::new();

    string.try_push('a').unwrap();
    string.try_push('b').unwrap();
    let overflow = string.try_push('c');

    assert_eq!(&string[..], "ab");
    assert_eq!(overflow.unwrap_err().element(), 'c');

#### `pub fn push_str(&mut self, s: &str)`[src]

Adds the given string slice to the end of the string.

Panics if the backing array is not large enough to fit the string.

    use arrayvec::ArrayString;

    let mut string = ArrayString::<[_; 2]>::new();

    string.push_str("a");
    string.push_str("d");

    assert_eq!(&string[..], "ad");

#### `pub fn try_push_str<'a>(
&mut self,
s: &'a str
) -> Result<(), CapacityError<&'a str>>`[src]

Adds the given string slice to the end of the string.

Returns `Ok` if the push succeeds.

Errors if the backing array is not large enough to fit the string.

    use arrayvec::ArrayString;

    let mut string = ArrayString::<[_; 2]>::new();

    string.try_push_str("a").unwrap();
    let overflow1 = string.try_push_str("bc");
    string.try_push_str("d").unwrap();
    let overflow2 = string.try_push_str("ef");

    assert_eq!(&string[..], "ad");
    assert_eq!(overflow1.unwrap_err().element(), "bc");
    assert_eq!(overflow2.unwrap_err().element(), "ef");

#### `pub fn pop(&mut self) -> Option<char>`[src]

Removes the last character from the string and returns it.

Returns `None` if this `ArrayString` is empty.

    use arrayvec::ArrayString;

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

    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 truncate(&mut self, new_len: usize)`[src]

Shortens this `ArrayString` to the specified length.

If `new_len` is greater than the string’s current length, this has no effect.

Panics if `new_len` does not lie on a `char` boundary.

    use arrayvec::ArrayString;

    let mut string = ArrayString::<[_; 6]>::from("foobar").unwrap();
    string.truncate(3);
    assert_eq!(&string[..], "foo");
    string.truncate(4);
    assert_eq!(&string[..], "foo");

#### `pub fn remove(&mut self, idx: usize) -> char`[src]

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

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

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

    use arrayvec::ArrayString;

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

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

#### `pub fn clear(&mut self)`[src]

Make the string empty.

#### `pub unsafe fn set_len(&mut self, length: usize)`[src]

Set the strings’s length.

This function is `unsafe` because it changes the notion of the number of “valid” bytes in the string. Use with care.

This method uses debug assertions to check the validity of `length` and may use other debug assertions.

#### `pub fn as_str(&self) -> &str`[src]

Return a string slice of the whole `ArrayString`.

## Trait Implementations

### `impl<A: Array<Item = u8>> DerefMut for ArrayString<A>`[src]

#### `fn deref_mut(&mut self) -> &mut str`[src]

Mutably dereferences the value.

### `impl<A: Array<Item = u8>> PartialEq<ArrayString<A>> for ArrayString<A>`[src]

#### `fn eq(&self, rhs: &Self) -> bool`[src]

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

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool` 1.0.0[src]

This method tests for `!=`.

### `impl<A: Array<Item = u8>> PartialEq<str> for ArrayString<A>`[src]

#### `fn eq(&self, rhs: &str) -> bool`[src]

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

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool` 1.0.0[src]

This method tests for `!=`.

### `impl<A: Array<Item = u8>> PartialEq<ArrayString<A>> for str`[src]

#### `fn eq(&self, rhs: &ArrayString<A>) -> bool`[src]

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

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool` 1.0.0[src]

This method tests for `!=`.

### `impl<A: Array<Item = u8>> Eq for ArrayString<A>`[src]

### `impl<A: Array<Item = u8>> Ord for ArrayString<A>`[src]

#### `fn cmp(&self, rhs: &Self) -> Ordering`[src]

This method returns an `Ordering` between `self` and `other`. Read more

#### `fn max(self, other: Self) -> Self` 1.21.0[src]

Compares and returns the maximum of two values. Read more

#### `fn min(self, other: Self) -> Self` 1.21.0[src]

Compares and returns the minimum of two values. Read more

#### `fn clamp(self, min: Self, max: Self) -> Self`[src]

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

Restrict a value to a certain interval. Read more

### `impl<A: Array<Item = u8>> PartialOrd<ArrayString<A>> for ArrayString<A>`[src]

#### `fn partial_cmp(&self, rhs: &Self) -> Option<Ordering>`[src]

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

#### `fn lt(&self, rhs: &Self) -> bool`[src]

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

#### `fn le(&self, rhs: &Self) -> bool`[src]

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

#### `fn gt(&self, rhs: &Self) -> bool`[src]

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

#### `fn ge(&self, rhs: &Self) -> bool`[src]

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

### `impl<A: Array<Item = u8>> PartialOrd<str> for ArrayString<A>`[src]

#### `fn partial_cmp(&self, rhs: &str) -> Option<Ordering>`[src]

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

#### `fn lt(&self, rhs: &str) -> bool`[src]

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

#### `fn le(&self, rhs: &str) -> bool`[src]

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

#### `fn gt(&self, rhs: &str) -> bool`[src]

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

#### `fn ge(&self, rhs: &str) -> bool`[src]

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

### `impl<A: Array<Item = u8>> PartialOrd<ArrayString<A>> for str`[src]

#### `fn partial_cmp(&self, rhs: &ArrayString<A>) -> Option<Ordering>`[src]

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

#### `fn lt(&self, rhs: &ArrayString<A>) -> bool`[src]

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

#### `fn le(&self, rhs: &ArrayString<A>) -> bool`[src]

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

#### `fn gt(&self, rhs: &ArrayString<A>) -> bool`[src]

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

#### `fn ge(&self, rhs: &ArrayString<A>) -> bool`[src]

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

### `impl<A: Array<Item = u8>> Hash for ArrayString<A>`[src]

#### `fn hash<H: Hasher>(&self, h: &mut H)`[src]

Feeds this value into the given [`Hasher`]. Read more

#### `fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,` 1.3.0[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

### `impl<A: Array<Item = u8>> Deref for ArrayString<A>`[src]

#### `type Target = str`

The resulting type after dereferencing.

#### `fn deref(&self) -> &str`[src]

Dereferences the value.

### `impl<A: Array<Item = u8>> Debug for ArrayString<A>`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter. Read more

### `impl<A: Array<Item = u8>> Display for ArrayString<A>`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter. Read more

### `impl<A: Array<Item = u8>> Write for ArrayString<A>`[src]

`Write` appends written data to the end of the string.

#### `fn write_char(&mut self, c: char) -> Result`[src]

Writes a [`char`] into this writer, returning whether the write succeeded. Read more

#### `fn write_str(&mut self, s: &str) -> Result`[src]

Writes a slice of bytes into this writer, returning whether the write succeeded. Read more

#### `fn write_fmt(&mut self, args: Arguments) -> Result<(), Error>`1.0.0[src]

Glue for usage of the [`write!`] macro with implementors of this trait. Read more

### `impl<A: Array<Item = u8>> AsRef<str> for ArrayString<A>`[src]

#### `fn as_ref(&self) -> &str`[src]

Performs the conversion.

### `impl<A: Copy + Array<Item = u8>> Copy for ArrayString<A> where
A::Index: Copy,` [src]

### `impl<A: Array<Item = u8> + Copy> Clone for ArrayString<A>`[src]

#### `fn clone(&self) -> ArrayString<A>`[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, rhs: &Self)`[src]

Performs copy-assignment from `source`. Read more

### `impl<A: Array<Item = u8>> Default for ArrayString<A>`[src]

#### `fn default() -> ArrayString<A>`[src]

Return an empty `ArrayString`

### `impl<A: Array<Item = u8>> Borrow<str> for ArrayString<A>`[src]

#### `fn borrow(&self) -> &str`[src]

Immutably borrows from an owned value. Read more

## Auto Trait Implementations

### `impl<A> Unpin for ArrayString<A> where
A: Unpin,
<A as Array>::Index: Unpin,`

### `impl<A> Send for ArrayString<A> where
A: Send,
<A as Array>::Index: Send,`

### `impl<A> Sync for ArrayString<A> where
A: Sync,
<A as Array>::Index: Sync,`

## Blanket Implementations

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)