Struct HashableRc 

pub struct HashableRc<T> { /* private fields */ }

A hashable wrapper around the Rc<T> type.

A hash of a HashableRc<T> is taken from the underlying pointer. Therefore, two separate objects that may be considered equal will, when contained in a HashableRc<T>, almost always have different hashed values. For example, the following holds:

use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use std::rc::Rc;

use hashable_rc::HashableRc;

fn hash<H: Hash>(value: &H) -> u64 {
    let mut state = DefaultHasher::new();
    value.hash(&mut state);
    state.finish()
}

// While the underlying values are considered equal, the hash values
// will be different, due to being separate allocated objects with 
// different underlying pointers.
let rc1 = Rc::new(42);
let rc2 = Rc::new(42);
 
// The hashes of the two reference countings are different.
assert_ne!(hash(&HashableRc::new(rc1.clone())), 
           hash(&HashableRc::new(rc2.clone())));

// Contrastingly, the hashes of clone reference countings pointing to 
// the same object are the equal.
assert_eq!(hash(&HashableRc::new(rc1.clone())), 
           hash(&HashableRc::new(rc1.clone())));

Similarly, equality of HashableRc<T> objects is done by evaluating pointer equality (using ptr_eq()). The equality is not from the value itself, but from the pointer.

use std::rc::Rc;

use hashable_rc::HashableRc;

// Again, the values contained are equal, but the underlying pointers
// are different.
let rc1 = Rc::new(42);
let rc2 = Rc::new(42);

// Therefore, two HashableRc wrappers containing these reference 
// counters are not equal.
assert_ne!(HashableRc::new(rc1.clone()),
           HashableRc::new(rc2.clone()));

// But HashableRc holding the same underlying object are equal.
assert_eq!(HashableRc::new(rc1.clone()),
           HashableRc::new(rc1.clone()));

Implementations

impl<T> HashableRc<T>

pub fn new(value: Rc<T>) -> Self

Constructs a new HashableRc<T> wrapping an Rc<T>.

pub fn get_cloned(&self) -> Rc<T>

Returns a clone of the wrapped Rc<T> without consuming self.

Trait Implementations

impl<T: Debug> Debug for HashableRc<T>

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

Formats the value using the given formatter.

impl<T> Hash for HashableRc<T>

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Generate a hash value for the HashableRc<T>.

This hash value is based on the underlying pointer. Two unique objects will most likely have different hashes, even if their values are the same.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq for HashableRc<T>

fn eq(&self, other: &Self) -> bool

Equality for two HashableRc<T> objects.

Equality is determined by pointer equality, rather than value equality. Objects are only considered equal if they point to the same object.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for HashableRc<T>