Struct lasso::ThreadedRodeo

source ·
pub struct ThreadedRodeo<K = Spur, S = RandomState> { /* private fields */ }
Expand description

A concurrent string interner that caches strings quickly with a minimal memory footprint, returning a unique key to re-access it with O(1) internment and resolution.

This struct is only available with the multi-threaded feature! By default ThreadedRodeo uses the Spur type for keys and RandomState as the hasher

Implementations§

Create a new ThreadedRodeo

Example
use lasso::{ThreadedRodeo, Spur};
use std::{thread, sync::Arc};

let lasso: Arc<ThreadedRodeo<Spur>> = Arc::new(ThreadedRodeo::new());
let hello = lasso.get_or_intern("Hello, ");

let l = Arc::clone(&lasso);
let world = thread::spawn(move || {
    l.get_or_intern("World!")
})
.join()
.unwrap();

assert_eq!("Hello, ", lasso.resolve(&hello));
assert_eq!("World!", lasso.resolve(&world));

Create a new ThreadedRodeo with the specified capacity. The interner will be able to hold capacity strings without reallocating. If capacity is 0, the interner will not allocate.

See Capacity for more details

Example
use lasso::{ThreadedRodeo, Capacity, Spur};

let rodeo: ThreadedRodeo<Spur> = ThreadedRodeo::with_capacity(Capacity::for_strings(10));

Create a new ThreadedRodeo with the specified memory limits. The interner will be able to hold max_memory_usage bytes of interned strings until it will start returning None from try_get_or_intern or panicking from get_or_intern.

Note: If the capacity of the interner is greater than the memory limit, then that will be the effective maximum for allocated memory

See MemoryLimits for more information

Example
use lasso::{ThreadedRodeo, MemoryLimits, Spur};

let rodeo: ThreadedRodeo<Spur> = ThreadedRodeo::with_memory_limits(MemoryLimits::for_memory_usage(4096));

Create a new ThreadedRodeo with the specified capacity and memory limits. The interner will be able to hold max_memory_usage bytes of interned strings until it will start returning None from try_get_or_intern or panicking from get_or_intern.

Note: If the capacity of the interner is greater than the memory limit, then that will be the effective maximum for allocated memory

See Capacity MemoryLimits for more information

Example
use lasso::{ThreadedRodeo, MemoryLimits, Spur};

let rodeo: ThreadedRodeo<Spur> = ThreadedRodeo::with_memory_limits(MemoryLimits::for_memory_usage(4096));

Creates an empty ThreadedRodeo which will use the given hasher for its internal hashmap

Example
use lasso::{Spur, ThreadedRodeo};
use std::collections::hash_map::RandomState;

let rodeo: ThreadedRodeo<Spur, RandomState> = ThreadedRodeo::with_hasher(RandomState::new());

Creates a new ThreadedRodeo with the specified capacity that will use the given hasher for its internal hashmap

See Capacity for more details

Example
use lasso::{Spur, Capacity, ThreadedRodeo};
use std::collections::hash_map::RandomState;

let rodeo: ThreadedRodeo<Spur, RandomState> = ThreadedRodeo::with_capacity_and_hasher(Capacity::for_strings(10), RandomState::new());

Creates a new ThreadedRodeo with the specified capacity and memory limits that will use the given hasher for its internal hashmap

See Capacity and MemoryLimits for more information

Example
use lasso::{Spur, Capacity, MemoryLimits, ThreadedRodeo};
use std::collections::hash_map::RandomState;

let rodeo: ThreadedRodeo<Spur, RandomState> = ThreadedRodeo::with_capacity_memory_limits_and_hasher(
    Capacity::for_strings(10),
    MemoryLimits::for_memory_usage(4096),
    RandomState::new(),
);

Get the key for a string, interning it if it does not yet exist

Panics

Panics if the key’s try_from_usize function fails. With the default keys, this means that you’ve interned more strings than it can handle. (For Spur this means that u32::MAX - 1 unique strings were interned)

Example
use lasso::ThreadedRodeo;

let rodeo = ThreadedRodeo::default();

// Interned the string
let key = rodeo.get_or_intern("Strings of things with wings and dings");
assert_eq!("Strings of things with wings and dings", rodeo.resolve(&key));

// No string was interned, as it was already contained
let key = rodeo.get_or_intern("Strings of things with wings and dings");
assert_eq!("Strings of things with wings and dings", rodeo.resolve(&key));

Get the key for a string, interning it if it does not yet exist

Example
use lasso::ThreadedRodeo;

let rodeo = ThreadedRodeo::default();

// Interned the string
let key = rodeo.get_or_intern("Strings of things with wings and dings");
assert_eq!("Strings of things with wings and dings", rodeo.resolve(&key));

// No string was interned, as it was already contained
let key = rodeo.get_or_intern("Strings of things with wings and dings");
assert_eq!("Strings of things with wings and dings", rodeo.resolve(&key));

Get the key for a static string, interning it if it does not yet exist

This will not reallocate or copy the given string but will instead just store it

Panics

Panics if the key’s try_from_usize function fails. With the default keys, this means that you’ve interned more strings than it can handle. (For Spur this means that u32::MAX - 1 unique strings were interned)

Example
use lasso::ThreadedRodeo;

let mut rodeo = ThreadedRodeo::default();

// Interned the string
let key = rodeo.get_or_intern_static("Strings of things with wings and dings");
assert_eq!("Strings of things with wings and dings", rodeo.resolve(&key));

// No string was interned, as it was already contained
let key = rodeo.get_or_intern_static("Strings of things with wings and dings");
assert_eq!("Strings of things with wings and dings", rodeo.resolve(&key));

