Struct Compact

pub struct Compact<T: Compactable> { /* private fields */ }

Compact representation of T. Only one-pointer wide.

It behaves like T for Drop, Clone, Hash, Eq, Ord, …

Implementations

impl<T: Compactable> Compact<T>

pub fn as_raw_data(&self) -> *const u8

Returns the underlying raw data.

pub fn extract(self) -> T

Returns the original value.

pub fn map_ref<U>(&self, f: impl FnOnce(&T) -> U) -> U

Maps a &T to U by applying a function to a temporarily created T value.

Since the value is temporary, you cannot take references to it out from this function.

Examples

use enum_ptr::{Compact, EnumPtr};

#[derive(EnumPtr, Debug)]
#[repr(C, usize)]
enum Foo {
    A(Box<i32>),
    B(Box<u32>),
}

let mut foo: Compact<_> = Foo::A(Box::new(1)).into();
let result = foo.map_ref(|f| match f {
    Foo::A(r) => **r,
    _ => unreachable!(),
});
assert_eq!(result, 1);

pub unsafe fn map_mut<U>(&mut self, f: impl FnOnce(&mut T) -> U) -> U

Maps a &mut T to U by applying a function to a temporarily created T value.

Since the value is temporary, you cannot take references to it out from this function.

Safety

See issue #3.

Examples

use enum_ptr::{Compact, EnumPtr};

#[derive(EnumPtr, Debug, PartialEq, Eq)]
#[repr(C, usize)]
enum Foo {
    A(Box<i32>),
    B(Box<u32>),
}

let mut foo: Compact<_> = Foo::A(Box::new(1)).into();
unsafe {
    foo.map_mut(|f| match f {
        Foo::A(r) => **r = 2,
        _ => unreachable!(),
    });
}
assert_eq!(foo.extract(), Foo::A(Box::new(2)));

impl<T: CompactBorrow> Compact<T>

pub fn borrow(&self) -> <T as CompactBorrow>::Target<'_>

Returns a reference type that acts like &T.

Check EnumPtr for more details.

Examples

use enum_ptr::{Compact, EnumPtr};

#[derive(EnumPtr, Debug)]
#[enum_ptr(borrow)] // required
#[repr(C, usize)]
enum Foo {               // enum FooRef<'enum_ptr> {
    A(Box<i32>),         //     A(&'enum_ptr i32),
    B(Option<Box<u32>>), //     B(Option<&'enum_ptr u32>),
}                        // }

let foo: Compact<_> = Foo::A(Box::new(1)).into();
match foo.borrow() {
    FooRef::A(inner) => assert_eq!(inner, &1),
    _ => unreachable!(),
}

impl<T: CompactBorrowMut> Compact<T>

pub fn borrow_mut(&mut self) -> <T as CompactBorrowMut>::Target<'_>

Returns a reference type that acts like &mut T.

Check EnumPtr for more details.

Examples

use enum_ptr::{Compact, EnumPtr};

#[derive(EnumPtr, Debug)]
#[enum_ptr(borrow_mut)] // required
#[repr(C, usize)]
enum Foo {               // enum FooRefMut<'enum_ptr> {
    A(Box<i32>),         //     A(&'enum_ptr mut i32),
    B(Option<Box<u32>>), //     B(Option<&'enum_ptr mut u32>),
}                        // }

let mut foo: Compact<_> = Foo::A(Box::new(1)).into();
match foo.borrow_mut() {
    FooRefMut::A(inner) => assert_eq!(inner, &mut 1),
    _ => unreachable!(),
}

Trait Implementations

impl<T: Compactable> Clone for Compact<T>

where T::Inner: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Compactable + Debug> Debug for Compact<T>

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

Formats the value using the given formatter.

impl<T: Compactable + Default> Default for Compact<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Compactable + Hash> Hash for Compact<T>

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: Compactable + Ord> Ord for Compact<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: Compactable + PartialEq> PartialEq for Compact<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: Compactable + PartialOrd> PartialOrd for Compact<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: &Rhs) -> bool

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

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

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

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

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

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

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

impl<T: Compactable<Inner = CompactInnerCopy<T>> + Copy> Copy for Compact<T>

impl<T: Compactable + Eq> Eq for Compact<T>

impl<T: Compactable + Send> Send for Compact<T>

impl<T: Compactable + Sync> Sync for Compact<T>