Struct arraystring::ArrayString

pub struct ArrayString<SIZE: Capacity> { /* fields omitted */ }

String based on a generic array (size defined at compile time through typenum)

Can't outgrow capacity (defined at compile time), always occupies capacity + 1 bytes of memory

Doesn't allocate memory on the heap and never panics (all panic branches are stripped at compile time)

Methods

impl<SIZE: Capacity> ArrayString<SIZE>

pub fn new() -> Self

Creates new empty string.

let string = SmallString::new();
assert!(string.is_empty());

pub fn try_from_str<S>(s: S) -> Result<Self, OutOfBounds> where     S: AsRef<str>,

Creates new ArrayString from string slice if length is lower or equal to capacity, otherwise returns an error.

let string = SmallString::try_from_str("My String")?;
assert_eq!(string.as_str(), "My String");

assert_eq!(SmallString::try_from_str("")?.as_str(), "");

let out_of_bounds = "0".repeat(SmallString::capacity() as usize + 1);
assert!(SmallString::try_from_str(out_of_bounds).is_err());

pub fn from_str_truncate<S>(string: S) -> Self where     S: AsRef<str>,

Creates new ArrayString from string slice truncating size if bigger than capacity.

let string = SmallString::from_str_truncate("My String");
println!("{}", string);

let truncate = "0".repeat(SmallString::capacity() as usize + 1);
let truncated = "0".repeat(SmallString::capacity().into());
let string = SmallString::from_str_truncate(&truncate);
assert_eq!(string.as_str(), truncated);

pub unsafe fn from_str_unchecked<S>(string: S) -> Self where     S: AsRef<str>,

Creates new ArrayString from string slice assuming length is appropriate.

Safety

It's UB if string.len() > capacity.

let filled = "0".repeat(SmallString::capacity().into());
let string = unsafe {
    SmallString::from_str_unchecked(&filled)
};
assert_eq!(string.as_str(), filled.as_str());

// Undefined behavior, don't do it
// let out_of_bounds = "0".repeat(SmallString::capacity().into() + 1);
// let ub = unsafe { SmallString::from_str_unchecked(out_of_bounds) };

pub fn try_from_iterator<U, I>(iter: I) -> Result<Self, OutOfBounds> where     U: AsRef<str>,     I: IntoIterator<Item = U>,

Creates new ArrayString from string slice iterator if total length is lower or equal to capacity, otherwise returns an error.

let string = MaxString::try_from_iterator(&["My String", " My Other String"][..])?;
assert_eq!(string.as_str(), "My String My Other String");

let out_of_bounds = (0..100).map(|_| "000");
assert!(SmallString::try_from_iterator(out_of_bounds).is_err());

pub fn from_iterator<U, I>(iter: I) -> Self where     U: AsRef<str>,     I: IntoIterator<Item = U>,

Creates new ArrayString from string slice iterator truncating size if bigger than capacity.

let string = MaxString::from_iterator(&["My String", " Other String"][..]);
assert_eq!(string.as_str(), "My String Other String");

let out_of_bounds = (0..400).map(|_| "000");
let truncated = "0".repeat(SmallString::capacity().into());

let truncate = SmallString::from_iterator(out_of_bounds);
assert_eq!(truncate.as_str(), truncated.as_str());

pub unsafe fn from_iterator_unchecked<U, I>(iter: I) -> Self where     U: AsRef<str>,     I: IntoIterator<Item = U>,

Creates new ArrayString from string slice iterator assuming length is appropriate.

Safety

It's UB if iter.map(|c| c.len()).sum() > capacity.

let string = unsafe {
    MaxString::from_iterator_unchecked(&["My String", " My Other String"][..])
};
assert_eq!(string.as_str(), "My String My Other String");

// Undefined behavior, don't do it
// let out_of_bounds = (0..400).map(|_| "000");
// let undefined_behavior = unsafe {
//     SmallString::from_iterator_unchecked(out_of_bounds)
// };

pub fn try_from_chars<I>(iter: I) -> Result<Self, OutOfBounds> where     I: IntoIterator<Item = char>,

Creates new ArrayString from char iterator if total length is lower or equal to capacity, otherwise returns an error.

let string = SmallString::try_from_chars("My String".chars())?;
assert_eq!(string.as_str(), "My String");

let out_of_bounds = "0".repeat(SmallString::capacity() as usize + 1);
assert!(SmallString::try_from_chars(out_of_bounds.chars()).is_err());

