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 benchmarking_only_clear_interns()

Only for benchmarking, this will cause problems

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: 'static + ?Sized> DeepSizeOf for Intern<T>

fn deep_size_of_children(&self, _context: &mut Context) -> usize

Returns an estimation of the heap-managed storage of this object. This does not include the size of the object itself.

fn deep_size_of(&self) -> usize

Returns an estimation of a total size of memory owned by the object, including heap-managed storage.

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>

Available on crate feature serde only.

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

Available on crate feature tinyset only.

The Fits64 implementation for Intern<T> is designed to normally give (relatively) small numbers, by XORing with a fixed pointer that is also on the heap. The pointer is also divided by its alignment to eliminate those redundant insignificant zeros. This should make the most significant bits of the resulting u64 be zero, which will mean that Set64 (which is space-efficient in storing small integers) can store this result in far fewer than 8 bytes.

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.

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>

Available on crate feature serde only.

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>