Struct Discriminant 

pub struct Discriminant { /* private fields */ }

Type describing the layout, alignment, and type of a container

Discriminant is central to the safety and performance of local pooling. It describes 2 things in just 8 bytes.

• The unique location in the source code of the implementation of IsoPoolable. This is accomplished by a proc macro that generates a global table of unique location ids for cross crate source code locations. This unique id ensures that different container types can’t be mixed in the same pool.

• The layout and alignment of all the type parameters of the container, up to 2 are supported. If your container has more that two type parameters then you can’t locally pool it, and you can’t implement IsoPoolable. If you do, you may caused UB.

In order to squeeze all this information into just 8 bytes there are some limitations.

• You can’t have more than 0xFFFF implementations of IsoPoolable in the same project. This includes all the crates depended on by the project.

• Your type parameters must have size <= 0x0FFF bytes and alignment <= 0xF.

• const SIZE parameters must be < 0xFFFF.

If any of these constraints are violated the Discriminant constructors will return None. If you desire you may panic at that point to cause a compile error. If you do not panic and instead leave DISCRIMINANT as None then local pool operations on that type will work just fine, but nothing will be pooled. Objects will be freed when they are dropped and take will allocate new objects each time it is called.

Implementations

impl Discriminant

pub const fn new(id: LocationId) -> Option<Discriminant>

build a discriminant for a type with no type variables (just a location id). Always returns Some

pub const fn new_p1<T>(id: LocationId) -> Option<Discriminant>

build a discriminant for a type with 1 type variable T. Return None if T is too large to fit.

pub const fn new_p1_size<T, const SIZE: usize>( id: LocationId, ) -> Option<Discriminant>

build a discriminant for a type with 1 type variable T and a const SIZE. Return None if T or SIZE are too large to fit.

pub const fn new_p2<T, U>(id: LocationId) -> Option<Discriminant>

build a discriminant for a type with two type variables T and U. Return None if either T or U are too large to fit

pub const fn new_p2_size<T, U, const SIZE: usize>( id: LocationId, ) -> Option<Discriminant>

build a discriminant for a type with two type variables T and U and a const SIZE. Return None if any of the parameters are too large to fit.

Trait Implementations

impl Clone for Discriminant

fn clone(&self) -> Discriminant

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Discriminant

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

Formats the value using the given formatter.

impl Hash for Discriminant

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 PartialEq for Discriminant

fn eq(&self, other: &Discriminant) -> 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 Copy for Discriminant

impl Eq for Discriminant

impl StructuralPartialEq for Discriminant