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<ReflectAccessId>,
        location: Box<Option<Location<'static>>>,
        context: Box<Cow<'static, str>>,
    },
    Invariant(Box<String>),
    UnregisteredComponentOrResourceType {
        type_name: Box<Cow<'static, str>>,
    },
    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>,
    },
    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<ReflectAccessId>

The id of the access

location: Box<Option<Location<'static>>>

The location 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_name: Box<Cow<'static, str>>

The name of the type

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

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>>) -> InteropError

Adds context to an existing error

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

Creates a new external error.

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

Creates a new external error from a boxed error.

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

Creates a new external error from a static string.

pub fn string(reason: String) -> InteropError

Creates a new external error from a string.

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

Creates a new value mismatch error.

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

Creates a new length mismatch error.

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

Creates a new failed from reflect error.

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

Creates a new type mismatch error.

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

Creates a new string type mismatch error.

pub fn cannot_claim_access( base: ReflectAccessId, location: Option<Location<'static>>, context: impl Into<Cow<'static, str>>, ) -> InteropError

Creates a new cannot claim access error.

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

Creates a new invariant error.

pub fn unregistered_component_or_resource_type( type_name: impl Into<Cow<'static, str>>, ) -> InteropError

Creates a new unregistered component or resource type error.

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

Creates a new unsupported operation error.

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

Creates a new missing type data error.

pub fn missing_entity(entity: Entity) -> InteropError

Creates a new missing entity error.

pub fn reflect_apply_error(e: ApplyError) -> InteropError

Creates a new reflect apply error.

pub fn function_interop_error( function_name: impl Display, on: Namespace, error: InteropError, ) -> InteropError

Creates a new function interop error.

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

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

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

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

pub fn garbage_collected_allocation(reference: ReflectReference) -> InteropError

Creates a new garbage collected allocation error.

pub fn unregistered_base(base: ReflectBaseType) -> InteropError

Creates a new unregistered base error.

pub fn reflection_path_error<'a>( error: ReflectPathError<'a>, reflected: Option<ReflectReference>, ) -> InteropError

Creates a new reflection path error.

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

Creates a new could not downcast error.

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

Creates a new missing schedule error.

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

Creates a new invalid index error.

pub fn missing_world() -> InteropError

Creates a new missing world error.

pub fn missing_function( function_name: impl Display, on: Namespace, ) -> InteropError

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<(), Error>

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<&dyn GetTypeInfo>, ) -> Result<(), Error>

Format the value using the provided type info provider if available

impl Display for InteropError

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

Formats the value using the given formatter.

impl DisplayWithTypeInfo for InteropError

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

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<O> FlattenError<O, InteropError> for Result<Result<O, InteropError>, InteropError>

fn flatten_interop_error(self) -> Result<O, InteropError>

Flattens the error into a single error type

impl From<InteropError> for ScriptError

fn from(val: InteropError) -> ScriptError

Converts to this type from the input type.

impl From<InteropError> for ScriptValue

fn from(value: InteropError) -> ScriptValue

Converts to this type from the input type.

impl FromReflect for InteropError

where InteropError: Any + Send + Sync,

fn from_reflect( reflect: &(dyn PartialReflect + 'static), ) -> Option<InteropError>

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

where InteropError: Any + Send + Sync,

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

fn to_lua_error(self) -> Error

Convert into mlua::Error

impl IntoRhaiError for InteropError

fn into_rhai_error(self) -> Box<EvalAltResult>

Converts the error into an InteropError

impl IntoScript for InteropError

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

Convert this value into a ScriptValue.

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

where Self: Sized,

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

impl PartialReflect for InteropError

where InteropError: Any + Send + Sync,

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 + 'static), ) -> 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<InteropError>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<InteropError>, ) -> 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 + 'static)>

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

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

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

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

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

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

Applies a reflected value to this value.

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

👎Deprecated since 0.16.0: to clone reflected values, prefer using reflect_clone. To convert reflected values to dynamic ones, use to_dynamic.

Clones Self into its dynamic representation.

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

Attempts to clone Self using reflection.

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 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

where InteropError: Any + Send + Sync,

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

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

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

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

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

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

where InteropError: Any + Send + Sync,

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

where InteropError: Any + Send + Sync,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.