Struct RodeoReader

pub struct RodeoReader<K = Spur, S = RandomState> { /* private fields */ }

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

The key and hasher types are the same as the Rodeo or ThreadedRodeo that created it, can be acquired with the into_reader methods.

Implementations

impl<K, S> RodeoReader<K, S>

pub fn get<T>(&self, val: T) -> Option<K>

where T: AsRef<str>, S: BuildHasher, K: Key,

Get the key value of a string, returning None if it doesn’t exist

Example

use lasso2::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_reader();
assert_eq!(Some(key), rodeo.get("Strings of things with wings and dings"));

assert_eq!(None, rodeo.get("This string isn't interned"));

pub fn contains<T>(&self, val: T) -> bool

where T: AsRef<str>, S: BuildHasher, K: Key,

Returns true if the given string has been interned

Example

use lasso2::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_reader();
assert!(rodeo.contains("Strings of things with wings and dings"));

assert!(!rodeo.contains("This string isn't interned"));

pub fn contains_key(&self, key: &K) -> bool

where K: Key,

Returns true if the given key exists in the current interner

Example

use lasso2::Rodeo;

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

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

pub fn resolve<'a>(&'a self, key: &K) -> &'a str

where K: Key,

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 lasso2::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,

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 lasso2::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,

Resolves a string by its key without bounds checks

Safety

The key must be valid for the current Reader

Example

use lasso2::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 len(&self) -> usize

Gets the number of interned strings

Example

use lasso2::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_reader();
assert_eq!(rodeo.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if there are no currently interned strings

Example

use lasso2::Rodeo;

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

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

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

Returns an iterator over the interned strings and their key values

pub fn strings(&self) -> Strings<'_, K>

Returns an iterator over the interned strings

pub fn into_resolver(self) -> RodeoResolver<K>

Consumes the current rodeo and makes it into a RodeoResolver, allowing contention-free access from multiple threads with the lowest possible memory consumption

Example

use lasso2::Rodeo;

// ThreadedRodeo is interchangeable for Rodeo here
let mut rodeo = Rodeo::default();
let key = rodeo.get_or_intern("Appear weak when you are strong, and strong when you are weak.");
let reader_rodeo = rodeo.into_reader();

let resolver_rodeo = reader_rodeo.into_resolver();
assert_eq!(
    "Appear weak when you are strong, and strong when you are weak.",
    resolver_rodeo.resolve(&key),
);

Trait Implementations

impl<K: Debug, S: Debug> Debug for RodeoReader<K, S>

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

Formats the value using the given formatter.

impl<'de, K: Key, S: BuildHasher + Default> Deserialize<'de> for RodeoReader<K, S>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, S> Index<K> for RodeoReader<K, S>

where K: Key, S: BuildHasher,

type Output = str

The returned type after indexing.

fn index(&self, idx: K) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, K: Key, S> IntoIterator for &'a RodeoReader<K, S>

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?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, S> IntoResolver<K> for RodeoReader<K, S>

where K: Key, S: BuildHasher,

type Resolver = RodeoResolver<K>

The type of Resolver the reader will be converted into

fn into_resolver(self) -> Self::Resolver

where Self: 'static,

Consumes the current Reader and makes it into a Resolver, allowing contention-free access from multiple threads with the lowest possible memory consumption

impl<K, S> PartialEq<Rodeo<K, S>> for RodeoReader<K, S>

fn eq(&self, other: &Rodeo<K, S>) -> bool

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

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

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

impl<K, S> PartialEq<RodeoReader<K, S>> for Rodeo<K, S>

fn eq(&self, other: &RodeoReader<K, S>) -> bool

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

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

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

impl<K, S> PartialEq<RodeoReader<K, S>> for RodeoResolver<K>

fn eq(&self, other: &RodeoReader<K, S>) -> bool

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

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

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

impl<K, S> PartialEq<RodeoReader<K, S>> for ThreadedRodeo<K, S>

where K: Eq + Hash + Key, S: Clone + BuildHasher,

fn eq(&self, other: &RodeoReader<K, S>) -> bool

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

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

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

impl<K, S> PartialEq<RodeoResolver<K>> for RodeoReader<K, S>

fn eq(&self, other: &RodeoResolver<K>) -> bool

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

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

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

impl<K, S> PartialEq for RodeoReader<K, S>

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

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

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

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

impl<K, S> Reader<K> for RodeoReader<K, S>

where K: Key, S: BuildHasher,

fn get(&self, val: &str) -> Option<K>

Get a key for the given string value if it exists

fn contains(&self, val: &str) -> bool

Returns true if the current interner contains the given string

impl<K, S> Resolver<K> for RodeoReader<K, S>

where K: Key,

fn resolve<'a>(&'a self, key: &K) -> &'a str

Resolves the given key into a string

fn try_resolve<'a>(&'a self, key: &K) -> Option<&'a str>

Attempts to resolve the given key into a string, returning None if it cannot be found

unsafe fn resolve_unchecked<'a>(&'a self, key: &K) -> &'a str

Resolves a string by its key without preforming bounds checks

fn contains_key(&self, key: &K) -> bool

Returns true if the current interner contains the given key

fn len(&self) -> usize

Gets the number of currently interned strings

fn is_empty(&self) -> bool

Returns true if there are no currently interned strings

impl<K, H> Serialize for RodeoReader<K, H>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, S> Eq for RodeoReader<K, S>

impl<K: Send, S: Send> Send for RodeoReader<K, S>

impl<K: Sync, S: Sync> Sync for RodeoReader<K, S>