[][src]Crate hashable_rc

Hashable wrappers for reference countings.

Provides hashable wrappers for Rc<T> and Weak<T> references with the types HashableRc<T> and HashableWeak<T>, respectively. This allows use of both strong and weak reference countings in hash-based data structures, such as HashMap or HashSet.

Quick Start

The most common use cases are wrapping Rc<T> or Weak<T> in HashableRc<T> or HashableWeak<T> respectively to be contained in a hash-based container. An example of using both types as keys in a HashMap follows.

use std::collections::HashMap;
use std::rc::{Rc, Weak};

use hashable_rc::{HashableRc, HashableWeak};

// Create a strong reference counting for an object.
let rc: Rc<u32> = Rc::new(42);

// Use the strong reference as a key for a HashMap.
let mut strong_map = HashMap::new();
strong_map.insert(HashableRc::new(rc.clone()), "foo");
assert_eq!(strong_map[&HashableRc::new(rc.clone())], "foo");

// Create a weak reference counting for the same object as above.
let weak: Weak<u32> = Rc::downgrade(&rc);

// Use the weak reference as a key for a HashMap.
let mut weak_map = HashMap::new();
weak_map.insert(HashableWeak::new(weak.clone()), "bar");
assert_eq!(weak_map[&HashableWeak::new(weak.clone())], "bar");

Insertion into other hash-based containers (such as a HashSet) follows similarly.



A hashable wrapper around the Rc<T> type.


A hashable wrapper around the Weak<T> type.