pub enum Enum8<A, B, C, D, E, F, G, H> {
A(A),
B(B),
C(C),
D(D),
E(E),
F(F),
G(G),
H(H),
}
Expand description
An unpacked version of Union4
.
Variants
A(A)
B(B)
C(C)
D(D)
E(E)
F(F)
G(G)
H(H)
Implementations
sourceimpl<A: ErasablePtr, B: ErasablePtr, C: ErasablePtr, D: ErasablePtr, E: ErasablePtr, F: ErasablePtr, G: ErasablePtr, H: ErasablePtr> Enum8<A, B, C, D, E, F, G, H>
impl<A: ErasablePtr, B: ErasablePtr, C: ErasablePtr, D: ErasablePtr, E: ErasablePtr, F: ErasablePtr, G: ErasablePtr, H: ErasablePtr> Enum8<A, B, C, D, E, F, G, H>
sourcepub fn pack(
self,
builder: Builder8<A, B, C, D, E, F, G, H>
) -> Union8<A, B, C, D, E, F, G, H>
pub fn pack(
self,
builder: Builder8<A, B, C, D, E, F, G, H>
) -> Union8<A, B, C, D, E, F, G, H>
Pack this loose enum into a pointer union.
sourcepub fn try_pack(self) -> Result<Union8<A, B, C, D, E, F, G, H>, Self>
pub fn try_pack(self) -> Result<Union8<A, B, C, D, E, F, G, H>, Self>
Pack this loose enum into a pointer union.
sourcepub unsafe fn pack_unchecked(self) -> Union8<A, B, C, D, E, F, G, H>
pub unsafe fn pack_unchecked(self) -> Union8<A, B, C, D, E, F, G, H>
Pack this loose enum into a pointer union.
Safety
The pointer packed must be properly aligned. Note that only the actually packed pointer is restricted, not any other pointer type involved in this definition.
Trait Implementations
sourceimpl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone> Clone for Enum8<A, B, C, D, E, F, G, H>
impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone> Clone for Enum8<A, B, C, D, E, F, G, H>
sourceimpl<A: Debug, B: Debug, C: Debug, D: Debug, E: Debug, F: Debug, G: Debug, H: Debug> Debug for Enum8<A, B, C, D, E, F, G, H>
impl<A: Debug, B: Debug, C: Debug, D: Debug, E: Debug, F: Debug, G: Debug, H: Debug> Debug for Enum8<A, B, C, D, E, F, G, H>
sourceimpl<A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash> Hash for Enum8<A, B, C, D, E, F, G, H>
impl<A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash> Hash for Enum8<A, B, C, D, E, F, G, H>
sourceimpl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq> PartialEq<Enum8<A, B, C, D, E, F, G, H>> for Enum8<A, B, C, D, E, F, G, H>
impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq> PartialEq<Enum8<A, B, C, D, E, F, G, H>> for Enum8<A, B, C, D, E, F, G, H>
impl<A: Copy, B: Copy, C: Copy, D: Copy, E: Copy, F: Copy, G: Copy, H: Copy> Copy for Enum8<A, B, C, D, E, F, G, H>
impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq> Eq for Enum8<A, B, C, D, E, F, G, H>
impl<A, B, C, D, E, F, G, H> StructuralEq for Enum8<A, B, C, D, E, F, G, H>
impl<A, B, C, D, E, F, G, H> StructuralPartialEq for Enum8<A, B, C, D, E, F, G, H>
Auto Trait Implementations
impl<A, B, C, D, E, F, G, H> RefUnwindSafe for Enum8<A, B, C, D, E, F, G, H> where
A: RefUnwindSafe,
B: RefUnwindSafe,
C: RefUnwindSafe,
D: RefUnwindSafe,
E: RefUnwindSafe,
F: RefUnwindSafe,
G: RefUnwindSafe,
H: RefUnwindSafe,
impl<A, B, C, D, E, F, G, H> Send for Enum8<A, B, C, D, E, F, G, H> where
A: Send,
B: Send,
C: Send,
D: Send,
E: Send,
F: Send,
G: Send,
H: Send,
impl<A, B, C, D, E, F, G, H> Sync for Enum8<A, B, C, D, E, F, G, H> where
A: Sync,
B: Sync,
C: Sync,
D: Sync,
E: Sync,
F: Sync,
G: Sync,
H: Sync,
impl<A, B, C, D, E, F, G, H> Unpin for Enum8<A, B, C, D, E, F, G, H> where
A: Unpin,
B: Unpin,
C: Unpin,
D: Unpin,
E: Unpin,
F: Unpin,
G: Unpin,
H: Unpin,
impl<A, B, C, D, E, F, G, H> UnwindSafe for Enum8<A, B, C, D, E, F, G, H> where
A: UnwindSafe,
B: UnwindSafe,
C: UnwindSafe,
D: UnwindSafe,
E: UnwindSafe,
F: UnwindSafe,
G: UnwindSafe,
H: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Erasable for T
impl<T> Erasable for T
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
🔬 This is a nightly-only experimental API. (
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more