pub fn from_chars<I>(iter: I) -> Self where     I: IntoIterator<Item = char>,

Creates new ArrayString from char iterator truncating size if bigger than capacity.

let string = SmallString::from_chars("My String".chars());
assert_eq!(string.as_str(), "My String");

let out_of_bounds = "0".repeat(SmallString::capacity() as usize + 1);
let truncated = "0".repeat(SmallString::capacity().into());

let truncate = SmallString::from_chars(out_of_bounds.chars());
assert_eq!(truncate.as_str(), truncated.as_str());

pub unsafe fn from_chars_unchecked<I>(iter: I) -> Self where     I: IntoIterator<Item = char>,

Creates new ArrayString from char iterator assuming length is appropriate.

Safety

It's UB if iter.map(|c| c.len_utf8()).sum() > capacity.

let string = unsafe { SmallString::from_chars_unchecked("My String".chars()) };
assert_eq!(string.as_str(), "My String");

// Undefined behavior, don't do it
// let out_of_bounds = "000".repeat(400);
// let undefined_behavior = unsafe { SmallString::from_chars_unchecked(out_of_bounds.chars()) };

pub fn try_from_utf8<B>(slice: B) -> Result<Self, Error> where     B: AsRef<[u8]>,

Creates new ArrayString from byte slice, returning Utf8 on invalid utf-8 data or OutOfBounds if bigger than capacity

let string = SmallString::try_from_utf8("My String")?;
assert_eq!(string.as_str(), "My String");

let invalid_utf8 = [0, 159, 146, 150];
assert_eq!(SmallString::try_from_utf8(invalid_utf8), Err(Error::Utf8));

let out_of_bounds = "0000".repeat(400);
assert_eq!(SmallString::try_from_utf8(out_of_bounds.as_bytes()), Err(Error::OutOfBounds));

pub fn from_utf8<B>(slice: B) -> Result<Self, Utf8> where     B: AsRef<[u8]>,

Creates new ArrayString from byte slice, returning Utf8 on invalid utf-8 data, truncating if bigger than capacity.

let string = SmallString::from_utf8("My String")?;
assert_eq!(string.as_str(), "My String");

let invalid_utf8 = [0, 159, 146, 150];
assert_eq!(SmallString::from_utf8(invalid_utf8), Err(Utf8));

let out_of_bounds = "0".repeat(300);
assert_eq!(SmallString::from_utf8(out_of_bounds.as_bytes())?.as_str(),
           "0".repeat(SmallString::capacity().into()).as_str());

pub unsafe fn from_utf8_unchecked<B>(slice: B) -> Self where     B: AsRef<[u8]>,

Creates new ArrayString from byte slice assuming it's utf-8 and of a appropriate size.

Safety

It's UB if slice is not a valid utf-8 string or slice.len() > capacity.

let string = unsafe { SmallString::from_utf8_unchecked("My String") };
assert_eq!(string.as_str(), "My String");

// Undefined behavior, don't do it
// let out_of_bounds = "0".repeat(300);
// let ub = unsafe { SmallString::from_utf8_unchecked(out_of_bounds)) };

pub fn try_from_utf16<B>(slice: B) -> Result<Self, Error> where     B: AsRef<[u16]>,

Creates new ArrayString from u16 slice, returning Utf16 on invalid utf-16 data or OutOfBounds if bigger than capacity

let music = [0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0x0069, 0x0063];
let string = SmallString::try_from_utf16(music)?;
assert_eq!(string.as_str(), "𝄞music");

let invalid_utf16 = [0xD834, 0xDD1E, 0x006d, 0x0075, 0xD800, 0x0069, 0x0063];
assert_eq!(SmallString::try_from_utf16(invalid_utf16), Err(Error::Utf16));

let out_of_bounds: Vec<_> = (0..300).map(|_| 0).collect();
assert_eq!(SmallString::try_from_utf16(out_of_bounds), Err(Error::OutOfBounds));

pub fn from_utf16<B>(slice: B) -> Result<Self, Utf16> where     B: AsRef<[u16]>,

Creates new ArrayString from u16 slice, returning Utf16 on invalid utf-16 data, truncating if bigger than capacity.

let music = [0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0x0069, 0x0063];
let string = SmallString::from_utf16(music)?;
assert_eq!(string.as_str(), "𝄞music");

