Struct Interner

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

An interner will keep track of strings and ensure there is only one allocation for any given string contents.

For example:

let mut interner = Interner::new();
let foo0 = interner.intern(String::from("foo"));
let foo1 = interner.intern(String::from("foo"));
assert!(InternedStr::ptr_eq(&foo0, &foo1));

Because foo0 and foo1 have the same contents, they become a single allocation.

Interned strings are immutable, which means that you must construct the finished string before interning it.

This is useful if you have many instances of the same strings (e.g., if 200 different structs contain the string "foo", an interner allows there to be 200 pointers to one allocation, rather than 200 different allocations).

This Interner is not thread-safe (which is to say, it is implements neither Send nor Sync). For a thread-safe variant, see the sync module.

Implementations

impl Interner

pub fn new() -> Self

Constructs a new Interner.

impl<S> Interner<S>

pub fn with_hasher(hasher: S) -> Self

Constructs a new Interner with the given hasher. See BuildHasher for more information.

pub fn from_set(strings: HashSet<InternedStr, S>) -> Self

Construct a new Interner with the given set’s contents already interned. The new Interner will also use the given set’s hasher.

pub fn into_set(self) -> HashSet<InternedStr, S>

Consume this Interner and return a set containing all of strings that were interned. The returned set also uses the same hasher.

pub fn clear(&mut self)

Removes all of the interned strings.

pub fn iter(&self) -> Iter<'_>

An iterator over all of the currently interned strings.

impl<S: BuildHasher> Interner<S>

pub fn intern(&mut self, string: impl AsRef<str>) -> InternedStr

Saves the given string if it is not already saved, and returns a reference the saved allocation.

pub fn contains(&self, string: impl AsRef<str>) -> bool

Returns whether the given string has already been saved.

pub fn get(&self, string: impl AsRef<str>) -> Option<InternedStr>

If the given string has already been saved, returns a reference to the saved allocation, or None otherwise.

Trait Implementations

impl<S: Clone> Clone for Interner<S>

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 for Interner<S>

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

Formats the value using the given formatter.

impl<S: Default> Default for Interner<S>

fn default() -> Self

Returns the “default value” for a type.

impl<A, S> FromIterator<A> for Interner<S>

where HashSet<InternedStr, S>: FromIterator<A>,

fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a, S> IntoIterator for &'a Interner<S>

type Item = &'a Rc<str>

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a>

Creates an iterator from a value.

impl<S> IntoIterator for Interner<S>

type Item = Rc<str>

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter

Creates an iterator from a value.

impl<S: BuildHasher> PartialEq for Interner<S>

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

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

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

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

impl<S: BuildHasher> Eq for Interner<S>