[][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]

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);

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);

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();

Return the capacity of the ArrayString.

use arrayvec::ArrayString;

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

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());

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");

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');

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");

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");

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);

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");

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');

Make the string empty.

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.

Return a string slice of the whole ArrayString.

Trait Implementations

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

Compares and returns the maximum of two values. Read more

Compares and returns the minimum of two values. Read more

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

This method tests for !=.

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

This method tests for !=.

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

This method tests for !=.

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

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

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

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

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

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

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

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

Return an empty ArrayString

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

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

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

Write appends written data to the end of the string.

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

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

The resulting type after dereferencing.

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

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

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

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

impl<A: Array<Item = u8>> Serialize for ArrayString<A>
[src]

Requires crate feature "serde-1"

impl<'de, A: Array<Item = u8>> Deserialize<'de> for ArrayString<A>
[src]

Requires crate feature "serde-1"

Auto Trait Implementations

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 for T
[src]

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

impl<T> ToOwned for T where
    T: Clone
[src]

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T, U> TryFrom for T where
    T: From<U>, 
[src]

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

The type returned in the event of a conversion error.

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

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

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

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

The type returned in the event of a conversion error.

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

impl<T> DeserializeOwned for T where
    T: Deserialize<'de>, 
[src]