let invalid_utf16 = [0xD834, 0xDD1E, 0x006d, 0x0075, 0xD800, 0x0069, 0x0063];
assert_eq!(SmallString::from_utf16(invalid_utf16), Err(Utf16));

let out_of_bounds: Vec<u16> = (0..300).map(|_| 0).collect();
assert_eq!(SmallString::from_utf16(out_of_bounds)?.as_str(),
           "\0".repeat(SmallString::capacity().into()).as_str());

pub fn from_utf16_lossy<B>(slice: B) -> Self where     B: AsRef<[u16]>,

Creates new ArrayString from u16 slice, replacing invalid utf-16 data with REPLACEMENT_CHARACTER (\u{FFFD}) and truncating size if bigger than capacity

let music = [0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0x0069, 0x0063];
let string = SmallString::from_utf16_lossy(music);
assert_eq!(string.as_str(), "𝄞music");

let invalid_utf16 = [0xD834, 0xDD1E, 0x006d, 0x0075, 0xD800, 0x0069, 0x0063];
assert_eq!(SmallString::from_utf16_lossy(invalid_utf16).as_str(), "𝄞mu\u{FFFD}ic");

let out_of_bounds: Vec<u16> = (0..300).map(|_| 0).collect();
assert_eq!(SmallString::from_utf16_lossy(&out_of_bounds).as_str(),
           "\0".repeat(SmallString::capacity().into()).as_str());

pub fn as_str(&self) -> &str

Extracts a string slice containing the entire ArrayString

let s = SmallString::try_from_str("My String")?;
assert_eq!(s.as_str(), "My String");

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

Extracts a mutable string slice containing the entire ArrayString

let mut s = SmallString::try_from_str("My String")?;
assert_eq!(s.as_mut_str(), "My String");

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

Extracts a byte slice containing the entire ArrayString

let s = SmallString::try_from_str("My String")?;
assert_eq!(s.as_bytes(), "My String".as_bytes());

pub unsafe fn as_mut_bytes(&mut self) -> &mut [u8]

Extracts a mutable string slice containing the entire ArrayString

let mut s = SmallString::try_from_str("My String")?;
assert_eq!(unsafe { s.as_mut_bytes() }, "My String".as_bytes());

pub fn capacity() -> u8

Returns maximum string capacity, defined at compile time, it will never change

assert_eq!(ArrayString::<typenum::U32>::capacity(), 32);

pub fn try_push_str<S>(&mut self, string: S) -> Result<(), OutOfBounds> where     S: AsRef<str>,

Pushes string slice to the end of the ArrayString if total size is lower or equal to capacity, otherwise returns an error.

let mut s = MaxString::try_from_str("My String")?;
s.try_push_str(" My other String")?;
assert_eq!(s.as_str(), "My String My other String");

assert!(s.try_push_str("0".repeat(MaxString::capacity().into())).is_err());

pub fn push_str<S>(&mut self, string: S) where     S: AsRef<str>,

Pushes string slice to the end of the ArrayString truncating total size if bigger than capacity.

let mut s = MaxString::try_from_str("My String")?;
s.push_str(" My other String");
assert_eq!(s.as_str(), "My String My other String");

let mut s = SmallString::default();
s.push_str("0".repeat(SmallString::capacity() as usize + 1));
assert_eq!(s.as_str(), "0".repeat(SmallString::capacity().into()).as_str());

pub unsafe fn push_str_unchecked<S>(&mut self, string: S) where     S: AsRef<str>,

Pushes string slice to the end of the ArrayString assuming total size is appropriate.

Safety

It's UB if self.len() + string.len() > capacity.

let mut s = MaxString::try_from_str("My String")?;
unsafe { s.push_str_unchecked(" My other String") };
assert_eq!(s.as_str(), "My String My other String");

// Undefined behavior, don't do it
// let mut undefined_behavior = SmallString::default();
// undefined_behavior.push_str_unchecked("0".repeat(SmallString::capacity().into() + 1));

pub fn try_push(&mut self, character: char) -> Result<(), OutOfBounds>

Inserts character to the end of the ArrayString erroring if total size if bigger than capacity.

let mut s = SmallString::try_from_str("My String")?;
s.try_push('!')?;
assert_eq!(s.as_str(), "My String!");

let mut s = SmallString::try_from_str(&"0".repeat(SmallString::capacity().into()))?;
assert!(s.try_push('!').is_err());

