Enum ModelError 

pub enum ModelError {
    NotNormalized {
        kind: IdentifierKind,
        value: String,
    },
    ReservedSeparator {
        kind: IdentifierKind,
        value: String,
    },
    MalformedCapabilityReference {
        value: String,
    },
    MalformedAssetId {
        value: String,
    },
    UnknownCapability {
        reference: CapabilityRef,
    },
    CapabilityKindMismatch {
        reference: CapabilityRef,
        expected: CapabilityKind,
        actual: CapabilityKind,
    },
    CapabilityTargetKind {
        reference: CapabilityRef,
        expected: StructuralKind,
    },
    UnknownBoundTarget {
        reference: CapabilityRef,
        kind: StructuralKind,
        id: String,
    },
    UnknownDeclaredTarget {
        component_type: ComponentTypeId,
        capability_id: CapabilityId,
        kind: StructuralKind,
        id: String,
    },
    ComponentIdentityMismatch {
        key: ComponentInstanceId,
        embedded: ComponentInstanceId,
    },
    UnknownComponentType {
        instance: ComponentInstanceId,
        component_type: ComponentTypeId,
    },
    UnknownMountLink {
        instance: ComponentInstanceId,
        link: LinkId,
    },
    DirectionSign {
        instance: ComponentInstanceId,
        capability_id: CapabilityId,
        value: i8,
    },
    UnknownDirectionSignCapability {
        instance: ComponentInstanceId,
        capability_id: CapabilityId,
    },
    UnknownRoleCapability {
        instance: ComponentInstanceId,
        capability_id: CapabilityId,
    },
    EmptyCapabilityRoles {
        instance: ComponentInstanceId,
        capability_id: CapabilityId,
    },
    DuplicateCapabilityRole {
        instance: ComponentInstanceId,
        capability_id: CapabilityId,
        role: CapabilityRole,
    },
    SimulationWithoutComponentType {
        component_type: ComponentTypeId,
    },
    SimulationWithoutCapability {
        component_type: ComponentTypeId,
        capability_id: CapabilityId,
    },
    SimulationCapabilityKindMismatch {
        component_type: ComponentTypeId,
        capability_id: CapabilityId,
        simulated: CapabilityKind,
        declared: CapabilityKind,
    },
    UnsupportedJointKind {
        owner: JointOwner,
        joint: JointId,
        kind: JointKind,
    },
    MotionLimit {
        field: MotionLimitField,
    },
    KinematicScalar {
        kinematics: KinematicKind,
        field: KinematicScalarField,
    },
    FootprintMovableJoint {
        joint: JointId,
    },
    FootprintMesh {
        link: LinkId,
    },
    FootprintNonFinite,
    FootprintRadius,
    Structure(StructureError),
}

A canonical robot model that violates the runtime model’s invariants.

Variants

NotNormalized

An identifier is not a normalized token.

Fields

kind: IdentifierKind

value: String

ReservedSeparator

An identifier contains the separator reserved for flattening a component’s structure into the robot’s.

Fields

kind: IdentifierKind

value: String

MalformedCapabilityReference

A capability reference is not written as component.capability.

Fields

value: String

MalformedAssetId

A logical asset id is not a normalized relative forward-slash path.

Fields

value: String

UnknownCapability

A reference names a capability the robot does not declare.

Fields

reference: CapabilityRef

CapabilityKindMismatch

A capability is not of the kind the caller requires.

Fields

reference: CapabilityRef

expected: CapabilityKind

actual: CapabilityKind

CapabilityTargetKind

A capability does not target the kind of structural item the caller requires.

Fields

reference: CapabilityRef

expected: StructuralKind

UnknownBoundTarget

A bound capability targets a structural item its component type does not define.

Fields

reference: CapabilityRef

kind: StructuralKind

id: String

UnknownDeclaredTarget

A component type’s capability targets a structural item that type does not define.

Fields

component_type: ComponentTypeId

capability_id: CapabilityId

kind: StructuralKind

id: String

ComponentIdentityMismatch

A component instance is filed under an id other than its own.

Fields

key: ComponentInstanceId

embedded: ComponentInstanceId

UnknownComponentType

A component instance names a component type the model did not load.

Fields

instance: ComponentInstanceId

component_type: ComponentTypeId

UnknownMountLink

A component instance mounts on a link the robot structure lacks.

Fields

instance: ComponentInstanceId

link: LinkId

DirectionSign

A direction sign is neither -1 nor 1.

Fields

instance: ComponentInstanceId

capability_id: CapabilityId

value: i8

UnknownDirectionSignCapability

A direction sign names a capability its component type does not declare.

Fields

instance: ComponentInstanceId

capability_id: CapabilityId

UnknownRoleCapability

A capability role assignment names a capability its component type does not declare.

Fields

instance: ComponentInstanceId

capability_id: CapabilityId

EmptyCapabilityRoles

A persisted role key must name at least one role.

Fields

instance: ComponentInstanceId

capability_id: CapabilityId

DuplicateCapabilityRole

A persisted role list may not repeat a role and rely on set coercion.

Fields

instance: ComponentInstanceId

capability_id: CapabilityId

role: CapabilityRole

SimulationWithoutComponentType

A simulation type has no component type to simulate.

Fields

component_type: ComponentTypeId

SimulationWithoutCapability

A simulated capability has no counterpart on the component type.

Fields

component_type: ComponentTypeId

capability_id: CapabilityId

SimulationCapabilityKindMismatch

A simulated capability models a different kind than the component declares, so the simulator would drive the wrong device.

Fields

component_type: ComponentTypeId

capability_id: CapabilityId

simulated: CapabilityKind

declared: CapabilityKind

UnsupportedJointKind

A joint uses a kind the runtime cannot drive.

Fields

owner: JointOwner

joint: JointId

kind: JointKind

MotionLimit

A motion limit is not finite, positive, and representable as f32.

The f32 bound is not cosmetic: motion commands cross the bus as f32, so a limit that does not survive the narrowing is not a limit.

Fields

field: MotionLimitField

KinematicScalar

A kinematic scalar is not finite and positive.

Fields

kinematics: KinematicKind

field: KinematicScalarField

FootprintMovableJoint

Stock safety cannot conservatively account for a collision shape that is attached below a movable joint.

Fields

joint: JointId

FootprintMesh

Mesh dimensions depend on asset contents and therefore cannot be compiled into the source-free stock safety envelope.

Fields

link: LinkId

FootprintNonFinite

A footprint scalar must remain finite after all fixed-joint transforms.

FootprintRadius

A compiled footprint radius is invalid, which must never enter a runtime bundle or authorize motion.

Structure(StructureError)

The canonical structure itself is invalid.

Trait Implementations

impl Debug for ModelError

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

Formats the value using the given formatter.

impl Display for ModelError

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

Formats the value using the given formatter.

impl Error for ModelError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl From<StructureError> for ModelError

fn from(source: StructureError) -> Self

Converts to this type from the input type.

impl From<TopologyIdError> for ModelError

fn from(error: TopologyIdError) -> Self

Converts to this type from the input type.