Struct PeekEnum 

pub struct PeekEnum<'mem, 'facet> { /* private fields */ }

Available on crate feature reflect only.

Lets you read from an enum (implements read-only enum operations)

Implementations

impl<'mem, 'facet> PeekEnum<'mem, 'facet>

pub fn ty(self) -> EnumType

Returns the enum definition

pub fn enum_repr(self) -> EnumRepr

Returns the enum representation

pub fn variants(self) -> &'static [Variant]

Returns the enum variants

pub fn variant_count(self) -> usize

Returns the number of variants in this enum

pub fn variant_name(self, index: usize) -> Option<&'static str>

Returns the variant name at the given index

pub fn discriminant(self) -> i64

Returns the discriminant value for the current enum value

Note: For RustNPO (null pointer optimization) types, there is no explicit discriminant stored in memory. In this case, 0 is returned. Use variant_index() to determine the active variant for NPO types.

pub fn variant_index(self) -> Result<usize, VariantError>

Returns the variant index for this enum value

pub fn active_variant(self) -> Result<&'static Variant, VariantError>

Returns the active variant

pub fn variant_name_active(self) -> Result<&'static str, VariantError>

Returns the name of the active variant for this enum value

pub fn field( self, index: usize, ) -> Result<Option<Peek<'mem, 'facet>>, VariantError>

Returns a PeekValue handle to a field of a tuple or struct variant by index

pub fn field_index( self, field_name: &str, ) -> Result<Option<usize>, VariantError>

Returns the index of a field in the active variant by name

pub fn field_by_name( self, field_name: &str, ) -> Result<Option<Peek<'mem, 'facet>>, VariantError>

Returns a PeekValue handle to a field of a tuple or struct variant by name

Methods from Deref<Target = Peek<'mem, 'facet>>

pub fn variance(&self) -> Variance

Returns the computed variance of the underlying type.

This walks the type’s fields to determine if the type is covariant, contravariant, or invariant over its lifetime parameter.

pub fn vtable(&self) -> VTableErased

Returns the vtable

pub fn id(&self) -> ValueId

Returns a unique identifier for this value, usable for cycle detection

pub fn ptr_eq(&self, other: &Peek<'_, '_>) -> bool

Returns true if the two values are pointer-equal

pub fn partial_eq(&self, other: &Peek<'_, '_>) -> Result<bool, ReflectError>

Returns true if this scalar is equal to the other scalar

Returns

false if equality comparison is not supported for this scalar type

pub fn partial_cmp( &self, other: &Peek<'_, '_>, ) -> Result<Option<Ordering>, ReflectError>

Compares this scalar with another and returns their ordering

Returns

None if comparison is not supported for this scalar type

pub fn hash(&self, hasher: &mut dyn Hasher) -> Result<(), ReflectError>

Hashes this scalar using the vtable hash function.

Returns

Err if hashing is not supported for this scalar type, Ok otherwise

pub fn structural_hash<H>(&self, hasher: &mut H)

where H: Hasher,

Computes a structural hash of this value.

Unlike hash, this method recursively traverses the structure and hashes each component, making it work for types that don’t implement Hash.

For scalars with a vtable hash function, it uses that. For compound types (structs, enums, lists, etc.), it recursively hashes the structure.

This is useful for Merkle-tree style hashing where you want to compare subtrees for equality based on their structural content.

pub fn type_name( &self, f: &mut Formatter<'_>, opts: TypeNameOpts, ) -> Result<(), Error>

Returns the type name of this scalar

Arguments

• f - A mutable reference to a core::fmt::Formatter
• opts - The TypeNameOpts to use for formatting

Returns

The result of the type name formatting

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

Returns the shape

pub fn data(&self) -> PtrConst

Returns the data

pub fn scalar_type(&self) -> Option<ScalarType>

Get the scalar type if set.

pub fn get<T>(&self) -> Result<&'mem T, ReflectError>

where T: Facet<'facet> + ?Sized,

Read the value from memory into a Rust value.

Panics

Panics if the shape doesn’t match the type T.

pub fn as_str(&self) -> Option<&'mem str>

Try to get the value as a string if it’s a string type Returns None if the value is not a string or couldn’t be extracted

pub fn as_bytes(&self) -> Option<&'mem [u8]>

Try to get the value as a byte slice if it’s a &u8 type Returns None if the value is not a byte slice or couldn’t be extracted

pub fn custom_serialization( &self, field: Field, ) -> Result<OwnedPeek<'mem>, ReflectError>

Available on crate feature alloc only.

Performs custom serialization of the current peek using the provided field’s metadata.

Returns an OwnedPeek that points to the final type that should be serialized in place of the current peek.

pub fn custom_serialization_from_shape( &self, ) -> Result<Option<OwnedPeek<'mem>>, ReflectError>

Available on crate feature alloc only.

Returns an OwnedPeek using the shape’s container-level proxy for serialization.

This is used when a type has #[facet(proxy = ProxyType)] at the container level. Unlike field-level proxies which are checked via custom_serialization(field), this method checks the Shape itself for a proxy definition.

Returns None if the shape has no container-level proxy.

Trait Implementations

impl<'mem, 'facet> Clone for PeekEnum<'mem, 'facet>

fn clone(&self) -> PeekEnum<'mem, 'facet>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PeekEnum<'_, '_>

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

Formats the value using the given formatter.

impl<'mem, 'facet> Deref for PeekEnum<'mem, 'facet>

type Target = Peek<'mem, 'facet>

The resulting type after dereferencing.

fn deref(&self) -> &<PeekEnum<'mem, 'facet> as Deref>::Target

Dereferences the value.

impl<'mem, 'facet> HasFields<'mem, 'facet> for PeekEnum<'mem, 'facet>

fn fields(&self) -> FieldIter<'mem, 'facet>

Iterates over all fields in this type, providing both field metadata and value

fn fields_for_serialize(&self) -> FieldsForSerializeIter<'mem, 'facet>

Iterates over fields in this type that should be included when it is serialized

impl<'mem, 'facet> Copy for PeekEnum<'mem, 'facet>