Struct enum_ptr::Compact

source ·

#[repr(transparent)]
pub struct Compact<T>where
    T: From<Compact<T>>,
    Compact<T>: From<T>,{ /* private fields */ }

Expand description

Compact representation of T. Only one-pointer wide.

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

Implementations§

source §

impl<T> Compact<T>where T: From<Compact<T>>, Compact<T>: From<T>,

source

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

Returns the underlying raw data.

source

pub fn extract(self) -> T

Alias of T::from(self).

source

pub fn map_ref(&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);

source

pub unsafe fn map_mut(&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)));

source §

impl<T> Compact<T>where T: From<Compact<T>> + CompactBorrow, Compact<T>: From<T>,

source

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!(),
}

source §

impl<T> Compact<T>where T: From<Compact<T>> + CompactBorrowMut, Compact<T>: From<T>,

source

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!(),
}