pub unsafe fn push_unchecked(&mut self, ch: char)

Inserts character to the end of the ArrayString assuming length is appropriate

Safety

It's UB if self.len() + character.len_utf8() > capacity

let mut s = SmallString::try_from_str("My String")?;
unsafe { s.push_unchecked('!') };
assert_eq!(s.as_str(), "My String!");

// s = SmallString::try_from_str(&"0".repeat(SmallString::capacity().into()))?;
// Undefined behavior, don't do it
// s.push_unchecked('!');

pub fn truncate(&mut self, size: u8) -> Result<(), Utf8>

Truncates ArrayString to specified size (if smaller than current size and a valid utf-8 char index).

let mut s = SmallString::try_from_str("My String")?;
s.truncate(5)?;
assert_eq!(s.as_str(), "My St");

// Does nothing
s.truncate(6)?;
assert_eq!(s.as_str(), "My St");

// Index is not at a valid char
let mut s = SmallString::try_from_str("🤔")?;
assert!(s.truncate(1).is_err());

pub fn pop(&mut self) -> Option<char>

Removes last character from ArrayString, if any.

let mut s = SmallString::try_from_str("A🤔")?;
assert_eq!(s.pop(), Some('🤔'));
assert_eq!(s.pop(), Some('A'));
assert_eq!(s.pop(), None);

pub fn trim(&mut self)

Removes spaces from the beggining and end of the string

let mut string = MaxString::try_from_str("   to be trimmed     ")?;
string.trim();
assert_eq!(string.as_str(), "to be trimmed");

let mut string = SmallString::try_from_str("   🤔")?;
string.trim();
assert_eq!(string.as_str(), "🤔");

pub fn remove(&mut self, idx: u8) -> Result<char, Error>

Removes specified char from ArrayString

let mut s = SmallString::try_from_str("ABCD🤔")?;
assert_eq!(s.remove("ABCD🤔".len() as u8), Err(Error::OutOfBounds));
assert_eq!(s.remove(10), Err(Error::OutOfBounds));
assert_eq!(s.remove(6), Err(Error::Utf8));
assert_eq!(s.remove(0), Ok('A'));
assert_eq!(s.as_str(), "BCD🤔");
assert_eq!(s.remove(2), Ok('D'));
assert_eq!(s.as_str(), "BC🤔");

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

Retains only the characters specified by the predicate.

let mut s = SmallString::try_from_str("ABCD🤔")?;
s.retain(|c| c != '🤔');
assert_eq!(s.as_str(), "ABCD");

pub fn try_insert(&mut self, idx: u8, ch: char) -> Result<(), Error>

Inserts character at specified index, returning error if total length is bigger than capacity.

Returns OutOfBounds if idx is out of bounds and Utf8 if idx is not a char position

let mut s = SmallString::try_from_str("ABCD🤔")?;
s.try_insert(1, 'A')?;
s.try_insert(2, 'B')?;
assert_eq!(s.as_str(), "AABBCD🤔");
assert_eq!(s.try_insert(20, 'C'), Err(Error::OutOfBounds));
assert_eq!(s.try_insert(8, 'D'), Err(Error::Utf8));

let mut s = SmallString::try_from_str(&"0".repeat(SmallString::capacity().into()))?;
assert_eq!(s.try_insert(0, 'C'), Err(Error::OutOfBounds));

pub unsafe fn insert_unchecked(&mut self, idx: u8, ch: char)

Inserts character at specified index assuming length is appropriate

Safety

It's UB if idx does not lie on a utf-8 char boundary

It's UB if self.len() + character.len_utf8() > capacity

let mut s = SmallString::try_from_str("ABCD🤔")?;
unsafe { s.insert_unchecked(1, 'A') };
unsafe { s.insert_unchecked(1, 'B') };
assert_eq!(s.as_str(), "ABABCD🤔");

// Undefined behavior, don't do it
// s.insert(20, 'C');
// s.insert(8, 'D');

pub fn try_insert_str<S>(&mut self, idx: u8, s: S) -> Result<(), Error> where     S: AsRef<str>,

Inserts string slice at specified index, returning error if total length is bigger than capacity.

Returns OutOfBounds if idx is out of bounds Returns Utf8 if idx is not a char position

let mut s = SmallString::try_from_str("ABCD🤔")?;
s.try_insert_str(1, "AB")?;
s.try_insert_str(1, "BC")?;
assert_eq!(s.try_insert_str(1, "0".repeat(SmallString::capacity().into())),
           Err(Error::OutOfBounds));
