Struct Interner

pub struct Interner<T, B = <T as DefaultBackendBuilder>::Backend, H = RandomState>
where
    T: Hash + Eq + PartialEq + ?Sized,
    H: BuildHasher,
    B: Backend<T>,
{ /* private fields */ }

Interner

This struct is responsible for tracking objects and interning them.

Example

use interns::*;

let mut interner = Interner::<str>::default();

let a = interner.get_or_intern("hello");
let b = interner.get_or_intern("world");
let c = interner.get_or_intern("hello");

let a_resolv = interner.resolve(a);
let b_resolv = interner.resolve(b);
let c_resolv = interner.resolve(c);

assert_eq!(a_resolv, Some("hello"));
assert_eq!(b_resolv, Some("world"));
assert_eq!(c_resolv, Some("hello"));

assert_eq!(a, c);
assert_ne!(a, b);
assert_ne!(b, c);

Implementations

impl<T, B, H> Interner<T, B, H>

where T: Hash + Eq + PartialEq + ?Sized, H: BuildHasher + Default, B: Backend<T>,

pub fn new() -> Self

where B: Default, H: Default,

Create a new Interner with a default backend and hasher

pub fn with_hasher(hasher: H) -> Self

where B: Default,

Create a new Interner with a default backend and the given hasher

pub fn with_backend(backend: B) -> Self

where H: Default,

Create a new Interner with a default hasher and the given backend

pub fn with_backend_and_hasher(backend: B, hasher: H) -> Self

Create a new Interner with the given backend and hasher

pub fn get_or_intern(&mut self, src: &T) -> B::Symbol

Turns a reference of T into the backend’s symbol

pub fn resolve(&self, sym: B::Symbol) -> Option<&T>

Resolves the symbol into a reference of T

pub fn len(&self) -> usize

Returns the number of elements currently interned

pub fn is_empty(&self) -> bool

Returns true if the interner contains no elements

pub fn capacity(&self) -> usize

Returns the capacity of the interner

Trait Implementations

impl<T, B> Default for Interner<T, B>

where T: Hash + Eq + PartialEq + ?Sized, B: Backend<T> + Default,

fn default() -> Self

Returns the “default value” for a type.