Struct string_interner::StringInterner

pub struct StringInterner<S = DefaultSymbol, B = DefaultBackend<S>, H = DefaultHashBuilder> where
    S: Symbol,
    H: BuildHasher,  { /* fields omitted */ }

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<S, B, H> StringInterner<S, B, H> where
    S: Symbol,
    B: Backend<S>,
    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<S, B, H> StringInterner<S, B, H> where
    S: Symbol,
    B: Backend<S>,
    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<S> 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) -> S 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) -> S

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 resolve(&self, symbol: S) -> Option<&str>

Returns the string for the given symbol if any.

Trait Implementations

impl<S, B, H> Clone for StringInterner<S, B, H> where
    S: Symbol,
    B: Backend<S> + Clone,
    H: BuildHasher + Clone, 

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, B, H> Debug for StringInterner<S, B, H> where
    S: Symbol + Debug,
    B: Backend<S> + Debug,
    H: BuildHasher, 

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

Formats the value using the given formatter.

impl Default for StringInterner

pub fn default() -> Self

Returns the "default value" for a type.

impl<'de, S, B, H> Deserialize<'de> for StringInterner<S, B, H> where
    S: Symbol,
    B: Backend<S>,
    H: BuildHasher + Default, 

pub fn deserialize<D>(
    deserializer: D
) -> Result<StringInterner<S, B, H>, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<S, B, H> Eq for StringInterner<S, B, H> where
    S: Symbol,
    B: Backend<S> + Eq,
    H: BuildHasher, 

impl<S, B, H, T> Extend<T> for StringInterner<S, B, H> where
    S: Symbol,
    B: Backend<S>,
    H: BuildHasher,
    T: AsRef<str>, 

pub fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = T>, 

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, B, H, T> FromIterator<T> for StringInterner<S, B, H> where
    S: Symbol,
    B: Backend<S>,
    H: BuildHasher + Default,
    T: AsRef<str>, 

pub fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator<Item = T>, 

Creates a value from an iterator.

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

type Item = (S, &'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?

pub fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S, B, H> PartialEq<StringInterner<S, B, H>> for StringInterner<S, B, H> where
    S: Symbol,
    B: Backend<S> + PartialEq,
    H: BuildHasher, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

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

Serialize this value into the given Serde serializer.