assert_eq!(s.as_str(), "ABCABBCD🤔");
assert_eq!(s.try_insert_str(20, "C"), Err(Error::OutOfBounds));
assert_eq!(s.try_insert_str(10, "D"), Err(Error::Utf8));

pub fn insert_str<S>(&mut self, idx: u8, string: S) -> Result<(), Error> where     S: AsRef<str>,

Inserts string slice at specified index, truncating size if bigger than capacity.

Returns OutOfBounds if idx is out of bounds and Utf8 if idx is not a char position

let mut s = SmallString::try_from_str("ABCD🤔")?;
s.insert_str(1, "AB")?;
s.insert_str(1, "BC")?;
assert_eq!(s.as_str(), "ABCABBCD🤔");

assert_eq!(s.insert_str(20, "C"), Err(Error::OutOfBounds));
assert_eq!(s.insert_str(10, "D"), Err(Error::Utf8));

s.clear();
s.insert_str(0, "0".repeat(SmallString::capacity() as usize + 10))?;
assert_eq!(s.as_str(), "0".repeat(SmallString::capacity().into()).as_str());

pub unsafe fn insert_str_unchecked<S>(&mut self, idx: u8, string: S) where     S: AsRef<str>,

Inserts string slice at specified index, assuming total length is appropriate.

Safety

It's UB if idx does not lie on a utf-8 char boundary

It's UB if self.len() + string.len() > capacity

let mut s = SmallString::try_from_str("ABCD🤔")?;
unsafe { s.insert_str_unchecked(1, "AB") };
unsafe { s.insert_str_unchecked(1, "BC") };
assert_eq!(s.as_str(), "ABCABBCD🤔");

// Undefined behavior, don't do it
// unsafe { s.insert_str_unchecked(20, "C") };
// unsafe { s.insert_str_unchecked(10, "D") };
// unsafe { s.insert_str_unchecked(1, "0".repeat(SmallString::capacity().into())) };

pub fn len(&self) -> u8

Returns ArrayString length.

let mut s = SmallString::try_from_str("ABCD")?;
assert_eq!(s.len(), 4);
s.try_push('🤔')?;
// Emojis use 4 bytes (this is the default rust behavior, length of u8)
assert_eq!(s.len(), 8);

pub fn is_empty(&self) -> bool

Checks if ArrayString is empty.

let mut s = SmallString::try_from_str("ABCD")?;
assert!(!s.is_empty());
s.clear();
assert!(s.is_empty());

pub fn split_off(&mut self, at: u8) -> Result<Self, Error>

Splits ArrayString in two if at is smaller than self.len().

Returns Utf8 if at does not lie at a valid utf-8 char boundary and OutOfBounds if it's out of bounds

let mut s = SmallString::try_from_str("AB🤔CD")?;
assert_eq!(s.split_off(6)?.as_str(), "CD");
assert_eq!(s.as_str(), "AB🤔");
assert_eq!(s.split_off(20), Err(Error::OutOfBounds));
assert_eq!(s.split_off(4), Err(Error::Utf8));

pub fn clear(&mut self)

Empties ArrayString

let mut s = SmallString::try_from_str("ABCD")?;
assert!(!s.is_empty());
s.clear();
assert!(s.is_empty());

pub fn drain<R>(&mut self, range: R) -> Result<Drain<SIZE>, Error> where     R: RangeBounds<u8>,

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.

let mut s = SmallString::try_from_str("ABCD🤔")?;
assert_eq!(s.drain(..3)?.collect::<Vec<_>>(), vec!['A', 'B', 'C']);
assert_eq!(s.as_str(), "D🤔");

assert_eq!(s.drain(3..), Err(Error::Utf8));
assert_eq!(s.drain(10..), Err(Error::OutOfBounds));

pub fn replace_range<S, R>(&mut self, r: R, with: S) -> Result<(), Error> where     S: AsRef<str>,     R: RangeBounds<u8>,

Removes the specified range of the ArrayString, and replaces it with the given string. The given string doesn't need to have the same length as the range.

let mut s = SmallString::try_from_str("ABCD🤔")?;
s.replace_range(2..4, "EFGHI")?;
assert_eq!(s.as_str(), "ABEFGHI🤔");

