Enum PokeUninit

#[non_exhaustive]
pub enum PokeUninit<'mem> {
    Scalar(PokeValueUninit<'mem>),
    List(PokeListUninit<'mem>),
    Map(PokeMapUninit<'mem>),
    Struct(PokeStruct<'mem>),
    Enum(PokeEnumNoVariant<'mem>),
    Option(PokeOptionUninit<'mem>),
    SmartPointer(PokeSmartPointerUninit<'mem>),
}

Allows initializing values of different kinds.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Scalar(PokeValueUninit<'mem>)

A scalar value. See PokeValue.

List(PokeListUninit<'mem>)

A list (array/vec/etc). See PokeList.

Map(PokeMapUninit<'mem>)

A map (HashMap/BTreeMap/etc). See PokeMap.

Struct(PokeStruct<'mem>)

A struct, tuple struct, or tuple. See PokeStruct.

Enum(PokeEnumNoVariant<'mem>)

An enum variant. See PokeEnum.

Option(PokeOptionUninit<'mem>)

An option value. See PokeOption.

SmartPointer(PokeSmartPointerUninit<'mem>)

A smart pointer. See PokeSmartPointer.

Implementations

impl<'mem> PokeUninit<'mem>

pub fn alloc<S: Facet>() -> (Self, Guard)

Allocates a new poke of a type that implements facet

pub fn alloc_shape(shape: &'static Shape) -> (Self, Guard)

Allocates a new poke from a given shape

pub unsafe fn unchecked_new( data: OpaqueUninit<'mem>, shape: &'static Shape, ) -> Self

Creates a new peek, for easy manipulation of some opaque data.

Safety

data must be initialized and well-aligned, and point to a value of the type described by shape.

pub fn into_struct(self) -> PokeStruct<'mem>

Converts this Poke into a PokeStruct, panicking if it’s not a Struct variant

pub fn into_list(self) -> PokeListUninit<'mem>

Converts this Poke into a PokeList, panicking if it’s not a List variant

pub fn into_map(self) -> PokeMapUninit<'mem>

Converts this Poke into a PokeMap, panicking if it’s not a Map variant

pub fn into_smart_pointer(self) -> PokeSmartPointerUninit<'mem>

Converts this Poke into a PokeSmartPointer, panicking if it’s not a SmartPointer variant

pub fn into_scalar(self) -> PokeValueUninit<'mem>

Converts this Poke into a PokeValue, panicking if it’s not a Scalar variant

pub fn into_enum(self) -> PokeEnumNoVariant<'mem>

Converts this Poke into a PokeEnum, panicking if it’s not an Enum variant

pub fn into_option(self) -> PokeOptionUninit<'mem>

Converts this Poke into a PokeOption, panicking if it’s not an Option variant

pub fn into_value(self) -> PokeValueUninit<'mem>

Converts into a value, so we can manipulate it

pub fn shape(&self) -> &'static Shape

Get the shape of this Poke.