Struct internment::Intern

pub struct Intern<T> { /* fields omitted */ }

A pointer to an interned object.

The interned object will be held in memory indefinitely. On the plus side, this means that lifetime issues are simple when using Intern.

Example

use internment::Intern;

let x = Intern::new("hello");
let y = Intern::new("world");
assert_ne!(x, y);
assert_eq!(x, Intern::new("hello"));
assert_eq!(*x, "hello"); // dereference an Intern like a pointer

Methods

impl<T: Clone + Eq + Hash + Send + 'static> Intern<T>

fn new(val: T) -> Intern<T>

Intern a value. If this value has not previously been interned, then new will allocate a spot for the value on the heap. Otherwise, it will return a pointer to the object previously allocated.

Note that Intern::new is a bit slow, since it needs to check a HashMap protected by a Mutex.

fn num_objects_interned(&self) -> usize

See how many objects have been interned. This may be helpful in analyzing memory use.

Trait Implementations

impl<T> PartialEq for Intern<T>

fn eq(&self, other: &Intern<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<T> Eq for Intern<T>

impl<T> Clone for Intern<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Copy for Intern<T>

An Intern is Copy, which is unusal for a pointer. This is safe because we never free the data pointed to by an Intern.

impl<T> Send for Intern<T>

impl<T> Sync for Intern<T>

impl<T> Borrow<T> for Intern<T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T> AsRef<T> for Intern<T>

fn as_ref(&self) -> &T

Performs the conversion.

impl<T> Deref for Intern<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: Default + Hash + Eq + Clone + Send + 'static> Default for Intern<T>

fn default() -> Intern<T>

Returns the "default value" for a type.

impl<T: Debug> Debug for Intern<T>

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

Formats the value using the given formatter.

impl<T: Display> Display for Intern<T>

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

Formats the value using the given formatter.

impl<T> Pointer for Intern<T>

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

Formats the value using the given formatter.

impl<T: Debug> Fits64 for Intern<T>

unsafe fn from_u64(x: u64) -> Self

Convert back from a u64. This is unsafe, since it is only infallible (and lossless) if the u64 originally came from type Self.

fn to_u64(self) -> u64

Convert to a u64. This should be infallible.

fn test_fits64(self) -> bool

verify that the conversion is lossless

impl<T> Hash for Intern<T>

The hash implementation for Intern returns the hash of the pointer value, not the hash of the value pointed to. This should be irrelevant, since there is a unique pointer for every value, but it is observable, since you could compare the pointer of Intern::new(data) with data itself.

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].