Struct Intern

pub struct Intern<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: Eq + Hash + Send + Sync + 'static> Intern<T>

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: ?Sized + Eq + Hash + 'a>(val: &'a Q) -> Intern<T>

where 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: Eq + Hash + Send + Sync + 'static + ?Sized> Intern<T>

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: ?Sized + Eq + Hash + 'a>(val: &'a Q) -> bool

where 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<Path>

fn as_ref(&self) -> &OsStr

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

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<Path> for Intern<OsStr>

fn as_ref(&self) -> &Path

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<T: ?Sized> AsRef<T> for Intern<T>

fn as_ref(&self) -> &T

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

impl<T: ?Sized> 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: Debug + ?Sized> Debug for Intern<T>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<T: Eq + Hash + Send + Sync + ?Sized> Deref for Intern<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

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

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

Deserialize this value from the given Serde deserializer.

impl<T: Eq + Hash + Send + Sync + Display + ?Sized> Display for Intern<T>

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

Formats the value using the given formatter.

impl<T: Eq + Hash + Send + Sync + 'static + Copy> From<&[T]> for Intern<[T]>

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

Converts to this type from the input type.

impl<T: Eq + Hash + Send + Sync + 'static + Copy, const N: usize> From<&[T; N]> for Intern<[T]>

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

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

impl From<&CStr> for Intern<CStr>

fn from(val: &CStr) -> Self

Converts to this type from the input type.

impl From<&Path> for Intern<Path>

fn from(val: &Path) -> Self

Converts to this type from the input type.

impl From<&str> for Intern<str>

fn from(val: &str) -> Self

Converts to this type from the input type.

impl<T: Eq + Hash + Send + Sync + 'static + ?Sized> From<Box<T>> for Intern<T>

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

Converts to this type from the input type.

impl<T: Eq + Hash + Send + Sync + 'static> From<T> for Intern<T>

fn from(t: T) -> Self

Converts to this type from the input type.

impl<T: Eq + Hash + Send + Sync + ?Sized> Hash for Intern<T>

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: Hasher>(&self, state: &mut H)

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: Eq + Hash + Send + Sync + Ord + ?Sized> Ord for Intern<T>

fn cmp(&self, other: &Self) -> 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: Eq + Hash + Send + Sync + ?Sized> PartialEq for Intern<T>

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

Tests for self and other values to be equal, and is used by ==.

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 + Hash + Send + Sync + PartialOrd + ?Sized> PartialOrd for Intern<T>

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

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

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

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

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

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

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

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

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

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

impl<T: Eq + Hash + Send + Sync + ?Sized> Pointer for Intern<T>

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

Formats the value using the given formatter.

impl<T: Eq + Hash + Send + Sync + Serialize + ?Sized> Serialize for Intern<T>

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

Serialize this value into the given Serde serializer.

impl<T: ?Sized> 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: Eq + Hash + Send + Sync + ?Sized> Eq for Intern<T>