Struct str_stack::StrStack

pub struct StrStack { /* fields omitted */ }

Implementations

impl StrStack

pub fn new() -> StrStack

Create a new StrStack.

pub fn with_capacity(bytes: usize, strings: usize) -> StrStack

Create a new StrStack with the given capacity.

You will be able to push bytes bytes and create strings strings before reallocating.

pub fn push(&mut self, s: &str) -> usize

Push a string onto the string stack.

This returns the index of the string on the stack.

pub fn iter(&self) -> Iter<'_>

Iterate over the strings on the stack.

pub fn pop(&mut self) -> bool

Remove the top string from the stack.

Returns true iff a string was removed.

pub fn clear(&mut self)

Clear the stack.

pub fn len(&self) -> usize

Returns the number of strings on the stack.

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

Truncate the stack to len strings.

pub fn consume<R: Read>(&mut self, source: R) -> Result<usize>

Read from source into the string stack.

Returns the index of the new string or an IO Error.

pub fn writer(&mut self) -> Writer<'_>

Returns a writer helper for this string stack.

This is useful for building a string in-place on the string-stack.

Example:

use std::fmt::Write;
use str_stack::StrStack;

let mut s = StrStack::new();
let index = {
    let mut writer = s.writer();
    writer.write_str("Hello");
    writer.write_char(' ');
    writer.write_str("World");
    writer.write_char('!');
    writer.finish()
};
assert_eq!(&s[index], "Hello World!");

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

Allows calling the write! macro directly on the string stack:

Example:

use std::fmt::Write;
use str_stack::StrStack;

let mut s = StrStack::new();
let index = write!(&mut s, "Hello {}!", "World");
assert_eq!(&s[index], "Hello World!");

pub unsafe fn get_unchecked(&self, index: usize) -> &str

Trait Implementations

impl Clone for StrStack

fn clone(&self) -> StrStack

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StrStack

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

Formats the value using the given formatter.

impl Default for StrStack

fn default() -> StrStack

Returns the “default value” for a type.

impl<S> Extend<S> for StrStack where
    S: AsRef<str>, 

fn extend<T>(&mut self, iterator: T) where
    T: IntoIterator<Item = S>, 

Extends a collection with the contents of an iterator.

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<S> FromIterator<S> for StrStack where
    S: AsRef<str>, 

fn from_iter<T>(iterator: T) -> Self where
    T: IntoIterator<Item = S>, 

Creates a value from an iterator.

impl Index<usize> for StrStack

type Output = str

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a> IntoIterator for &'a StrStack

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

type Item = &'a str

The type of the elements being iterated over.

fn into_iter(self) -> Iter<'a>

Creates an iterator from a value.