Struct CuAppLifecycle 

pub struct CuAppLifecycle<S, L, A, State = Initialized> { /* private fields */ }

Compile-time enforced lifecycle for a CuApplication.

Wrapping an application moves lifecycle mistakes (double start, iterating before start, mixing start_all_tasks with run…) from runtime surprises to compile errors: each state is a distinct type exposing only the transitions that are legal from it.

                     start
  Initialized ------------------> Running <---+
       |                            |  |      | run_one_iteration
       | run_until_shutdown         |  +------+
       |                            | stop
       +--------> Stopped <---------+
                   |   ^
                   |   | stop (cleanup)
       (restart)   |  Faulted <--- any failed transition
                   +---> start / run_until_shutdown again

Transitions consume the wrapper and return it typed with the new state, so a stale pre-transition handle cannot be reused. When a transition fails, the application is handed back inside LifecycleError, typed Faulted, so cleanup is still possible and nothing is lost.

This is the default construction path: the generated application builder hands one out from build_app(). The raw CuApplication methods remain available (deprecated on the generated application) for framework-level harnesses such as replay engines; into_inner drops back to that level when needed.

The application is boxed internally: generated applications embed their copperlist pools and can be megabytes, so the consuming transitions move a pointer instead of the application itself (which in debug builds would blow through a test thread’s stack).

Implementations

impl<S, L, A, State> CuAppLifecycle<S, L, A, State>

pub fn inner(&self) -> &A

Read-only access to the wrapped application.

pub fn into_inner(self) -> A

Consumes the wrapper and returns the application, dropping the compile-time lifecycle tracking.

impl<S, L, A> CuAppLifecycle<S, L, A, Initialized>

where S: SectionStorage, L: UnifiedLogWrite<S> + 'static, A: CuApplication<S, L>,

pub fn new(app: A) -> Self

Wraps a freshly built application in the Initialized state.

pub fn inner_mut(&mut self) -> &mut A

Mutable access to the wrapped application, only before it is started.

This exists for pre-start configuration (attaching monitors, inspecting the runtime…). Once started, only the read-only inner view remains available so the lifecycle transitions cannot be bypassed mid-flight.

impl<S, L, A, State> CuAppLifecycle<S, L, A, State>

where S: SectionStorage, L: UnifiedLogWrite<S> + 'static, A: CuApplication<S, L>, State: Startable,

pub fn start(self) -> TransitionResult<S, L, A, Running>

Starts all tasks, transitioning to Running.

On failure the application may be partially started; it is returned typed Faulted inside the error so it can be cleaned up.

pub fn run_until_shutdown(self) -> TransitionResult<S, L, A, Stopped>

Runs the full lifecycle (start, iterate until shutdown, stop), transitioning to Stopped on success.

impl<S, L, A> CuAppLifecycle<S, L, A, Running>

where S: SectionStorage, L: UnifiedLogWrite<S> + 'static, A: CuApplication<S, L>,

pub fn run_one_iteration(&mut self) -> CuResult<()>

Executes one iteration of the runtime. An iteration error does not change the lifecycle state: the caller decides whether to keep iterating or stop.

impl<S, L, A, State> CuAppLifecycle<S, L, A, State>

where S: SectionStorage, L: UnifiedLogWrite<S> + 'static, A: CuApplication<S, L>, State: Stoppable,

pub fn stop(self) -> TransitionResult<S, L, A, Stopped>

Stops all tasks, transitioning to Stopped. From Faulted this is a best-effort cleanup. On failure the application is handed back typed Faulted again.

Trait Implementations

impl<S, L, A> CuApplication<S, L> for CuAppLifecycle<S, L, A, Initialized>

where S: SectionStorage, L: UnifiedLogWrite<S> + 'static, A: CuApplication<S, L>,

Legacy escape hatch: the raw (deprecated) lifecycle API remains callable on what build() returns, so pre-typestate code compiles unchanged and only picks up deprecation warnings. Raw calls do not advance the typestate; mixing them with typed transitions is outside the typestate guarantees.

fn get_original_config() -> String

Returns the original configuration as a string, typically loaded from a RON file. This configuration represents the default settings for the application before any overrides.

fn start_all_tasks(&mut self) -> CuResult<()>

👎Deprecated since 1.2.0:

use the typed transition start() on the handle returned by build()

Starts all tasks managed by the application/runtime.

fn run_one_iteration(&mut self) -> CuResult<()>

👎Deprecated since 1.2.0:

use run_one_iteration() on the Running handle from build()?.start()?

Executes a single iteration of copper-generated runtime (generating and logging one copperlist)

fn run(&mut self) -> CuResult<()>

👎Deprecated since 1.2.0:

use the typed transition run_until_shutdown() on the handle returned by build()

Runs indefinitely looping over run_one_iteration

fn stop_all_tasks(&mut self) -> CuResult<()>

👎Deprecated since 1.2.0:

use the typed transition stop() on the Running handle

Stops all tasks managed by the application/runtime.

fn restore_keyframe(&mut self, freezer: &KeyFrame) -> CuResult<()>

Restore all tasks from the given frozen state

impl<S, L, A, State> Debug for CuAppLifecycle<S, L, A, State>

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

Formats the value using the given formatter.

impl<S, L, A, State> Deref for CuAppLifecycle<S, L, A, State>

Read access to the wrapped application in every lifecycle state, so conveniences like app.clock() keep working without ceremony.

type Target = A

The resulting type after dereferencing.

fn deref(&self) -> &A

Dereferences the value.

impl<S, L, A> DerefMut for CuAppLifecycle<S, L, A, Initialized>

Mutable access only before the application is started: after a typed start, raw mutable access could bypass the lifecycle guarantees.

fn deref_mut(&mut self) -> &mut A

Mutably dereferences the value.