Struct inlinable_string::inline_string::InlineString

pub struct InlineString { /* fields omitted */ }

A short UTF-8 string that uses inline storage and does no heap allocation.

See the module level documentation for more.

Implementations

impl InlineString

pub fn new() -> InlineString

Creates a new string buffer initialized with the empty string.

Examples

use inlinable_string::InlineString;

let s = InlineString::new();

pub fn into_bytes(self) -> [u8; 14]

Returns the underlying byte buffer, encoded as UTF-8. Trailing bytes are zeroed.

Examples

use inlinable_string::InlineString;

let s = InlineString::from("hello");
let bytes = s.into_bytes();
assert_eq!(&bytes[0..5], [104, 101, 108, 108, 111]);

pub fn push_str(&mut self, string: &str) -> Result<(), NotEnoughSpaceError>

Pushes the given string onto this string buffer.

Examples

use inlinable_string::InlineString;

let mut s = InlineString::from("foo");
s.push_str("bar");
assert_eq!(s, "foobar");

pub fn push(&mut self, ch: char) -> Result<(), NotEnoughSpaceError>

Adds the given character to the end of the string.

Examples

use inlinable_string::InlineString;

let mut s = InlineString::from("abc");
s.push('1');
s.push('2');
s.push('3');
assert_eq!(s, "abc123");

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

Works with the underlying buffer as a byte slice.

Examples

use inlinable_string::InlineString;

let s = InlineString::from("hello");
assert_eq!(s.as_bytes(), [104, 101, 108, 108, 111]);

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

Shortens a string to the specified length.

Panics

Panics if new_len > current length, or if new_len is not a character boundary.

Examples

use inlinable_string::InlineString;

let mut s = InlineString::from("hello");
s.truncate(2);
assert_eq!(s, "he");

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

Removes the last character from the string buffer and returns it. Returns None if this string buffer is empty.

Examples

use inlinable_string::InlineString;

let mut s = InlineString::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 the character from the string buffer at byte position idx and returns it.

Panics

If idx does not lie on a character boundary, or if it is out of bounds, then this function will panic.

Examples

use inlinable_string::InlineString;

let mut s = InlineString::from("foo");
assert_eq!(s.remove(0), 'f');
assert_eq!(s.remove(1), 'o');
assert_eq!(s.remove(0), 'o');

pub fn insert(
    &mut self,
    idx: usize,
    ch: char
) -> Result<(), NotEnoughSpaceError>

Inserts a character into the string buffer at byte position idx.

Examples

use inlinable_string::InlineString;

let mut s = InlineString::from("foo");
s.insert(2, 'f');
assert!(s == "fofo");

Panics

If idx does not lie on a character boundary or is out of bounds, then this function will panic.

pub fn insert_str(
    &mut self,
    idx: usize,
    string: &str
) -> Result<(), NotEnoughSpaceError>

Inserts a string into the string buffer at byte position idx.

Examples

use inlinable_string::InlineString;

let mut s = InlineString::from("foo");
s.insert_str(2, "bar");
assert!(s == "fobaro");

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

Views the internal string buffer as a mutable sequence of bytes.

Safety

This is unsafe because it does not check to ensure that the resulting string will be valid UTF-8.

Examples

use inlinable_string::InlineString;

let mut s = InlineString::from("hello");
unsafe {
    let slice = s.as_mut_slice();
    assert!(slice == &[104, 101, 108, 108, 111]);
    slice.reverse();
}
assert_eq!(s, "olleh");

pub fn len(&self) -> usize

Returns the number of bytes in this string.

Examples

use inlinable_string::InlineString;

let a = InlineString::from("foo");
assert_eq!(a.len(), 3);

pub fn is_empty(&self) -> bool

Returns true if the string contains no bytes

Examples

use inlinable_string::InlineString;

let mut v = InlineString::new();
assert!(v.is_empty());
v.push('a');
assert!(!v.is_empty());

pub fn clear(&mut self)

Truncates the string, returning it to 0 length.

Examples

use inlinable_string::InlineString;

let mut s = InlineString::from("foo");
s.clear();
assert!(s.is_empty());

Trait Implementations

impl AsMut<[u8]> for InlineString

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

Performs the conversion.

impl AsMut<str> for InlineString

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

Performs the conversion.

impl AsRef<[u8]> for InlineString

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

Performs the conversion.

impl AsRef<str> for InlineString

fn as_ref(&self) -> &str

Performs the conversion.

impl Clone for InlineString

fn clone(&self) -> InlineString

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InlineString

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

Formats the value using the given formatter.

impl Default for InlineString

fn default() -> InlineString

Returns the "default value" for a type.

impl Deref for InlineString

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &str

Dereferences the value.

impl DerefMut for InlineString

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

Mutably dereferences the value.

impl Display for InlineString

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

Formats the value using the given formatter.

impl Eq for InlineString

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

Create a InlineString from the given &str.

Panics

If the given string's size is greater than INLINE_STRING_CAPACITY, this method panics.

fn from(string: &'a str) -> InlineString

Performs the conversion.

impl Hash for InlineString

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 Index<Range<usize>> for InlineString

type Output = str

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl Index<RangeFrom<usize>> for InlineString

type Output = str

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl Index<RangeFull> for InlineString

type Output = str

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl Index<RangeTo<usize>> for InlineString

type Output = str

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl IndexMut<Range<usize>> for InlineString

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

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

impl IndexMut<RangeFrom<usize>> for InlineString

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

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

impl IndexMut<RangeFull> for InlineString

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

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

impl IndexMut<RangeTo<usize>> for InlineString

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

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

impl<'a> PartialEq<&'a str> for InlineString

fn eq(&self, other: &&'a 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<'a> PartialEq<Cow<'a, str>> for InlineString

fn eq(&self, other: &Cow<'a, 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<'a> PartialEq<InlinableString> for InlineString

fn eq(&self, other: &InlinableString) -> 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 PartialEq<InlineString> for InlineString

fn eq(&self, rhs: &InlineString) -> 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<'a> PartialEq<InlineString> for str

fn eq(&self, other: &InlineString) -> 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<'a> PartialEq<InlineString> for &'a str

fn eq(&self, other: &InlineString) -> 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<'a> PartialEq<InlineString> for Cow<'a, str>

fn eq(&self, other: &InlineString) -> 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<'a> PartialEq<InlineString> for InlinableString

fn eq(&self, other: &InlineString) -> 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<'a> PartialEq<str> for InlineString

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 StructuralEq for InlineString

impl Write for InlineString

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

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

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

Writes a string slice 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.