Struct lasso::RodeoResolver[−][src]

pub struct RodeoResolver<K = Spur> { /* fields omitted */ }

Expand description

A read-only view of a Rodeo or ThreadedRodeo that allows contention-free access to interned strings with only key to string resolution

The key type is the same as the Rodeo or ThreadedRodeo that created it

Implementations

`impl<K> RodeoResolver<K>`[src]

`pub fn resolve<'a>(&'a self, key: &K) -> &'a str where K: Key,` [src]

Resolves a string by its key. Only keys made by the current Resolver or the creator of the current Resolver may be used

Panics

Panics if the key is out of bounds

Example

use lasso::Rodeo;

// ThreadedRodeo is interchangeable for Rodeo here
let mut rodeo = Rodeo::default();
let key = rodeo.get_or_intern("Strings of things with wings and dings");

let rodeo = rodeo.into_resolver();
assert_eq!("Strings of things with wings and dings", rodeo.resolve(&key));

`pub fn try_resolve<'a>(&'a self, key: &K) -> Option<&'a str> where K: Key,` [src]

Resolves a string by its key, returning None if the key is out of bounds. Only keys made by the current Resolver or the creator of the current Resolver may be used

Example

use lasso::Rodeo;

// ThreadedRodeo is interchangeable for Rodeo here
let mut rodeo = Rodeo::default();
let key = rodeo.get_or_intern("Strings of things with wings and dings");

let rodeo = rodeo.into_resolver();
assert_eq!(Some("Strings of things with wings and dings"), rodeo.try_resolve(&key));

`pub unsafe fn resolve_unchecked<'a>(&'a self, key: &K) -> &'a str where K: Key,` [src]

Resolves a string by its key without preforming bounds checks

Safety

The key must be valid for the current interner

Example

use lasso::Rodeo;

// ThreadedRodeo is interchangeable for Rodeo here
let mut rodeo = Rodeo::default();
let key = rodeo.get_or_intern("Strings of things with wings and dings");

let rodeo = rodeo.into_resolver();
unsafe {
    assert_eq!("Strings of things with wings and dings", rodeo.resolve_unchecked(&key));
}

`pub fn contains_key(&self, key: &K) -> bool where K: Key,` [src]

Returns true if the given key exists in the current interner

Example

use lasso::Rodeo;

let mut rodeo = Rodeo::default();
let key = rodeo.get_or_intern("Strings of things with wings and dings");

let rodeo = rodeo.into_resolver();
assert!(rodeo.contains_key(&key));
assert!(!rodeo.contains_key(&key_that_doesnt_exist));

`pub fn len(&self) -> usize`[src]

Gets the number of interned strings

Example

use lasso::Rodeo;

// ThreadedRodeo is interchangeable for Rodeo here
let mut rodeo = Rodeo::default();
rodeo.get_or_intern("Documentation often has little hidden bits in it");

let rodeo = rodeo.into_resolver();
assert_eq!(rodeo.len(), 1);

`pub fn is_empty(&self) -> bool`[src]

Returns true if there are no currently interned strings

Example

use lasso::Rodeo;

// ThreadedRodeo is interchangeable for Rodeo here
let rodeo = Rodeo::default();

let rodeo = rodeo.into_resolver();
assert!(rodeo.is_empty());

`pub fn iter(&self) -> Iter<'_, K>ⓘNotable traits for Iter<'a, K> impl<'a, K> Iterator for Iter<'a, K> where K: Key, type Item = (K, &'a str);`[src]

Returns an iterator over the interned strings and their key values

`pub fn strings(&self) -> Strings<'_, K>ⓘNotable traits for Strings<'a, K> impl<'a, K> Iterator for Strings<'a, K> type Item = &'a str;`[src]

Returns an iterator over the interned strings

Trait Implementations

`impl<K: Debug> Debug for RodeoResolver<K>`[src]

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

Formats the value using the given formatter. Read more

`impl<'de, K: Key> Deserialize<'de> for RodeoResolver<K>`[src]

`fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,` [src]

Deserialize this value from the given Serde deserializer. Read more

`impl<K: Key> Index<K> for RodeoResolver<K>`[src]

`type Output = str`

The returned type after indexing.

`fn index(&self, idx: K) -> &Self::Output`[src]

Performs the indexing (container[index]) operation. Read more

`impl<'a, K: Key> IntoIterator for &'a RodeoResolver<K>`[src]

`type Item = (K, &'a str)`

The type of the elements being iterated over.

`type IntoIter = Iter<'a, K>`

Which kind of iterator are we turning this into?