assert_eq!(s.replace_range(9.., "J"), Err(Error::Utf8));
assert_eq!(s.replace_range(..90, "K"), Err(Error::OutOfBounds));
assert_eq!(s.replace_range(0..1, "0".repeat(SmallString::capacity().into())),
           Err(Error::OutOfBounds));

Trait Implementations

impl<'a, SIZE> From<&'a str> for ArrayString<SIZE> where     SIZE: Capacity,

fn from(s: &str) -> Self

Performs the conversion.

impl From<ArrayString<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>>> for CacheString

fn from(array: ArrayString<U63>) -> Self

Performs the conversion.

impl<SIZE: Capacity> Eq for ArrayString<SIZE>

impl<SIZE> Extend<char> for ArrayString<SIZE> where     SIZE: Capacity,

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

Extends a collection with the contents of an iterator.

impl<'a, SIZE> Extend<&'a char> for ArrayString<SIZE> where     SIZE: Capacity,

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

Extends a collection with the contents of an iterator.

impl<'a, SIZE> Extend<&'a str> for ArrayString<SIZE> where     SIZE: Capacity,

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

Extends a collection with the contents of an iterator.

impl<SIZE> PartialOrd<ArrayString<SIZE>> for ArrayString<SIZE> where     SIZE: Capacity,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

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

#[must_use] fn lt(&self, other: &Rhs) -> bool

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

#[must_use] fn le(&self, other: &Rhs) -> bool

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

#[must_use] fn gt(&self, other: &Rhs) -> bool

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

#[must_use] fn ge(&self, other: &Rhs) -> bool

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

impl<SIZE> AsMut<str> for ArrayString<SIZE> where     SIZE: Capacity,

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

Performs the conversion.

impl<SIZE: Capacity + Copy> Copy for ArrayString<SIZE> where     SIZE::Array: Copy,

impl<SIZE> Default for ArrayString<SIZE> where     SIZE: Capacity,

fn default() -> Self

Returns the "default value" for a type.

impl<'a, 'b, SIZE> PartialEq<str> for ArrayString<SIZE> where     SIZE: Capacity,

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

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

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

This method tests for !=.

impl<SIZE> PartialEq<ArrayString<SIZE>> for ArrayString<SIZE> where     SIZE: Capacity,

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

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

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

This method tests for !=.

impl<SIZE> AsRef<str> for ArrayString<SIZE> where     SIZE: Capacity,

fn as_ref(&self) -> &str

Performs the conversion.

impl<SIZE> AsRef<[u8]> for ArrayString<SIZE> where     SIZE: Capacity,

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

Performs the conversion.

impl<SIZE: Clone + Capacity> Clone for ArrayString<SIZE> where     SIZE::Array: Clone,

fn clone(&self) -> ArrayString<SIZE>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<SIZE> Ord for ArrayString<SIZE> where     SIZE: Capacity,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<SIZE> Debug for ArrayString<SIZE> where     SIZE: Capacity,

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

Formats the value using the given formatter.

impl<SIZE> Display for ArrayString<SIZE> where     SIZE: Capacity,

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

Formats the value using the given formatter.

impl<SIZE> Write for ArrayString<SIZE> where     SIZE: Capacity,

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

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

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

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

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

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

impl<SIZE> DerefMut for ArrayString<SIZE> where     SIZE: Capacity,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<SIZE> Deref for ArrayString<SIZE> where     SIZE: Capacity,

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<SIZE> Hash for ArrayString<SIZE> where     SIZE: Capacity,

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

Feeds this value into the given [Hasher].

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

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

impl<'a, SIZE> Add<&'a str> for ArrayString<SIZE> where     SIZE: Capacity,

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl<SIZE> Index<RangeFrom<u8>> for ArrayString<SIZE> where     SIZE: Capacity,

type Output = str

The returned type after indexing.

