Struct Interner

pub struct Interner<S = Symbol, H = RandomState> { /* private fields */ }

String interner.

This is a thin wrapper around BytesInterner that uses str instead of [u8].

See the crate-level docs for more details.

Implementations

impl Interner<Symbol, RandomState>

pub fn new() -> Self

Creates a new, empty Interner with the default symbol and hasher.

pub fn with_capacity(capacity: usize) -> Self

Creates a new Interner with the given capacity and default symbol and hasher.

impl<S: InternerSymbol, H: BuildHasher> Interner<S, H>

pub fn with_hasher(hash_builder: H) -> Self

Creates a new Interner with the given custom hasher.

pub fn with_capacity_and_hasher(capacity: usize, hash_builder: H) -> Self

Creates a new Interner with the given capacitiy and custom hasher.

pub fn len(&self) -> usize

Returns the number of unique strings in the interner.

pub fn is_empty(&self) -> bool

Returns true if the interner is empty.

pub fn iter(&self) -> impl ExactSizeIterator<Item = (S, &str)> + Clone

Returns an iterator over the interned strings and their corresponding Symbols.

Does not guarantee that it includes symbols added after the iterator was created.

pub fn all_symbols( &self, ) -> impl ExactSizeIterator<Item = S> + Send + Sync + Clone

Returns an iterator over all symbols in the interner.

pub fn intern(&self, s: &str) -> S

Interns a string, returning its unique Symbol.

Allocates the string internally if it is not already interned.

If s outlives self, like &'static str, prefer using intern_static, as it will not allocate the string on the heap.

pub fn intern_mut(&mut self, s: &str) -> S

Interns a string, returning its unique Symbol.

Allocates the string internally if it is not already interned.

If s outlives self, like &'static str, prefer using intern_mut_static, as it will not allocate the string on the heap.

By taking &mut self, this never acquires any locks.

pub fn intern_static<'a, 'b: 'a>(&'a self, s: &'b str) -> S

Interns a static string, returning its unique Symbol.

Note that this only requires that s outlives self, which means we can avoid allocating the string.

pub fn intern_mut_static<'a, 'b: 'a>(&'a mut self, s: &'b str) -> S

Interns a static string, returning its unique Symbol.

Note that this only requires that s outlives self, which means we can avoid allocating the string.

By taking &mut self, this never acquires any locks.

pub fn intern_many<'a>(&self, strings: impl IntoIterator<Item = &'a str>)

Interns multiple strings.

Allocates the strings internally if they are not already interned.

If the strings outlive self, like &'static str, prefer using intern_many_static, as it will not allocate the strings on the heap.

pub fn intern_many_mut<'a>( &mut self, strings: impl IntoIterator<Item = &'a str>, )

Interns multiple strings.

Allocates the strings internally if they are not already interned.

If the strings outlive self, like &'static str, prefer using intern_many_mut_static, as it will not allocate the strings on the heap.

By taking &mut self, this never acquires any locks.

pub fn intern_many_static<'a, 'b: 'a>( &'a self, strings: impl IntoIterator<Item = &'b str>, )

Interns multiple static strings.

Note that this only requires that the strings outlive self, which means we can avoid allocating the strings.

pub fn intern_many_mut_static<'a, 'b: 'a>( &'a mut self, strings: impl IntoIterator<Item = &'b str>, )

Interns multiple static strings.

Note that this only requires that the strings outlive self, which means we can avoid allocating the strings.

By taking &mut self, this never acquires any locks.

pub fn resolve(&self, sym: S) -> &str

Maps a Symbol to its string. This is a cheap, lock-free operation.

Panics

Panics if Symbol is out of bounds of this Interner. You should only use Symbols created by this Interner.

Trait Implementations

impl Default for Interner

fn default() -> Self

Returns the “default value” for a type.