Struct elsa::index_set::FrozenIndexSet

pub struct FrozenIndexSet<T, S = RandomState> { /* private fields */ }

Append-only version of indexmap::IndexSet where insertion does not require mutable access

Implementations

impl<T: Eq + Hash> FrozenIndexSet<T>

pub fn new() -> Self

Examples found in repository

examples/string_interner.rs (line 13)

    fn new() -> Self {
        StringInterner {
            set: FrozenIndexSet::new(),
        }
    }

impl<T: Eq + Hash + StableDeref, S: BuildHasher> FrozenIndexSet<T, S>

pub fn insert(&self, value: T) -> &T::Target

If the value exists in the set, returns a reference to the corresponding value, otherwise inserts a new entry in the set for that value and returns a reference to it.

Existing values are never overwritten.

Example

use elsa::index_set::FrozenIndexSet;
let set = FrozenIndexSet::new();
let a_ref = set.insert(Box::new("a"));
let aa = "a";
let other_a_ref = unsafe { aa.as_ptr() as *const &str};
let other_a = Box::new(aa);
assert!(!std::ptr::eq(a_ref, other_a_ref));
assert!(std::ptr::eq(a_ref, set.insert(other_a)));

pub fn insert_full(&self, value: T) -> (usize, &T::Target)

If the key exists in the set, returns a reference to the corresponding value and its index, otherwise inserts a new entry in the set for that value and returns a reference to it and its index.

Existing values are never overwritten.

Example

use elsa::index_set::FrozenIndexSet;
let map = FrozenIndexSet::new();
assert_eq!(map.insert_full(Box::new("a")), (0, &"a"));
assert_eq!(map.insert_full(Box::new("b")), (1, &"b"));

Examples found in repository

examples/string_interner.rs (line 23)

    fn get_or_intern<T>(&self, value: T) -> usize
    where
        T: AsRef<str>,
    {
        // TODO use Entry in case the standard Entry API gets improved
        // (here to avoid premature allocation or double lookup)
        self.set.insert_full(value.as_ref().to_string()).0
    }

pub fn get<Q>(&self, k: &Q) -> Option<&T::Target>

where T: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a reference to the value passed as argument if present in the set.

Examples

use elsa::index_set::FrozenIndexSet;

let set = FrozenIndexSet::new();
set.insert(Box::new("a"));
assert_eq!(set.get(&Box::new("a")), Some(&"a"));
assert_eq!(set.get(&Box::new("b")), None);

pub fn get_full<Q>(&self, k: &Q) -> Option<(usize, &T::Target)>

where T: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a reference to the value passed as argument if present in the set, along with its index

Examples

use elsa::index_set::FrozenIndexSet;

let set = FrozenIndexSet::new();
set.insert(Box::new("a"));
assert_eq!(set.get_full(&Box::new("a")), Some((0, &"a")));
assert_eq!(set.get_full(&Box::new("b")), None);

Examples found in repository

examples/string_interner.rs (line 30)

    fn get<T>(&self, value: T) -> Option<usize>
    where
        T: AsRef<str>,
    {
        self.set.get_full(value.as_ref()).map(|(i, _r)| i)
    }

pub fn get_index(&self, index: usize) -> Option<&T::Target>

Returns a reference to value at the index passed as argument, if present in the set.

Examples

use elsa::index_set::FrozenIndexSet;

let set = FrozenIndexSet::new();
set.insert(Box::new("a"));
assert_eq!(set.get_index(0), Some(&"a"));
assert_eq!(set.get_index(1), None);

Examples found in repository

examples/string_interner.rs (line 34)

    fn resolve(&self, index: usize) -> Option<&str> {
        self.set.get_index(index)
    }

impl<T, S> FrozenIndexSet<T, S>

pub fn into_set(self) -> IndexSet<T, S>

pub fn as_mut(&mut self) -> &mut IndexSet<T, S>

Get mutable access to the underlying IndexSet.

This is safe, as it requires a &mut self, ensuring nothing is using the ‘frozen’ contents.

Trait Implementations

impl<K: Clone, V: Clone> Clone for FrozenIndexSet<K, V>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Eq + Hash, S: Default> Default for FrozenIndexSet<T, S>

fn default() -> Self

Returns the “default value” for a type.

impl<T, S> From<IndexSet<T, S>> for FrozenIndexSet<T, S>

fn from(set: IndexSet<T, S>) -> Self

Converts to this type from the input type.

impl<T: Eq + Hash, S: Default + BuildHasher> FromIterator<T> for FrozenIndexSet<T, S>

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

where U: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<T: Eq + Hash + StableDeref, S> Index<usize> for FrozenIndexSet<T, S>

type Output = <T as Deref>::Target

The returned type after indexing.

fn index(&self, idx: usize) -> &T::Target

Performs the indexing (container[index]) operation.

impl<T: Hash + Eq, S: BuildHasher> PartialEq for FrozenIndexSet<T, S>

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

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

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

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