fn index(&self, index: RangeFrom<u8>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<SIZE> Index<RangeTo<u8>> for ArrayString<SIZE> where     SIZE: Capacity,

type Output = str

The returned type after indexing.

fn index(&self, index: RangeTo<u8>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<SIZE> Index<RangeFull> for ArrayString<SIZE> where     SIZE: Capacity,

type Output = str

The returned type after indexing.

fn index(&self, index: RangeFull) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<SIZE> Index<Range<u8>> for ArrayString<SIZE> where     SIZE: Capacity,

type Output = str

The returned type after indexing.

fn index(&self, index: Range<u8>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<SIZE> Index<RangeToInclusive<u8>> for ArrayString<SIZE> where     SIZE: Capacity,

type Output = str

The returned type after indexing.

fn index(&self, index: RangeToInclusive<u8>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<SIZE> Index<RangeInclusive<u8>> for ArrayString<SIZE> where     SIZE: Capacity,

type Output = str

The returned type after indexing.

fn index(&self, index: RangeInclusive<u8>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<SIZE> IndexMut<RangeFrom<u8>> for ArrayString<SIZE> where     SIZE: Capacity,

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

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

impl<SIZE> IndexMut<RangeTo<u8>> for ArrayString<SIZE> where     SIZE: Capacity,

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

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

impl<SIZE> IndexMut<RangeFull> for ArrayString<SIZE> where     SIZE: Capacity,

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

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

impl<SIZE> IndexMut<Range<u8>> for ArrayString<SIZE> where     SIZE: Capacity,

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

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

impl<SIZE> IndexMut<RangeToInclusive<u8>> for ArrayString<SIZE> where     SIZE: Capacity,

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

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

impl<SIZE> IndexMut<RangeInclusive<u8>> for ArrayString<SIZE> where     SIZE: Capacity,

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

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

impl<SIZE> FromIterator<char> for ArrayString<SIZE> where     SIZE: Capacity,

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

Creates a value from an iterator.

impl<'a, SIZE> FromIterator<&'a str> for ArrayString<SIZE> where     SIZE: Capacity,

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

Creates a value from an iterator.

impl<SIZE> FromStr for ArrayString<SIZE> where     SIZE: Capacity,

type Err = OutOfBounds

The associated error which can be returned from parsing.

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

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

impl<SIZE> Borrow<str> for ArrayString<SIZE> where     SIZE: Capacity,

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl<SIZE> BorrowMut<str> for ArrayString<SIZE> where     SIZE: Capacity,

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

Mutably borrows from an owned value.

impl<SIZE, ST, DB> Queryable<ST, DB> for ArrayString<SIZE> where     SIZE: Capacity,     DB: Backend,     *const str: FromSql<ST, DB>,

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

impl<SIZE: Capacity, QS> SelectableExpression<QS> for ArrayString<SIZE>

impl<SIZE: Capacity, QS> AppearsOnTable<QS> for ArrayString<SIZE>

impl<SIZE: Capacity> Expression for ArrayString<SIZE>

type SqlType = VarChar

The type that this expression represents in SQL

impl<SIZE, DB> ToSql<Text, DB> for ArrayString<SIZE> where     SIZE: Capacity,     DB: Backend,

fn to_sql<W: Write>(&self, out: &mut Output<W, DB>) -> Result

See the trait documentation.

impl<SIZE, DB> QueryFragment<DB> for ArrayString<SIZE> where     SIZE: Capacity,     DB: Backend + HasSqlType<VarChar>,

fn walk_ast(&self, pass: AstPass<DB>) -> QueryResult<()>

Walk over this QueryFragment for all passes.

fn to_sql(&self, out: &mut <DB as Backend>::QueryBuilder) -> Result<(), Error>

Converts this QueryFragment to its SQL representation.

fn collect_binds(     &self,     out: &mut <DB as Backend>::BindCollector,     metadata_lookup: &<DB as TypeMetadata>::MetadataLookup ) -> Result<(), Error>

Serializes all bind parameters in this query.

fn is_safe_to_cache_prepared(&self) -> Result<bool, Error>

Is this query safe to store in the prepared statement cache?

impl<SIZE: Capacity> NonAggregate for ArrayString<SIZE>

impl<SIZE, ST, DB> FromSql<ST, DB> for ArrayString<SIZE> where     SIZE: Capacity,     DB: Backend,     *const str: FromSql<ST, DB>,

fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self>

See the trait documentation.

impl<SIZE, ST, DB> FromSqlRow<ST, DB> for ArrayString<SIZE> where     SIZE: Capacity,     DB: Backend,     *const str: FromSql<ST, DB>,

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

fn build_from_row<T: Row<DB>>(row: &mut T) -> Result<Self>

See the trait documentation.

impl<SIZE> Serialize for ArrayString<SIZE> where     SIZE: Capacity,

fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<'a, SIZE> Deserialize<'a> for ArrayString<SIZE> where     SIZE: Capacity,

fn deserialize<D: Deserializer<'a>>(des: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.