Struct Partial 

pub struct Partial<'facet> { /* private fields */ }

A work-in-progress heap-allocated value

Lifetimes

• 'facet: The lifetime of borrowed values within the structure (or ’static if it’s owned)
• 'shape: The lifetime of the Shape structure itself (often ’static)

Implementations

impl<'facet> Partial<'facet>

pub fn alloc_shape(shape: &'static Shape) -> Result<Self, ReflectError>

Allocates a new Partial instance with the given shape

pub fn alloc<T>() -> Result<TypedPartial<'facet, T>, ReflectError>

where T: Facet<'facet>,

Allocates a new TypedPartial instance with the given shape and type

pub fn from_ptr(data: PtrUninit<'_>, shape: &'static Shape) -> Self

Creates a Partial from an existing pointer and shape (used for nested initialization)

pub fn frame_count(&self) -> usize

Returns the current frame count (depth of nesting)

pub fn set<U>(&mut self, value: U) -> Result<&mut Self, ReflectError>

where U: Facet<'facet>,

Sets a value wholesale into the current frame

pub unsafe fn set_shape( &mut self, src_value: PtrConst<'_>, src_shape: &'static Shape, ) -> Result<&mut Self, ReflectError>

Sets a value into the current frame by shape, for shape-based operations

If this returns Ok, then src_value has been moved out of

Safety

The caller must ensure that src_value points to a valid instance of a value whose memory layout and type matches src_shape, and that this value can be safely copied (bitwise) into the destination specified by the Partial’s current frame. No automatic drop will be performed for any existing value, so calling this on an already-initialized destination may result in leaks or double drops if misused. After a successful call, the ownership of the value at src_value is effectively moved into the Partial (i.e., the destination), and the original value should not be used or dropped by the caller; consider using core::mem::forget on the passed value. If an error is returned, the destination remains unmodified and safe for future operations.

pub fn set_default(&mut self) -> Result<&mut Self, ReflectError>

Sets the current frame to its default value

pub fn set_field_default( &mut self, field_default_fn: DefaultInPlaceFn, ) -> Result<&mut Self, ReflectError>

Sets the current frame using a field-level default function

pub fn set_from_function<F>(&mut self, f: F) -> Result<&mut Self, ReflectError>

where F: FnOnce(PtrUninit<'_>) -> Result<(), ReflectError>,

Sets the current frame using a function that initializes the value

pub fn parse_from_str(&mut self, s: &str) -> Result<&mut Self, ReflectError>

Parses a string value into the current frame using the type’s ParseFn from the vtable

pub fn select_variant_named( &mut self, variant_name: &str, ) -> Result<&mut Self, ReflectError>

Pushes a variant for enum initialization by name

pub fn select_variant( &mut self, discriminant: i64, ) -> Result<&mut Self, ReflectError>

Pushes a variant for enum initialization

pub fn begin_field( &mut self, field_name: &str, ) -> Result<&mut Self, ReflectError>

Selects a field of a struct with a given name

pub fn select_nth_variant( &mut self, index: usize, ) -> Result<&mut Self, ReflectError>

Selects a variant for enum initialization, by variant index in the enum’s variant list (0-based)

pub fn begin_nth_field(&mut self, idx: usize) -> Result<&mut Self, ReflectError>

Selects the nth field of a struct by index

pub fn begin_nth_element( &mut self, idx: usize, ) -> Result<&mut Self, ReflectError>

Selects the nth element of an array by index

pub fn begin_nth_enum_field( &mut self, idx: usize, ) -> Result<&mut Self, ReflectError>

Selects the nth field of an enum variant by index

pub fn begin_smart_ptr(&mut self) -> Result<&mut Self, ReflectError>

Pushes a frame to initialize the inner value of a smart pointer (Box<T>, Arc<T>, etc.)

pub fn begin_list(&mut self) -> Result<&mut Self, ReflectError>

Initializes a list (Vec, etc.) if it hasn’t been initialized before. This is a prerequisite to begin_push_item/set/end or the shorthand push.

begin_list does not clear the list if it was previously initialized. begin_list does not push a new frame to the stack, and thus does not require end to be called afterwards.

pub fn begin_map(&mut self) -> Result<&mut Self, ReflectError>

Begins a map initialization operation This initializes the map with default capacity and allows inserting key-value pairs

pub fn begin_key(&mut self) -> Result<&mut Self, ReflectError>

Pushes a frame for the map key Automatically starts a new insert if we’re idle

pub fn begin_value(&mut self) -> Result<&mut Self, ReflectError>

Pushes a frame for the map value Must be called after the key has been set and popped

pub fn begin_list_item(&mut self) -> Result<&mut Self, ReflectError>

Pushes an element to the list The element should be set using set() or similar methods, then pop() to complete

pub fn end(&mut self) -> Result<&mut Self, ReflectError>

Pops the current frame off the stack, indicating we’re done initializing the current field

pub fn build(&mut self) -> Result<HeapValue<'facet>, ReflectError>

Builds the value

pub fn path(&self) -> String

Returns a human-readable path representing the current traversal in the builder, e.g., RootStruct.fieldName[index].subfield.

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

Returns the shape of the current frame.

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

Returns the innermost shape (alias for shape(), for compatibility)

pub fn is_field_set(&self, index: usize) -> Result<bool, ReflectError>

Check if a struct field at the given index has been set

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

Find the index of a field by name in the current struct

pub fn selected_variant(&self) -> Option<Variant>

Get the currently selected variant for an enum

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

Find a variant by name in the current enum

pub fn begin_some(&mut self) -> Result<&mut Self, ReflectError>

Begin building the Some variant of an Option

pub fn begin_inner(&mut self) -> Result<&mut Self, ReflectError>

Begin building the inner value of a wrapper type

pub fn set_from_peek( &mut self, peek: &Peek<'_, '_>, ) -> Result<&mut Self, ReflectError>

Copy a value from a Peek into the current position (safe alternative to set_shape)

pub fn set_field_from_default( &mut self, field_data: PtrConst<'_>, field_shape: &'static Shape, ) -> Result<&mut Self, ReflectError>

Copy a field from a struct’s default value (safe wrapper for deserialization) This method creates the Peek internally to avoid exposing unsafe code to callers

pub fn fill_unset_fields_from_default( &mut self, ) -> Result<&mut Self, ReflectError>

Fill all unset fields from the struct’s default value This is a safe API for format deserializers that forbid unsafe code

pub fn set_nth_element<U>( &mut self, idx: usize, value: U, ) -> Result<&mut Self, ReflectError>

where U: Facet<'facet>,

Convenience shortcut: sets the nth element of an array directly to value, popping after.

pub fn set_nth_field<U>( &mut self, idx: usize, value: U, ) -> Result<&mut Self, ReflectError>

where U: Facet<'facet>,

Convenience shortcut: sets the field at index idx directly to value, popping after.

pub fn set_field<U>( &mut self, field_name: &str, value: U, ) -> Result<&mut Self, ReflectError>

where U: Facet<'facet>,

Convenience shortcut: sets the named field to value, popping after.

pub fn set_nth_enum_field<U>( &mut self, idx: usize, value: U, ) -> Result<&mut Self, ReflectError>

where U: Facet<'facet>,

Convenience shortcut: sets the nth field of an enum variant directly to value, popping after.

pub fn set_key<U>(&mut self, value: U) -> Result<&mut Self, ReflectError>

where U: Facet<'facet>,

Convenience shortcut: sets the key for a map key-value insertion, then pops after.

pub fn set_value<U>(&mut self, value: U) -> Result<&mut Self, ReflectError>

where U: Facet<'facet>,

Convenience shortcut: sets the value for a map key-value insertion, then pops after.

pub fn push<U>(&mut self, value: U) -> Result<&mut Self, ReflectError>

where U: Facet<'facet>,

Shorthand for: begin_list_item(), set, end

Trait Implementations

impl<'facet> Drop for Partial<'facet>

fn drop(&mut self)

Executes the destructor for this type.