Trait TaggableValue

pub unsafe trait TaggableValue<TM, Count: TagOptions> {
    // Required methods
    fn untag(v: TagWrapper<Self, TM>) -> Self;
    fn untag_in_place(v: &mut TagWrapper<Self, TM>);
    fn get_tag(v: &TagWrapper<Self, TM>) -> Count;
    fn tag(v: Self, o: Count) -> TagWrapper<Self, TM>;
    fn tag_in_place(v: &mut TagWrapper<Self, TM>, o: Count);
    fn change_tag(v: &mut TagWrapper<Self, TM>, o: Count);
    unsafe fn uninitialized_from_tag(o: Count) -> TagWrapper<Self, TM>;
    fn fmt_untagged(v: &TagWrapper<Self, TM>, f: &mut Formatter<'_>) -> Result
       where Self: Debug;
    fn eq(a: &TagWrapper<Self, TM>, b: &TagWrapper<Self, TM>) -> bool
       where Self: PartialEq;
    fn ne(a: &TagWrapper<Self, TM>, b: &TagWrapper<Self, TM>) -> bool
       where Self: PartialEq;
}

A trait representing a value which can have some space dedicated to use for tagging a union If you implement this trait incorrectly, you will break memory safety.

Required Methods

fn untag(v: TagWrapper<Self, TM>) -> Self

Untags a value and returns it

fn untag_in_place(v: &mut TagWrapper<Self, TM>)

Untags a value in place

fn get_tag(v: &TagWrapper<Self, TM>) -> Count

Gets the tag associated with a value

fn tag(v: Self, o: Count) -> TagWrapper<Self, TM>

Tag a value and return it

fn tag_in_place(v: &mut TagWrapper<Self, TM>, o: Count)

Tag a value in place

fn change_tag(v: &mut TagWrapper<Self, TM>, o: Count)

Change the tag on an already tagged value

unsafe fn uninitialized_from_tag(o: Count) -> TagWrapper<Self, TM>

Return a tagged (but otherwise uninitialized) value

fn fmt_untagged(v: &TagWrapper<Self, TM>, f: &mut Formatter<'_>) -> Result

where Self: Debug,

A helper debug printing a value as though it weren’t tagged

fn eq(a: &TagWrapper<Self, TM>, b: &TagWrapper<Self, TM>) -> bool

where Self: PartialEq,

A helper testing equality between tagged items

fn ne(a: &TagWrapper<Self, TM>, b: &TagWrapper<Self, TM>) -> bool

where Self: PartialEq,

A helper testing inequality between tagged items

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl TaggableValue<TagMSB, Two> for u8

fn untag(v: TagWrapper<u8, TagMSB>) -> u8

fn untag_in_place(v: &mut TagWrapper<u8, TagMSB>)

fn get_tag(v: &TagWrapper<u8, TagMSB>) -> Two

fn tag(v: Self, o: Two) -> TagWrapper<u8, TagMSB>

fn tag_in_place(v: &mut TagWrapper<u8, TagMSB>, o: Two)

fn change_tag(v: &mut TagWrapper<u8, TagMSB>, o: Two)

unsafe fn uninitialized_from_tag(o: Two) -> TagWrapper<u8, TagMSB>

fn fmt_untagged(v: &TagWrapper<u8, TagMSB>, f: &mut Formatter<'_>) -> Result

fn eq(a: &TagWrapper<u8, TagMSB>, b: &TagWrapper<u8, TagMSB>) -> bool

fn ne(a: &TagWrapper<u8, TagMSB>, b: &TagWrapper<u8, TagMSB>) -> bool

impl TaggableValue<TagMSB, Two> for u16

fn untag(v: TagWrapper<u16, TagMSB>) -> u16

fn untag_in_place(v: &mut TagWrapper<u16, TagMSB>)

fn get_tag(v: &TagWrapper<u16, TagMSB>) -> Two

fn tag(v: Self, o: Two) -> TagWrapper<u16, TagMSB>

fn tag_in_place(v: &mut TagWrapper<u16, TagMSB>, o: Two)

fn change_tag(v: &mut TagWrapper<u16, TagMSB>, o: Two)

unsafe fn uninitialized_from_tag(o: Two) -> TagWrapper<u16, TagMSB>

fn fmt_untagged(v: &TagWrapper<u16, TagMSB>, f: &mut Formatter<'_>) -> Result

fn eq(a: &TagWrapper<u16, TagMSB>, b: &TagWrapper<u16, TagMSB>) -> bool

fn ne(a: &TagWrapper<u16, TagMSB>, b: &TagWrapper<u16, TagMSB>) -> bool

impl TaggableValue<TagMSB, Two> for u32

fn untag(v: TagWrapper<u32, TagMSB>) -> u32

fn untag_in_place(v: &mut TagWrapper<u32, TagMSB>)

fn get_tag(v: &TagWrapper<u32, TagMSB>) -> Two

fn tag(v: Self, o: Two) -> TagWrapper<u32, TagMSB>

fn tag_in_place(v: &mut TagWrapper<u32, TagMSB>, o: Two)

fn change_tag(v: &mut TagWrapper<u32, TagMSB>, o: Two)

unsafe fn uninitialized_from_tag(o: Two) -> TagWrapper<u32, TagMSB>

fn fmt_untagged(v: &TagWrapper<u32, TagMSB>, f: &mut Formatter<'_>) -> Result

fn eq(a: &TagWrapper<u32, TagMSB>, b: &TagWrapper<u32, TagMSB>) -> bool

fn ne(a: &TagWrapper<u32, TagMSB>, b: &TagWrapper<u32, TagMSB>) -> bool

impl TaggableValue<TagMSB, Two> for u64

fn untag(v: TagWrapper<u64, TagMSB>) -> u64

fn untag_in_place(v: &mut TagWrapper<u64, TagMSB>)

fn get_tag(v: &TagWrapper<u64, TagMSB>) -> Two

fn tag(v: Self, o: Two) -> TagWrapper<u64, TagMSB>

fn tag_in_place(v: &mut TagWrapper<u64, TagMSB>, o: Two)

fn change_tag(v: &mut TagWrapper<u64, TagMSB>, o: Two)

unsafe fn uninitialized_from_tag(o: Two) -> TagWrapper<u64, TagMSB>

fn fmt_untagged(v: &TagWrapper<u64, TagMSB>, f: &mut Formatter<'_>) -> Result

fn eq(a: &TagWrapper<u64, TagMSB>, b: &TagWrapper<u64, TagMSB>) -> bool

fn ne(a: &TagWrapper<u64, TagMSB>, b: &TagWrapper<u64, TagMSB>) -> bool

impl TaggableValue<TagMSB, Two> for usize

fn untag(v: TagWrapper<usize, TagMSB>) -> usize

fn untag_in_place(v: &mut TagWrapper<usize, TagMSB>)

fn get_tag(v: &TagWrapper<usize, TagMSB>) -> Two

fn tag(v: Self, o: Two) -> TagWrapper<usize, TagMSB>

fn tag_in_place(v: &mut TagWrapper<usize, TagMSB>, o: Two)

fn change_tag(v: &mut TagWrapper<usize, TagMSB>, o: Two)

unsafe fn uninitialized_from_tag(o: Two) -> TagWrapper<usize, TagMSB>

fn fmt_untagged(v: &TagWrapper<usize, TagMSB>, f: &mut Formatter<'_>) -> Result

fn eq(a: &TagWrapper<usize, TagMSB>, b: &TagWrapper<usize, TagMSB>) -> bool

fn ne(a: &TagWrapper<usize, TagMSB>, b: &TagWrapper<usize, TagMSB>) -> bool

Implementors

impl<T, TM> TaggableValue<TM, One> for T

where T: UntaggedZero<TM, Two>,