Struct Robot 

pub struct Robot { /* private fields */ }

Fully normalized runtime-facing robot model.

Implementations

impl Robot

pub const fn id(&self) -> &RobotId

pub const fn clock(&self) -> Clock

The time domain this robot runs on.

pub const fn motion(&self) -> &MotionModel

pub fn components(&self) -> impl ExactSizeIterator<Item = &ComponentInstance>

Every mounted component instance, ordered by instance id.

pub fn component_ids( &self, ) -> impl ExactSizeIterator<Item = &ComponentInstanceId>

Every mounted instance’s identity, ordered.

pub fn component_instance(&self, id: &str) -> Option<&ComponentInstance>

The named instance, if the robot mounts one.

pub fn component_for_instance(&self, id: &str) -> Option<&Component>

The component type behind the named instance.

Absent exactly when the instance is: a validated robot never mounts an instance of a type it did not load.

pub fn simulation_for_component_type( &self, component_type: &str, ) -> Option<&Simulation>

The simulation for a component type, when one was authored.

pub fn simulation_for_instance(&self, component_id: &str) -> Option<&Simulation>

The simulation behind the named instance, when one was authored.

pub const fn structure(&self) -> &Structure

The robot’s own structure, in flattened runtime identities.

pub const fn footprint_envelope(&self) -> Option<FootprintEnvelope>

The persisted compiler-derived stock-safety envelope, if available.

pub fn capability(&self, reference: &CapabilityRef) -> Option<&Capability>

The referenced capability, if the robot declares it.

pub fn capability_refs( &self, selects: impl Fn(&Capability) -> bool, ) -> Vec<CapabilityRef>

Every declared capability matching selects.

The result is ordered by (component id, capability id). That order is an invariant, not an accident of iteration: participants derive bus identities and arbitration priorities from these positions, so two runs over the same robot must produce the same sequence.

This is infallible because a Robot value cannot exist with an instance whose component type is absent: validation rejects that with ModelError::UnknownComponentType before the value is constructed. The unresolved arm below is therefore unreachable rather than a capability being quietly dropped, and it stays a skip rather than a panic so that the impossible case degrades into a smaller result set instead of taking the process down.

pub fn capabilities_with_role(&self, role: CapabilityRole) -> Vec<CapabilityRef>

Every capability assigned the given authored role, ordered by (component id, capability id).

pub fn require_motor( &self, reference: &CapabilityRef, ) -> Result<(&Motor, i8), ModelError>

The referenced motor and the direction sign to apply to it.

Errors

Returns ModelError::UnknownCapability when the robot does not declare the capability, and ModelError::CapabilityKindMismatch when it declares something other than a motor.

pub fn require_encoder( &self, reference: &CapabilityRef, ) -> Result<(&Encoder, i8), ModelError>

The referenced encoder and the direction sign to apply to it.

Errors

Returns ModelError::UnknownCapability when the robot does not declare the capability, and ModelError::CapabilityKindMismatch when it declares something other than an encoder.

pub fn link_target_frame( &self, reference: &CapabilityRef, ) -> Result<LinkId, ModelError>

The namespaced runtime frame for a capability’s component-local link.

Errors

Returns ModelError::CapabilityTargetKind when the capability is attached to a joint rather than a link, and ModelError::UnknownBoundTarget when its component type has no such link.

Trait Implementations

impl Clone for Robot

fn clone(&self) -> Robot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Robot

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

Formats the value using the given formatter.

impl DescribeWire for Robot

fn wire_schema() -> WireSchema

The shape a value of this type puts on the wire.

impl<'de> Deserialize<'de> for Robot

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Serialize for Robot

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.