Struct Snapshot 

pub struct Snapshot {
    pub execution_id: Option<String>,
    pub root: Option<DefinitionRef>,
    pub definition_stack: Vec<DefinitionRef>,
    pub active_request_id: Option<RequestId>,
    pub active_behavior_id: Option<String>,
    pub status: ExecutionStatus,
    pub node_statuses: BTreeMap<String, NodeStatus>,
    pub active_node_path: Option<String>,
    pub blackboard: BTreeMap<String, Value>,
    pub args: BTreeMap<String, Value>,
    pub started_at: Option<RobotInstant>,
    pub failure: Option<Failure>,
}

Fields

execution_id: Option<String>

root: Option<DefinitionRef>

definition_stack: Vec<DefinitionRef>

active_request_id: Option<RequestId>

active_behavior_id: Option<String>

status: ExecutionStatus

node_statuses: BTreeMap<String, NodeStatus>

active_node_path: Option<String>

blackboard: BTreeMap<String, Value>

args: BTreeMap<String, Value>

started_at: Option<RobotInstant>

When the active execution started, on the publisher’s timeline. The envelope carries when this snapshot was produced; that instant is never duplicated here.

failure: Option<Failure>

Trait Implementations

impl Clone for Snapshot

fn clone(&self) -> Snapshot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ContractBody for Snapshot

const NAME: &'static str = "v0.1::behavior::Snapshot"

The version-qualified type identity: the dotted wire revision, then the ::-joined node path (dynamic-node vars are topic params, never type-path segments), then the PascalCase type leaf, e.g. "v0.1::drive::Target" or "v0.1::component::motor::Command". This is the contract’s source identity (D1) - two contracts interoperate iff they share this exact name - as distinct from TOPIC, the resolved wire key derived from it. NAME is exactly the "::"-join of VERSION and CONTRACT; it stays available for callers that want the whole identity as one string (e.g. display), while consumers that must reason about the revision and the contract independently use the two split consts instead - a joined name is not machine-parseable without assuming the version naming scheme.

const VERSION: &'static str = "v0.1"

This body’s dotted wire revision alone, e.g. "v0.1" - equal to <Self::Api as ApiVersion>::ID, but exposed directly on the body so a metadata or diagnostics recorder can const-splice it without routing through Self::Api. Split from CONTRACT so a consumer can read the revision without parsing a joined name.

const CONTRACT: &'static str = "behavior::Snapshot"

This body’s contract path within its own version: the ::-joined node path (dynamic-node vars excluded, as with NAME) plus the PascalCase type leaf, e.g. "drive::Target". The logical contract - stable across a version bump - is this value alone; pairing it with VERSION recovers the full version-qualified identity (NAME).

const TOPIC: &'static str = "v0.1/behavior/snapshot"

The version-qualified wire key: the dotted wire revision, then the /-joined node path plus the topic leaf, with each dynamic node contributing a {var} placeholder, e.g. "v0.1/drive/state" or "v0.1/component/{instance}/motor/{capability}/command". The concrete key is produced by the api-local topic builder, which fills the placeholders.

const ROLE: TopicRole = ::phoxal_bus::TopicRole::State

The topic role this body was declared with, which fixes both the side brand and the robot time a publisher of it can express.

type Api = Api

The single API version this body belongs to. Two bodies from different versions have different Api, so the type system keeps them apart.

impl Debug for Snapshot

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Snapshot

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Snapshot

fn eq(&self, other: &Snapshot) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Snapshot

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StateContract for Snapshot

impl StructuralPartialEq for Snapshot