Enum InteropError 

pub enum InteropError {
    NotImplemented,
    ValueMismatch {
        value: Box<ScriptValue>,
        expected: Box<TypeId>,
    },
    LengthMismatch {
        expected: usize,
        got: usize,
    },
    FailedFromReflect {
        type_id: Box<Option<TypeId>>,
        reason: Box<String>,
    },
    TypeMismatch {
        expected: Box<TypeId>,
        got: Box<Option<TypeId>>,
    },
    StringTypeMismatch {
        expected: Box<String>,
        got: Box<Option<TypeId>>,
    },
    CannotClaimAccess {
        base: Box<WorldAccessRangeWithDisplay>,
        context: Box<Cow<'static, str>>,
    },
    Invariant(Box<String>),
    UnregisteredComponentOrResourceType {
        type_: Box<TypeId>,
    },
    MissingResource {
        type_: Box<TypeId>,
    },
    UnsupportedOperation {
        base: Box<Option<TypeId>>,
        value: Box<Option<ReflectWrapper>>,
        operation: Box<String>,
    },
    MissingTypeData {
        type_id: Box<TypeId>,
        type_data: Box<String>,
    },
    MissingEntity(Entity),
    FunctionInteropError {
        function_name: Box<String>,
        on: Box<Namespace>,
        error: Box<InteropError>,
        context: Box<Option<FunctionCallContext>>,
    },
    FunctionArgConversionError {
        argument: Box<String>,
        error: Box<InteropError>,
    },
    ArgumentCountMismatch {
        expected: usize,
        got: usize,
    },
    GarbageCollectedAllocation {
        reference: Box<ReflectReference>,
    },
    UnregisteredReflectBase {
        base: Box<ReflectBaseType>,
    },
    ReflectionPathError {
        error: Box<String>,
        reflected: Option<Box<ReflectReference>>,
    },
    CouldNotDowncastReference {
        to: Box<TypeId>,
        reference: Box<ReflectReference>,
    },
    MissingSchedule {
        schedule_name: &'static str,
    },
    InvalidIndex {
        index: Box<ScriptValue>,
        reason: Box<String>,
    },
    MissingWorld,
    External(ExternalError),
    WithContext(Box<Cow<'static, str>>, Box<InteropError>),
}

An error occurring when converting between rust and a script context.

Variants

NotImplemented

The given feature is not implemented

ValueMismatch

A script value was of the wrong type

Fields

value: Box<ScriptValue>

The value with the wrong type

expected: Box<TypeId>

The expected type

LengthMismatch

The length of a list like structure was wrong

Fields

expected: usize

The expected length

got: usize

The actual length

FailedFromReflect

Something failed when converting from a reflect

Fields

type_id: Box<Option<TypeId>>

The type id of the reflect

reason: Box<String>

The reason for the failure

TypeMismatch

A type mismatch occurred

Fields

expected: Box<TypeId>

The expected type

got: Box<Option<TypeId>>

The actual type

StringTypeMismatch

A type mismatch occurred, but with a string representation of the expected type

Fields

expected: Box<String>

The expected type

got: Box<Option<TypeId>>

The actual type

CannotClaimAccess

Could not claim access to a value

Fields

base: Box<WorldAccessRangeWithDisplay>

The id of the access

context: Box<Cow<'static, str>>

The context of the access

Invariant(Box<String>)

An invariant was broken

UnregisteredComponentOrResourceType

An unregistered component or resource type was used

Fields

type_: Box<TypeId>

The typeId

MissingResource

A resource is registered, but not inserted

Fields

type_: Box<TypeId>

The resource type missing.

UnsupportedOperation

An unsupported operation was performed

Fields

base: Box<Option<TypeId>>

The base type of the operation

value: Box<Option<ReflectWrapper>>

The value of the operation

operation: Box<String>

The operation

MissingTypeData

Some type data was missing

Fields

type_id: Box<TypeId>

The type id of the missing data

type_data: Box<String>

The missing type data

MissingEntity(Entity)

An entity was missing

FunctionInteropError

An error occurred in a function

Fields

function_name: Box<String>

The name of the function

on: Box<Namespace>

The namespace of the function

error: Box<InteropError>

The error that occurred

context: Box<Option<FunctionCallContext>>

The context at the time of the call

FunctionArgConversionError

An error occurred when converting a function argument

Fields

argument: Box<String>

The argument that failed to convert

error: Box<InteropError>

The error that occurred

ArgumentCountMismatch

The number of arguments in a function call was wrong

Fields

expected: usize

The expected number of arguments

got: usize

The actual number of arguments

GarbageCollectedAllocation

A garbage collected allocation was used

Fields

reference: Box<ReflectReference>

The reference to the allocation

UnregisteredReflectBase

An unregistered reflect base was used

Fields

base: Box<ReflectBaseType>

The base that was unregistered

ReflectionPathError

An error occurred when using a reflection path

Fields

error: Box<String>

The error that occurred

reflected: Option<Box<ReflectReference>>

The reflected value

CouldNotDowncastReference

Could not downcast a reference

Fields

to: Box<TypeId>

The type to downcast to

reference: Box<ReflectReference>

The reference to downcast

MissingSchedule

A schedule was missing

Fields

schedule_name: &'static str

The name of the schedule

InvalidIndex

An invalid index was used

Fields

index: Box<ScriptValue>

The index that was invalid

reason: Box<String>

The reason the index was invalid

MissingWorld

The world was missing

External(ExternalError)

An external error occurred

WithContext(Box<Cow<'static, str>>, Box<InteropError>)

an error enriched with some contextual information

Tuple Fields

0: Box<Cow<'static, str>>

The context to add

1: Box<InteropError>

The error to add context to

Implementations

impl InteropError

pub fn unwrap_context(self) -> (Vec<Cow<'static, str>>, InteropError)

Strips outer context layers from the error, returning all contexts and the base error

pub fn with_context(self, context: impl Into<Cow<'static, str>>) -> Self

Adds context to an existing error

pub fn external(error: impl Error + Send + Sync + 'static) -> Self

Creates a new external error.

pub fn external_boxed(error: Box<dyn Error + Send + Sync + 'static>) -> Self

Creates a new external error from a boxed error.

pub fn str(reason: &'static str) -> Self

Creates a new external error from a static string.

pub fn string(reason: String) -> Self

Creates a new external error from a string.

pub fn value_mismatch(expected: TypeId, value: ScriptValue) -> Self

Creates a new value mismatch error.

pub fn length_mismatch(expected: usize, got: usize) -> Self

Creates a new length mismatch error.

pub fn failed_from_reflect( type_id: Option<TypeId>, reason: impl Display, ) -> Self

Creates a new failed from reflect error.

pub fn type_mismatch(expected: TypeId, got: Option<TypeId>) -> Self

Creates a new type mismatch error.

pub fn string_type_mismatch(expected: String, got: Option<TypeId>) -> Self

Creates a new string type mismatch error.

pub fn cannot_claim_access( base: WorldAccessRange, context: impl Into<Cow<'static, str>>, ) -> Self

Creates a new cannot claim access error.

pub fn invariant(reason: impl Into<String>) -> Self

Creates a new invariant error.

pub fn unregistered_component_or_resource_type(type_id: TypeId) -> Self

Creates a new unregistered component or resource type error.

pub fn missing_resource(type_id: TypeId) -> Self

Creates a new missing resource type error.

pub fn unsupported_operation( base: Option<TypeId>, value: Option<Box<dyn PartialReflect>>, op: impl Display, ) -> Self

Creates a new unsupported operation error.

pub fn missing_type_data(type_id: TypeId, type_data: String) -> Self

Creates a new missing type data error.

pub fn missing_entity(entity: Entity) -> Self

Creates a new missing entity error.

pub fn reflect_apply_error(e: ApplyError) -> Self

Creates a new reflect apply error.

pub fn function_interop_error( function_name: impl Display, on: Namespace, error: InteropError, context: Option<FunctionCallContext>, ) -> Self

Creates a new function interop error.

pub fn function_arg_conversion_error( argument: String, error: InteropError, ) -> Self

Thrown when an error happens during argument conversion in a function call

pub fn argument_count_mismatch(expected: usize, got: usize) -> Self

Thrown when the number of arguments in a function call does not match.

pub fn garbage_collected_allocation(reference: ReflectReference) -> Self

Creates a new garbage collected allocation error.

pub fn unregistered_base(base: ReflectBaseType) -> Self

Creates a new unregistered base error.

pub fn reflection_path_error( error: String, reflected: Option<ReflectReference>, ) -> Self

Creates a new reflection path error.

pub fn could_not_downcast(reference: ReflectReference, to: TypeId) -> Self

Creates a new could not downcast error.

pub fn missing_schedule(schedule_name: &'static str) -> Self

Creates a new missing schedule error.

pub fn invalid_index(index: ScriptValue, reason: impl Into<String>) -> Self

Creates a new invalid index error.

pub fn missing_world() -> Self

Creates a new missing world error.

pub fn missing_function( function_name: impl Display, on: Namespace, context: Option<FunctionCallContext>, ) -> Self

Creates a new missing function error.

Trait Implementations

impl Clone for InteropError

fn clone(&self) -> InteropError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InteropError

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

Formats the value using the given formatter.

impl DebugWithTypeInfo for InteropError

fn to_string_with_type_info( &self, f: &mut Formatter<'_>, type_info_provider: Option<&WorldAccessGuard<'_>>, ) -> Result

Format the value using the provided type info provider if available

impl Display for InteropError

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

Formats the value using the given formatter.

impl DisplayWithTypeInfo for InteropError

fn display_with_type_info( &self, f: &mut Formatter<'_>, type_info_provider: Option<&WorldGuard<'_>>, ) -> Result

Format the value using the provided type info provider if available

impl Error for InteropError

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<DynWorldAccessError> for InteropError

fn from(value: DynWorldAccessError) -> Self

Converts to this type from the input type.

impl From<InteropError> for ScriptValue

fn from(value: InteropError) -> Self

Converts to this type from the input type.

impl FromReflect for InteropError

fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeDependencies for InteropError

type Underlying = InteropError

In the majority of the implementations, this will be Self However some types might be facades for other types, in which case this will be the underlying type

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers the type dependencies of the implementing type with the given TypeRegistry.

impl GetTypeRegistration for InteropError

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(_registry: &mut TypeRegistry)

Registers other types needed by this type.

impl IntoScript for InteropError

fn into_script( self, _world: WorldGuard<'_>, ) -> Result<ScriptValue, InteropError>

Convert this value into a ScriptValue.

fn into_script_inline_error(self, world: WorldGuard<'_>) -> ScriptValue

where Self: Sized,

Convert this value into a ScriptValue, returning an error as a ScriptValue if an error occurs.

impl PartialReflect for InteropError

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&dyn Reflect>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn reflect_partial_eq( &self, _value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_partial_cmp( &self, _value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

Returns a “partial comparison” result.

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

Debug formatter for the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for InteropError

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl TypePath for InteropError

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for InteropError

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.