Struct godot::builtin::meta::CallError

pub struct CallError { /* private fields */ }

Error capable of representing failed function calls.

This type is returned from varcall functions in the Godot API that begin with try_ prefixes, e.g. Object::try_call() or Node::try_rpc(). Varcall refers to the “variant call” calling convention, meaning that arguments and return values are passed as Variant (as opposed to ptrcall, which passes direct pointers to Rust objects).

Allows to inspect the involved class and method via class_name() and method_name(). Implements the std::error::Error trait, so it comes with Display and Error::source() APIs.

Possible error causes

Several reasons can cause a function call to fail. The reason is described in the Display impl.

• Invalid method: The method does not exist on the object.
• Failed argument conversion: The arguments passed to the method cannot be converted to the declared parameter types.
• Failed return value conversion: The returned Variant of a dynamic method cannot be converted to the expected return type.
• Too many or too few arguments: The number of arguments passed to the method does not match the number of parameters.
• User panic: A Rust method caused a panic.

Chained errors

Let’s say you have this code, and you want to call the method dynamically with Object::try_call().

Then, the immediate CallError will refer to the Object::try_call method, and its source will refer to MyClass::my_method (the actual method that failed).

use godot::prelude::*;
use std::error::Error;
#[derive(GodotClass)]
struct MyClass;

#[godot_api]
impl MyClass {
    #[func]
    fn my_method(&self, arg: i64) {}
}

fn some_method() {
    let mut obj: Gd<MyClass> = MyClass::new_gd();

    // Dynamic call. Note: forgot to pass the argument.
    let result: Result<Variant, CallError> = obj.try_call("my_method".into(), &[]);

    // Get immediate and original errors.
    // Note that source() can be None or of type ConvertError.
    let outer: CallError = result.unwrap_err();
    let inner: &CallError = outer.source().unwrap().downcast_ref::<CallError>().unwrap();

    // Immediate error: try_call() internally invokes Object::call().
    assert_eq!(outer.class_name(), Some("Object"));
    assert_eq!(outer.method_name(), "call");

    // Original error: my_method() failed.
    assert_eq!(inner.class_name(), Some("MyClass"));
    assert_eq!(inner.method_name(), "my_method");
}

Implementations

impl CallError

pub fn class_name(&self) -> Option<&str>

Name of the class/builtin whose method failed. Not the dynamic type.

Returns None if this is a utility function (without a surrounding class/builtin).

This is the static and not the dynamic type. For example, if you invoke call() on a Gd<Node>, you are effectively invoking Object::call() (through DerefMut), and the class name will be Object.

pub fn method_name(&self) -> &str

Name of the function or method that failed.

Trait Implementations

impl Debug for CallError

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

Formats the value using the given formatter.

impl Display for CallError

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

Formats the value using the given formatter.

impl Error for CallError

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

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.