Struct lasso::ReadOnlyLasso

pub struct ReadOnlyLasso<K: Key = Cord, S: BuildHasher + Clone = RandomState> { /* fields omitted */ }

A read-only view of a Lasso that allows contention-free access to interned strings

Made with the Lasso::into_read_only method, the key and hasher types default to the ones used by the Lasso that created it

Methods

impl<K: Key, S: BuildHasher + Clone> ReadOnlyLasso<K, S>

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

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

Example

use lasso::{Cord, Lasso};

let lasso = Lasso::default();
let key = lasso.intern("Strings of things with wings and dings");

let lasso = lasso.into_read_only();
assert_eq!(Some(key), lasso.get("Strings of things with wings and dings"));

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

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

Resolves a string by its key

Safety

Safety relies on the given Key's adherence to symmetry, if the key gives bad indexes then it will cause UB.
With that in mind, never use any key not directly provided by the interner

Example

use lasso::{Cord, Key, Lasso};

let lasso = Lasso::default();
let key = lasso.intern("Strings of things with wings and dings");

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

pub fn len(&self) -> usize

Gets the number of interned strings

Example

use lasso::Lasso;

let lasso = Lasso::default();
lasso.intern("Documentation often has little hidden bits in it");

let lasso = lasso.into_read_only();
assert_eq!(lasso.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if there are no currently interned strings

Example

use lasso::Lasso;

let lasso = Lasso::default();

let lasso = lasso.into_read_only();
assert!(lasso.is_empty());

#[must_use]pub fn into_resolver(self) -> ResolverLasso<K>

Consumes the current ReadOnlyLasso, making it into a ResolverLasso, allowing contention-free access from multiple threads with the lowest possible memory consumption

Example

use lasso::Lasso;

let lasso = Lasso::default();
let key = lasso.intern("Appear weak when you are strong, and strong when you are weak.");
let read_only_lasso = lasso.into_read_only();

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

Trait Implementations

impl<K, S> Clone for ReadOnlyLasso<K, S> where
    K: Key,
    S: BuildHasher + Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug + Key, S: Debug + BuildHasher + Clone> Debug for ReadOnlyLasso<K, S>

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

Formats the value using the given formatter.

impl<K: Key, S: BuildHasher + Clone> Drop for ReadOnlyLasso<K, S>

Deallocate the leaked strings interned by ReadOnlyLasso

fn drop(&mut self)

Executes the destructor for this type.

impl<K: Key, S: BuildHasher + Clone> Send for ReadOnlyLasso<K, S>

impl<K: Key, S: BuildHasher + Clone> Sync for ReadOnlyLasso<K, S>