Struct Intern 

pub struct Intern<T>
where
    T: 'static + ?Sized,
{ /* private fields */ }

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

Example with owned String data

use internment::Intern;

let x = Intern::new("hello".to_string());
let y = Intern::<String>::from_ref("world");
assert_ne!(x, y);
assert_eq!(x, Intern::from_ref("hello"));
assert_eq!(y, Intern::from_ref("world"));
assert_eq!(&*x, "hello"); // dereference a Intern like a pointer

Implementations

impl<T> Intern<T>

where T: Eq + Hash + Send + Sync + 'static,

pub 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 HashSet protected by a Mutex.

pub fn from_ref<'a, Q>(val: &'a Q) -> Intern<T>

where Q: Eq + Hash + 'a + ?Sized, T: Borrow<Q> + From<&'a Q>,

Intern a value from a reference.

If this value has not previously been interned, then new will allocate a spot for the value on the heap and generate that value using T::from(val).

impl<T> Intern<T>

where T: Eq + Hash + Send + Sync + 'static + ?Sized,

pub fn as_ref(self) -> &'static T

Get a long-lived reference to the data pointed to by an Intern, which is never freed from the intern pool.

pub fn num_objects_interned() -> usize

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

pub fn is_interned<'a, Q>(val: &'a Q) -> bool

where Q: Eq + Hash + 'a + ?Sized, T: Borrow<Q>,

Check if a value already is interned.

If this value has previously been interned, return true, else returns false/// Checking if an object is already interned

 
use internment::Intern;

assert!(!Intern::<String>::is_interned("Fortunato"));
let x = Intern::new("Fortunato".to_string());
assert!(Intern::<String>::is_interned("Fortunato"));

assert!(!Intern::<str>::is_interned("Fortunato"));
let x: Intern<str> = "Fortunato".into();
assert!(Intern::<str>::is_interned("Fortunato"));

Trait Implementations

impl AsRef<OsStr> for Intern<str>

fn as_ref(&self) -> &OsStr

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<OsStr> for Intern<Path>

fn as_ref(&self) -> &OsStr

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Path> for Intern<str>

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Path> for Intern<OsStr>

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

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

where T: ?Sized,

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Clone for Intern<T>

where T: ?Sized,

fn clone(&self) -> Intern<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for Intern<T>

where T: ?Sized,

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> Debug for Intern<T>

where T: Debug + ?Sized,

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

Formats the value using the given formatter.

impl<T> Default for Intern<T>

where T: Eq + Hash + Send + Sync + Default + 'static,

fn default() -> Intern<T>

Returns the “default value” for a type.

impl<T> Deref for Intern<T>

where T: Eq + Hash + Send + Sync + ?Sized,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<'de, T> Deserialize<'de> for Intern<T>

where T: Eq + Hash + Send + Sync + 'static + Deserialize<'de> + ?Sized,

Available on crate feature serde only.

fn deserialize<D>( deserializer: D, ) -> Result<Intern<T>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for Intern<T>

where T: Eq + Hash + Send + Sync + Display + ?Sized,

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

Formats the value using the given formatter.

impl<T> Eq for Intern<T>

where T: Eq + Hash + Send + Sync + ?Sized,

impl From<&CStr> for Intern<CStr>

fn from(val: &CStr) -> Intern<CStr>

Converts to this type from the input type.

impl From<&Path> for Intern<Path>

fn from(val: &Path) -> Intern<Path>

Converts to this type from the input type.

impl<T, const N: usize> From<&[T; N]> for Intern<[T]>

where T: Eq + Hash + Send + Sync + 'static + Copy,

fn from(val: &[T; N]) -> Intern<[T]>

Converts a [T; N] into a Intern<[T]>

impl<T> From<&[T]> for Intern<[T]>

where T: Eq + Hash + Send + Sync + 'static + Copy,

fn from(val: &[T]) -> Intern<[T]>

Converts to this type from the input type.

impl From<&str> for Intern<str>

fn from(val: &str) -> Intern<str>

Converts to this type from the input type.

impl<T> From<Box<T>> for Intern<T>

where T: Eq + Hash + Send + Sync + 'static + ?Sized,

fn from(val: Box<T>) -> Intern<T>

Converts to this type from the input type.

impl<T> From<T> for Intern<T>

where T: Eq + Hash + Send + Sync + 'static,

fn from(t: T) -> Intern<T>

Converts to this type from the input type.

impl<T> Hash for Intern<T>

where T: Eq + Hash + Send + Sync + ?Sized,

The hash implementation 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 hash of the pointer with hash of the data itself.

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

where H: Hasher,

Feeds this value into the given Hasher.

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> Ord for Intern<T>

where T: Eq + Hash + Send + Sync + Ord + ?Sized,

fn cmp(&self, other: &Intern<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for Intern<T>

where T: Eq + Hash + Send + Sync + ?Sized,

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

Equality operator ==.

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

Inequality operator !=.

impl<T> PartialOrd for Intern<T>

where T: Eq + Hash + Send + Sync + PartialOrd + ?Sized,

fn partial_cmp(&self, other: &Intern<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Pointer for Intern<T>

where T: Eq + Hash + Send + Sync + ?Sized,

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

Formats the value using the given formatter.

impl<T> Serialize for Intern<T>

where T: Eq + Hash + Send + Sync + Serialize + ?Sized,

Available on crate feature serde only.

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: TypeHash + ?Sized> TypeHash for Intern<T>

fn write_hash(hasher: &mut impl Hasher)

Write the structure of the type to the hasher

fn type_hash() -> u64

Generate a stable hash of the type structure.