Struct StringInterner

pub struct StringInterner<B, H = DefaultHashBuilder>
where
    B: Backend,
{ /* private fields */ }

Data structure to intern and resolve strings.

Caches strings efficiently, with minimal memory footprint and associates them with unique symbols. These symbols allow constant time comparisons and look-ups to the underlying interned strings.

The following API covers the main functionality:

• StringInterner::get_or_intern: To intern a new string.
  • This maps from string type to symbol type.
• StringInterner::resolve: To resolve your already interned strings.
  • This maps from symbol type to string type.

Implementations

impl<B, H> StringInterner<B, H>

where B: Backend, <B as Backend>::Symbol: Symbol, H: BuildHasher + Default,

pub fn new() -> Self

Creates a new empty StringInterner.

pub fn with_capacity(cap: usize) -> Self

Creates a new StringInterner with the given initial capacity.

impl<B, H> StringInterner<B, H>

where B: Backend, <B as Backend>::Symbol: Symbol, H: BuildHasher,

pub fn with_hasher(hash_builder: H) -> Self

Creates a new empty StringInterner with the given hasher.

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

Creates a new empty StringInterner with the given initial capacity and the given hasher.

pub fn len(&self) -> usize

Returns the number of strings interned by the interner.

pub fn is_empty(&self) -> bool

Returns true if the string interner has no interned strings.

pub fn get<T>(&self, string: T) -> Option<<B as Backend>::Symbol>

where T: AsRef<str>,

Returns the symbol for the given string if any.

Can be used to query if a string has already been interned without interning.

pub fn get_or_intern<T>(&mut self, string: T) -> <B as Backend>::Symbol

where T: AsRef<str>,

Interns the given string.

Returns a symbol for resolution into the original string.

Panics

If the interner already interns the maximum number of strings possible by the chosen symbol type.

pub fn get_or_intern_static( &mut self, string: &'static str, ) -> <B as Backend>::Symbol

Interns the given 'static string.

Returns a symbol for resolution into the original string.

Note

This is more efficient than StringInterner::get_or_intern since it might avoid some memory allocations if the backends supports this.

Panics

If the interner already interns the maximum number of strings possible by the chosen symbol type.

pub fn shrink_to_fit(&mut self)

Shrink backend capacity to fit the interned strings exactly.

pub fn resolve(&self, symbol: <B as Backend>::Symbol) -> Option<&str>

Returns the string for the given `symbol`` if any.

pub unsafe fn resolve_unchecked(&self, symbol: <B as Backend>::Symbol) -> &str

Returns the string for the given symbol without performing any checks.

Safety

It is the caller’s responsibility to provide this method with symbols that are valid for the StringInterner.

pub fn iter(&self) -> <B as Backend>::Iter<'_>

Returns an iterator that yields all interned strings and their symbols.

Trait Implementations

impl<B, H> Clone for StringInterner<B, H>

where B: Backend + Clone, <B as Backend>::Symbol: Symbol, H: BuildHasher + Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B, H> Debug for StringInterner<B, H>

where B: Backend + Debug, <B as Backend>::Symbol: Symbol + Debug, H: BuildHasher,

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

Formats the value using the given formatter.

impl Default for StringInterner<DefaultBackend>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, B, H> Deserialize<'de> for StringInterner<B, H>

where B: Backend, <B as Backend>::Symbol: Symbol, H: BuildHasher + Default,

fn deserialize<D>(deserializer: D) -> Result<StringInterner<B, H>, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<B, H, T> Extend<T> for StringInterner<B, H>

where B: Backend, <B as Backend>::Symbol: Symbol, H: BuildHasher, T: AsRef<str>,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = T>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

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<B, H, T> FromIterator<T> for StringInterner<B, H>

where B: Backend, <B as Backend>::Symbol: Symbol, H: BuildHasher + Default, T: AsRef<str>,

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<'a, B, H> IntoIterator for &'a StringInterner<B, H>

where B: Backend, <B as Backend>::Symbol: Symbol, &'a B: IntoIterator<Item = (<B as Backend>::Symbol, &'a str)>, H: BuildHasher,

type Item = (<B as Backend>::Symbol, &'a str)

The type of the elements being iterated over.

type IntoIter = <&'a B as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<B, H> PartialEq for StringInterner<B, H>

where B: Backend + PartialEq, <B as Backend>::Symbol: Symbol, H: BuildHasher,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<B, H> Serialize for StringInterner<B, H>

where B: Backend, <B as Backend>::Symbol: Symbol, for<'a> &'a B: IntoIterator<Item = (<B as Backend>::Symbol, &'a str)>, H: BuildHasher,

fn serialize<T>(&self, serializer: T) -> Result<T::Ok, T::Error>

where T: Serializer,

Serialize this value into the given Serde serializer.

impl<B, H> Eq for StringInterner<B, H>

where B: Backend + Eq, <B as Backend>::Symbol: Symbol, H: BuildHasher,