Struct CuContext 

pub struct CuContext {
    pub clock: RobotClock,
    /* private fields */
}

Execution context passed to task and bridge callbacks.

CuContext provides callback code with:

• time access through clock and Deref<Target = RobotClock>
• current execution sequence id via cl_id()
• process instance metadata via instance_id()
• compile-time subsystem identity via subsystem_code()
• current component metadata via current_component_id()
• current task metadata via task_id() / task_index()

The execution sequence id matches the copper-list id of the iteration being processed. It is also available in other lifecycle callbacks (start/preprocess/postprocess/stop) for continuity, but outside process callbacks it must not be treated as a live copper-list handle.

The runtime creates one context per execution loop and updates transient fields such as the currently executing component/task before each callback.

Fields

clock: RobotClock

Runtime clock. Kept as a field for direct access (context.clock.now()).

Implementations

impl CuContext

pub fn builder(clock: RobotClock) -> CuContextBuilder

Starts a context builder from a clock.

pub fn from_clock(clock: RobotClock) -> CuContext

Creates a context from an existing clock with default metadata.

Defaults:

• cl_id = 0
• no task id table

pub fn new_with_clock() -> CuContext

Creates a context backed by a real robot clock.

Defaults:

• cl_id = 0
• no task id table

pub fn new_mock_clock() -> (CuContext, RobotClockMock)

Creates a context backed by a mock clock.

Returns both the context and its RobotClockMock control handle.

pub fn set_current_component(&mut self, component_index: usize)

Sets the currently executing component index.

pub fn clear_current_component(&mut self)

Clears the currently executing component.

pub fn set_current_task(&mut self, task_index: usize)

Sets the currently executing task index.

pub fn clear_current_task(&mut self)

Clears the currently executing task.

pub fn cl_id(&self) -> u64

Returns the current execution sequence id.

In process callbacks, this value is the id of the copper-list being processed. In other lifecycle callbacks, this value is still meaningful for sequencing but does not imply that a copper-list instance is alive.

pub fn instance_id(&self) -> u32

Returns the runtime instance id attached to this context.

pub fn subsystem_code(&self) -> u16

Returns the compile-time subsystem code for this Copper process.

pub fn current_component_id(&self) -> Option<usize>

Returns the current component index, if any.

pub fn task_index(&self) -> Option<usize>

Returns the current task index, if any.

pub fn task_id(&self) -> Option<&'static str>

Returns the current task id, if any.

Methods from Deref<Target = RobotClock>

pub fn is_mock(&self) -> bool

Whether time is controlled explicitly by a mock handle.

pub fn now(&self) -> CuTime

Reads execution time: local elapsed time, or the selected reference epoch.

pub fn origin(&self) -> ClockOrigin

Describes the source and epoch of execution timestamps without converting them.

Reference metadata is published with the execution mapping and shared by clones. Before initial acquisition, the local origin remains in effect. During resynchronization, the previous epoch remains in effect while the execution clock slews. Providers must preserve the epoch across resync. This accessor performs no counter read, allocation, or reference I/O.

use cu29_clock::{ClockEpoch, ClockSource, RobotClock};
let (clock, _) = RobotClock::mock();
assert_eq!(clock.origin().source, ClockSource::Mock);
assert_eq!(clock.origin().epoch, ClockEpoch::Local);

pub fn recent(&self) -> CuTime

Reads the same timeline through the backend’s recent-time operation.

pub fn raw_now(&self) -> CuInstant

Reads undisciplined local counter time in nanoseconds.

Clones share the counter origin and calibration. Independently constructed clocks have their own origins; compare raw readings only within one clock and its clones. Reference capture and elapsed-time measurements use this timeline, which is unaffected by execution-clock synchronization.

use cu29_clock::{CuDuration, RobotClock};

let (clock, control) = RobotClock::mock();
let start = clock.raw_now();
control.increment(CuDuration::from_millis(1));
assert_eq!(clock.raw_now() - start, CuDuration::from_millis(1));

pub fn busy_wait_for(&self, duration: CuDuration)

Spins for a duration measured on this clock’s undisciplined timeline.

pub fn busy_wait_until(&self, time: CuInstant)

Spins until a raw deadline from this clock or one of its clones.

pub fn sync_status(&self) -> Option<SyncStatus>

Current domain, uncertainty and synchronization health.

Available with or without clock-sync. Returns None when synchronization is disabled or no discipline has been published. Without the feature this does not read the counter or require synchronization storage.

use cu29_clock::{RobotClock, sync::SyncStatus};

let (clock, _) = RobotClock::mock();
let quality: Option<SyncStatus> = clock.sync_status();
assert_eq!(quality, None);

Trait Implementations

impl Clone for CuContext

fn clone(&self) -> CuContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CuContext

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

Formats the value using the given formatter.

impl Deref for CuContext

type Target = RobotClock

The resulting type after dereferencing.

fn deref(&self) -> &<CuContext as Deref>::Target

Dereferences the value.