Struct zerotrie::cursor::ZeroAsciiIgnoreCaseTrieCursor

pub struct ZeroAsciiIgnoreCaseTrieCursor<'a> {
    trie: ZeroAsciiIgnoreCaseTrie<&'a [u8]>,
}

A cursor into a ZeroAsciiIgnoreCaseTrie, useful for stepwise lookup.

For examples, see ZeroAsciiIgnoreCaseTrie::cursor().

Fields

trie: ZeroAsciiIgnoreCaseTrie<&'a [u8]>

Implementations

impl<'a> ZeroAsciiIgnoreCaseTrieCursor<'a>

pub fn step(&mut self, byte: u8) -> Option<u8>

Steps the cursor one byte into the trie.

Returns the byte if matched, which may be a different case than the input byte. If this function returns None, any lookup loops can be terminated.

Examples

Normalize the case of a value by stepping through an ignore-case trie:

use std::borrow::Cow;
use zerotrie::ZeroAsciiIgnoreCaseTrie;

// A trie with two values: "aBc" and "aBcdEf"
let trie = ZeroAsciiIgnoreCaseTrie::from_bytes(b"aBc\x80dEf\x81");

// Get out the value for "abc" and normalize the key string
let mut cursor = trie.cursor();
let mut key_str = Cow::Borrowed("abc".as_bytes());
let mut i = 0;
let value = loop {
    let Some(&input_byte) = key_str.get(i) else {
        break cursor.take_value();
    };
    let Some(matched_byte) = cursor.step(input_byte) else {
        break None;
    };
    if matched_byte != input_byte {
        key_str.to_mut()[i] = matched_byte;
    }
    i += 1;
};

assert_eq!(value, Some(0));
assert_eq!(&*key_str, "aBc".as_bytes());

For more examples, see ZeroTrieSimpleAsciiCursor::step.

pub fn take_value(&mut self) -> Option<usize>

Takes the value at the current position.

For more details, see ZeroTrieSimpleAsciiCursor::take_value.

pub fn probe(&mut self, index: usize) -> Option<AsciiProbeResult>

Probes the next byte in the cursor.

For more details, see ZeroTrieSimpleAsciiCursor::probe.

pub fn is_empty(&self) -> bool

Checks whether the cursor points to an empty trie.

For more details, see ZeroTrieSimpleAsciiCursor::is_empty.

Trait Implementations

impl<'a> Clone for ZeroAsciiIgnoreCaseTrieCursor<'a>

fn clone(&self) -> ZeroAsciiIgnoreCaseTrieCursor<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ZeroAsciiIgnoreCaseTrieCursor<'a>

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

Formats the value using the given formatter.

impl<'a> Write for ZeroAsciiIgnoreCaseTrieCursor<'a>

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

Steps the cursor through each ASCII byte of the string.

If the string contains non-ASCII chars, an error is returned.

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

Equivalent to ZeroAsciiIgnoreCaseTrieCursor::step(), except returns an error if the char is non-ASCII.

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

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