Struct magnus::RTypedData

source ·

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

Expand description

A Value pointer to a RTypedData struct, Ruby’s internal representation of objects that wrap foreign types.

Implementations§

source §

impl RTypedData

source

pub fn from_value(val: Value) -> Option<Self>

Return Some(RTypedData) if val is a RTypedData, None otherwise.

§Examples

use magnus::{class, define_class, eval, function, prelude::*, RTypedData};

#[magnus::wrap(class = "Point")]
struct Point {
    x: isize,
    y: isize,
}

let point_class = define_class("Point", class::object()).unwrap();
point_class
    .define_singleton_method("new", function!(|x, y| Point { x, y }, 2))
    .unwrap();

assert!(RTypedData::from_value(eval(r#"Point.new(1, 2)"#).unwrap()).is_some());
assert!(RTypedData::from_value(eval(r#"Object.new"#).unwrap()).is_none());

source

pub fn wrap<T>(data: T) -> Self
where T: TypedData,

Wrap the Rust type T in a Ruby object.

§Panics

Panics if called from a non-Ruby thread. See Ruby::wrap for the non-panicking version.

§Examples

use magnus::{class, define_class, prelude::*, RTypedData};

#[magnus::wrap(class = "Point")]
struct Point {
    x: isize,
    y: isize,
}

let point_class = define_class("Point", class::object()).unwrap();

let value = RTypedData::wrap(Point { x: 4, y: 2 });
assert!(value.is_kind_of(point_class));

source

pub fn wrap_as<T>(data: T, class: RClass) -> Self
where T: TypedData,

Wrap the Rust type T in a Ruby object that is an instance of the given class.

§Panics

Panics if class is not a subclass of <T as TypedData>::class(), or if called from a non-Ruby thread. See Ruby::wrap_as for a version that can not be called from a non-Ruby thread, so will not panic for that reason.

§Examples

use magnus::{class, define_class, prelude::*, RTypedData};

#[magnus::wrap(class = "Point")]
struct Point {
    x: isize,
    y: isize,
}

let point_class = define_class("Point", class::object()).unwrap();
let point_sub_class = define_class("SubPoint", point_class).unwrap();

let value = RTypedData::wrap_as(Point { x: 4, y: 2 }, point_sub_class);
assert!(value.is_kind_of(point_sub_class));
assert!(value.is_kind_of(point_class));

Allowing a wrapped type to be subclassed from Ruby:

(note, in this example Point does not have and does not call the initialize method, subclasses would need to override the class new method rather than initialize)

use magnus::{
    class, define_class, eval, function, method, prelude::*, RClass, RTypedData, Value,
};

#[magnus::wrap(class = "Point")]
struct Point {
    x: isize,
    y: isize,
}

impl Point {
    fn new(class: RClass, x: isize, y: isize) -> RTypedData {
        RTypedData::wrap_as(Self { x, y }, class)
    }
}

let point_class = define_class("Point", class::object()).unwrap();
point_class
    .define_singleton_method("new", method!(Point::new, 2))
    .unwrap();
point_class
    .define_singleton_method("inherited", function!(RClass::undef_default_alloc_func, 1))
    .unwrap();

let value: Value = eval(
    r#"
      class SubPoint < Point
      end
      SubPoint.new(4, 2)
    "#,
)
.unwrap();

assert!(value.is_kind_of(class::object().const_get::<_, RClass>("SubPoint").unwrap()));
assert!(value.is_kind_of(point_class));

source

pub fn get<T>(&self) -> Result<&T, Error>
where T: TypedData,

Get a reference to the Rust type wrapped in the Ruby object self.

§Examples

use magnus::{class, define_class, RTypedData};

#[magnus::wrap(class = "Point")]
#[derive(Debug, PartialEq, Eq)]
struct Point {
    x: isize,
    y: isize,
}

define_class("Point", class::object()).unwrap();
let value = RTypedData::wrap(Point { x: 4, y: 2 });

assert_eq!(value.get::<Point>().unwrap(), &Point { x: 4, y: 2 });