Struct StatefulView 

pub struct StatefulView {
    pub metadata: *const c_void,
    pub witness_table: *const c_void,
    pub id: i64,
    /* private fields */
}

A runtime-built Swift view type with a real @State.

SwiftUI installs the storage itself: it walks the type’s reflection field records looking for a stored property whose type conforms to DynamicProperty, finds the State<Int>, and attaches a location box. That is what makes set invalidate the view and re-run the body, and what lets set_animated interpolate — a @State change is a change to a view SwiftUI already knows, unlike a root swap.

The catch is how quietly that walk fails. If the field’s mangled type name does not demangle, the runtime reports the field as an empty tuple, SwiftUI finds no DynamicProperty, and everything still works — the body runs once, writes report success — except nothing ever updates. See the layout assertions in build_type.

Several at once

The body witness is one extern "C" function with no room for an instance parameter, so the struct carries a second stored field holding an id. The witness reads it and looks the right builder up, which is what lets more than one StatefulView be live at a time.

Fields

metadata: *const c_void

Metadata for the synthesised struct.

witness_table: *const c_void

Its View witness table.

id: i64

Identifies this instance to the shared body witness.

Implementations

impl StatefulView

pub fn new( initial: i64, builder: impl Fn(i64) -> ViewHandle + Send + 'static, ) -> Self

Build the type and one instance of it.

builder receives the current state value every time SwiftUI evaluates the body.

Hosting the result works: examples/parity’s state_rebuild check hosts one, writes to it three times, and asserts the body saw each new value. An earlier note here said it faulted in a value witness — that was true of the first attempt, which borrowed State<Int>’s witness table; the module docs explain why that cannot work and what replaced it.

Examples found in repository

examples/ios_app.rs (line 61)

fn root_view() -> views::ViewHandle {
    thread_local! {
        static ROOT: std::cell::OnceCell<swiftui_native::state::StatefulView> =
            const { std::cell::OnceCell::new() };
    }
    ROOT.with(|cell| {
        let sv = cell.get_or_init(|| {
            let sv = swiftui_native::state::StatefulView::new(0, |_generation| ui());
            ROOT_ID.store(sv.id, std::sync::atomic::Ordering::Release);
            sv
        });
        sv.as_view()
    })
}

pub fn set(&self, value: i64) -> bool

Write a new value, re-running the body.

pub fn set_animated(&self, value: i64)

Write a new value inside withAnimation, so SwiftUI interpolates.

pub fn set_animated_with(&self, value: i64, animation: u64)

As set_animated, with the animation spelled out — withAnimation(.easeInOut(duration: 1)) { ... } and the like.

pub fn as_view(&self) -> ViewHandle

Wrap the instance in an AnyView so it can be hosted like any other view.

Examples found in repository

examples/ios_app.rs (line 65)

fn root_view() -> views::ViewHandle {
    thread_local! {
        static ROOT: std::cell::OnceCell<swiftui_native::state::StatefulView> =
            const { std::cell::OnceCell::new() };
    }
    ROOT.with(|cell| {
        let sv = cell.get_or_init(|| {
            let sv = swiftui_native::state::StatefulView::new(0, |_generation| ui());
            ROOT_ID.store(sv.id, std::sync::atomic::Ordering::Release);
            sv
        });
        sv.as_view()
    })
}

Trait Implementations

impl Drop for StatefulView

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.