Struct OpaqueError

pub struct OpaqueError(/* private fields */);

A wrapper to make a Error Send + Sync.

Error is not Send or Sync as it provides a way to call some of Ruby’s APIs, which are not safe to call from a non-Ruby thread.

Error is safe to send between Ruby threads, but Rust’s trait system currently can not model this detail.

To resolve this, the OpaqueError type makes an Error Send + Sync by removing the ability use it with any Ruby APIs.

OpaqueError::into_error_with provides a way to safely get an Error from a OpaqueError].

Note that OpaqueError contains a Ruby value, so must be kept on the stack of a Ruby thread to prevent it from being Garbage Collected (or otherwise protected from premature GC).

Implementations

impl OpaqueError

pub fn into_error_with(this: Self, handle: &Ruby) -> Error

Convert an OpaqueError into an Error.

Examples

use magnus::{error::OpaqueError, Error, Ruby};

let ruby = Ruby::get().unwrap(); // errors on non-Ruby thread
let opaque_err = OpaqueError::from(Error::new(ruby.exception_runtime_error(), "test"));

// send to another Ruby thread

let ruby = Ruby::get().unwrap(); // errors on non-Ruby thread
let err = OpaqueError::into_error_with(opaque_err, &ruby);
assert!(err.is_kind_of(ruby.exception_runtime_error()));

Trait Implementations

impl Clone for OpaqueError

fn clone(&self) -> OpaqueError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<Error> for OpaqueError

fn from(err: Error) -> Self

Converts to this type from the input type.

impl IntoError for OpaqueError

fn into_error(self, _: &Ruby) -> Error

Convert self into Error.

impl Send for OpaqueError

impl Sync for OpaqueError