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 = Rc::new(42);

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

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

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

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