Enum SnapshotField 

#[non_exhaustive]
pub enum SnapshotField<'a> {
    Value(&'a RenderedValue),
    PercpuKey {
        key: u32,
    },
    Missing(SnapshotError),
}

One field’s view at the leaf of a dotted-path walk.

Returned by super::Snapshot::var, super::SnapshotEntry::get, and super::SnapshotEntry::key. Terminal as_* accessors return SnapshotResult so a missing or type-mismatched field surfaces as a recoverable error rather than a panic.

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.

Value(&'a RenderedValue)

Resolved rendered value at the leaf of the path walk.

PercpuKey

Dedicated per-CPU array key shape (u32, no struct).

Fields

key: u32

Missing(SnapshotError)

Path could not be resolved.

Implementations

impl<'a> SnapshotField<'a>

pub fn get(&self, path: &str) -> SnapshotField<'a>

Walk into a sub-field. Composable with super::SnapshotEntry::get.

pub fn is_present(&self) -> bool

True when the field resolved successfully.

pub fn as_u64(&self) -> SnapshotResult<u64>

Read as u64. Accepts RenderedValue::Uint, RenderedValue::Int (errors on negative), RenderedValue::Bool (0/1), RenderedValue::Char (raw byte), RenderedValue::Enum (raw enum integer), RenderedValue::Ptr (pointer value), and the percpu-array u32 key.

pub fn as_i64(&self) -> SnapshotResult<i64>

Read as i64.

pub fn as_bool(&self) -> SnapshotResult<bool>

Read as bool. RenderedValue::Bool direct, ints / enums non-zero is true.

pub fn as_f64(&self) -> SnapshotResult<f64>

Read as f64.

pub fn as_str(&self) -> SnapshotResult<&'a str>

Read the variant string for an RenderedValue::Enum with a resolved variant name.

pub fn as_u64_array(&self) -> SnapshotResult<Vec<u64>>

Read as Vec<u64> from an RenderedValue::Array whose every element coerces via Self::as_u64’s rules. Errors with SnapshotError::TypeMismatch when self is not an array, or when any element fails the coercion (no partial results — the caller cannot tell which element silently dropped). Mirrors RenderedValue::as_u64_array but propagates the captured SnapshotError through the SnapshotField::Missing arm.

pub fn as_u32_array(&self) -> SnapshotResult<Vec<u32>>

Read as Vec<u32> from an array. Mirrors RenderedValue::as_u32_array; out-of-range values (Uint exceeding u32::MAX) error rather than truncate.

pub fn as_i64_array(&self) -> SnapshotResult<Vec<i64>>

Read as Vec<i64> from an array. Mirrors RenderedValue::as_i64_array.

pub fn as_f64_array(&self) -> SnapshotResult<Vec<f64>>

Read as Vec<f64> from an array. Mirrors RenderedValue::as_f64_array.

pub fn as_bool_array(&self) -> SnapshotResult<Vec<bool>>

Read as Vec<bool> from an array. Mirrors RenderedValue::as_bool_array.

pub fn raw(&self) -> Option<&'a RenderedValue>

Drop into the raw RenderedValue for direct RenderedValue::member / RenderedValue::get / RenderedValue::index navigation. Use when the pattern-matched-into-known-shape access pattern (Option- returning terminals, no rich error context) reads more naturally than the SnapshotField’s Result-propagating chain. None for SnapshotField::PercpuKey (no underlying tree) and SnapshotField::Missing.

pub fn iter_members(&self) -> impl Iterator<Item = SnapshotField<'a>> + '_

Iterate the elements of an array-shaped field as SnapshotFields so chained navigation composes: field.iter_members().filter_map(|el| el.get("name").as_u64().ok()). Bridges the gap left by the scalar as_*_array terminals on array-of-struct shapes: those terminals coerce each element to a scalar via the shared coercion helper and return SnapshotError::TypeMismatch on the first non-scalar element, which is exactly what an array-of-struct triggers. iter_members instead hands the caller each raw element so they can chain .get(field).as_u64() per element. Peels RenderedValue::Ptr dereferences and RenderedValue::Truncated partial-array wrappers the same way Self::as_u64_array does.

Yields nothing for non-array shapes, percpu-key fields, or missing fields — the empty iterator pattern is the natural “no elements to walk” representation when the chain just wants to fold over what’s there. iter_members itself never surfaces SnapshotError::TypeMismatch; callers needing to distinguish “absent” from “empty” check Self::is_present or Self::error explicitly.

pub fn error(&self) -> Option<&SnapshotError>

Error reference when the field is missing; None otherwise.

Trait Implementations

impl<'a> Debug for SnapshotField<'a>

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

Formats the value using the given formatter.