Get the key for a static string, interning it if it does not yet exist

This will not reallocate and copy the given string but will instead just store it

Example
use lasso::ThreadedRodeo;

let mut rodeo = ThreadedRodeo::default();

// Interned the string
let key = rodeo.try_get_or_intern_static("Strings of things with wings and dings").unwrap();
assert_eq!("Strings of things with wings and dings", rodeo.resolve(&key));

// No string was interned, as it was already contained
let key = rodeo.try_get_or_intern_static("Strings of things with wings and dings").unwrap();
assert_eq!("Strings of things with wings and dings", rodeo.resolve(&key));

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

Example
use lasso::ThreadedRodeo;

let rodeo = ThreadedRodeo::default();

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

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

Returns true if the given string has been interned

Example
use lasso::ThreadedRodeo;

let rodeo = ThreadedRodeo::default();

let key = rodeo.get_or_intern("Strings of things with wings and dings");
assert!(rodeo.contains("Strings of things with wings and dings"));

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

Returns true if the given key exists in the current interner

Example
use lasso::ThreadedRodeo;

let mut rodeo = ThreadedRodeo::default();

let key = rodeo.get_or_intern("Strings of things with wings and dings");
assert!(rodeo.contains_key(&key));

assert!(!rodeo.contains_key(&key_that_doesnt_exist));

Resolves a string by its key. Only keys made by the current ThreadedRodeo may be used

Panics

Panics if the key is out of bounds

Example
use lasso::ThreadedRodeo;

let rodeo = ThreadedRodeo::default();

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

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

Example
use lasso::ThreadedRodeo;

let rodeo = ThreadedRodeo::default();

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

Gets the number of interned strings

Example
use lasso::ThreadedRodeo;

let rodeo = ThreadedRodeo::default();
rodeo.get_or_intern("Documentation often has little hidden bits in it");

assert_eq!(rodeo.len(), 1);

Returns true if there are no currently interned strings

Example
use lasso::ThreadedRodeo;

let rodeo = ThreadedRodeo::default();
assert!(rodeo.is_empty());

Returns the number of strings that can be interned without a reallocation

This is an unreliable measurement since the underlying hashmap is unreliable in its capacity measurement

Example
use lasso::{Spur, Capacity, ThreadedRodeo};

let rodeo: ThreadedRodeo<Spur> = ThreadedRodeo::with_capacity(Capacity::for_strings(10));
assert_eq!(rodeo.capacity(), 10);

Returns an iterator over the interned strings and their key values

Returns an iterator over the interned strings

Set the ThreadedRodeo’s maximum memory usage while in-flight

Note that setting the maximum memory usage to below the currently allocated memory will do nothing

Get the ThreadedRodeo’s currently allocated memory

Get the ThreadedRodeo’s current maximum of allocated memory

Consumes the current ThreadedRodeo, returning a RodeoReader to allow contention-free access of the interner from multiple threads

Example
use lasso::ThreadedRodeo;

let rodeo = ThreadedRodeo::default();
let key = rodeo.get_or_intern("Appear weak when you are strong, and strong when you are weak.");

let rodeo_reader = rodeo.into_reader();
assert_eq!(
    "Appear weak when you are strong, and strong when you are weak.",
    rodeo_reader.resolve(&key),
);

Consumes the current ThreadedRodeo, returning a RodeoResolver to allow contention-free access of the interner from multiple threads with the lowest possible memory consumption

Example
use lasso::ThreadedRodeo;

let rodeo = ThreadedRodeo::default();
let key = rodeo.get_or_intern("Appear weak when you are strong, and strong when you are weak.");

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

Trait Implementations§

Formats the value using the given formatter. Read more

Creates a ThreadedRodeo using Spur as its key and RandomState as its hasher

Returns the “default value” for a type. Read more
Extends a collection with the contents of an iterator. Read more
🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more
Creates a value from an iterator. Read more
The returned type after indexing.
Performs the indexing (container[index]) operation. Read more
Get the key for a string, interning it if it does not yet exist Read more
Get the key for a string, interning it if it does not yet exist
Get the key for a static string, interning it if it does not yet exist Read more
Get the key for a static string, interning it if it does not yet exist Read more
Get the key for a string, interning it if it does not yet exist Read more
Get the key for a string, interning it if it does not yet exist
Get the key for a static string, interning it if it does not yet exist Read more
Get the key for a static string, interning it if it does not yet exist Read more
The type of Reader the interner will be converted into
Consumes the current Interner and converts it into a Reader to allow contention-free access of the interner from multiple threads
The type of Resolver the reader will be converted into
Consumes the current Reader and makes it into a Resolver, allowing contention-free access from multiple threads with the lowest possible memory consumption
This method tests for self and other values to be equal, and is used by ==.
This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
This method tests for self and other values to be equal, and is used by ==.
This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
This method tests for self and other values to be equal, and is used by ==.
This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
This method tests for self and other values to be equal, and is used by ==.
This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Get a key for the given string value if it exists
Returns true if the current interner contains the given string
Get a key for the given string value if it exists
Returns true if the current interner contains the given string
Resolves the given key into a string Read more
Attempts to resolve the given key into a string, returning None if it cannot be found
Resolves a string by its key without preforming bounds checks Read more
Returns true if the current interner contains the given key
Gets the number of currently interned strings
Returns true if there are no currently interned strings

ThreadedRodeo does not actually have a resolve_unchecked() method, so this just forwards to the normal ThreadedRodeo::resolve() method

Resolves the given key into a string Read more
Attempts to resolve the given key into a string, returning None if it cannot be found
Returns true if the current interner contains the given key
Gets the number of currently interned strings
Returns true if there are no currently interned strings

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.