Struct string_interner::StringInterner

pub struct StringInterner<S = DefaultSymbol, B = DefaultBackend, H = DefaultHashBuilder> where
    S: Symbol,
    B: Backend<S>,
    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.

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,
    &'a B: IntoIterator<Item = (S, &'a str)>,
    H: BuildHasher + Default, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl Default for StringInterner<DefaultSymbol, DefaultBackend, DefaultHashBuilder>

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, 

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<'a, S, B, H, T> Extend<T> for StringInterner<S, B, H> where
    S: Symbol,
    B: Backend<S>,
    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<'a, S, B, H, T> FromIterator<T> for StringInterner<S, B, H> where
    S: Symbol,
    B: Backend<S>,
    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, 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?

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, 

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

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

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

This method tests for !=.

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

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, 

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

Serialize this value into the given Serde serializer.

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