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.