Trait ruru::traits::Object [−] [src]

pub trait Object: From<Value> {
    fn value(&self) -> Value;

    fn class(&self) -> Class { ... }
    fn send(&self, method: &str, arguments: Vec<AnyObject>) -> AnyObject { ... }
    fn to_any_object(&self) -> AnyObject { ... }
    fn instance_variable_get(&self, variable: &str) -> AnyObject { ... }
    fn instance_variable_set<T: Object>(&mut self, variable: &str, value: T) -> AnyObject { ... }
}

Object

Trait consists methods of Ruby Object class. Every struct like Array, Hash etc implements this trait.

Required Methods

fn value(&self) -> Value

Usually this function just returns a value of current object.

Examples

use ruru::types::Value;
use ruru::traits::Object;

struct Array {
    value: Value
}

impl From<Value> for Array {
    fn from(value: Value) -> Self {
        Array {
            value: value
        }
    }
}

impl Object for Array {
    fn value(&self) -> Value {
        self.value
    }
}

Provided Methods

fn class(&self) -> Class

Returns a Class struct of current object

Examples

use ruru::{Array, VM};
use ruru::traits::Object;

assert_eq!(Array::new().class(), Array::new().class());

fn send(&self, method: &str, arguments: Vec<AnyObject>) -> AnyObject

Calls a given method on an object similarly to Ruby Object#send method

Examples

use ruru::{Array, Fixnum, RString, VM};
use ruru::traits::Object;

let array = Array::new().push(Fixnum::new(1));
let array_to_str =
    array
        .send("to_s", vec![])
        .to::<RString>()
        .to_string();

assert_eq!(array_to_str, "[1]".to_string());

fn to_any_object(&self) -> AnyObject

Converts struct to AnyObject

See docs for AnyObject class for more details.

Examples

use ruru::{Array, Fixnum, VM};
use ruru::traits::Object;

let array = Array::new().push(Fixnum::new(1));
let args = vec![Fixnum::new(1).to_any_object()];
let index =
    array
        .send("find_index", args)
        .to::<Fixnum>()
        .to_i64();

assert_eq!(index, 0);

fn instance_variable_get(&self, variable: &str) -> AnyObject

Sets an instance variable for object

Examples

use ruru::{AnyObject, Class, Fixnum, VM};
use ruru::types::Argc;
use ruru::traits::Object;

#[no_mangle]
pub extern fn counter_initialize(_: Argc,
                                 _: *const AnyObject,
                                 mut itself: AnyObject) -> AnyObject {
    itself.instance_variable_set("@state", Fixnum::new(0))
}

#[no_mangle]
pub extern fn counter_increment(_: Argc,
                                _: *const AnyObject,
                                mut itself: AnyObject) -> AnyObject {
    let state = itself.instance_variable_get("@state").to::<Fixnum>().to_i64();

    itself.instance_variable_set("@state", Fixnum::new(state + 1))
}

#[no_mangle]
pub extern fn counter_state(_: Argc, _: *const AnyObject, itself: AnyObject) -> Fixnum {
    itself.instance_variable_get("@state").to::<Fixnum>()
}

fn main() {
    let counter = Class::new("Counter").define(|itself| {
        itself.def("initialize", counter_initialize);
        itself.def("increment!", counter_increment);
        itself.def("state", counter_state);
    }).new_instance(vec![]);

    counter.send("increment!", vec![]);

    let new_state = counter.send("state", vec![]).to::<Fixnum>().to_i64();

    assert_eq!(new_state, 1);
}

fn instance_variable_set<T: Object>(&mut self, variable: &str, value: T) -> AnyObject

Gets an instance variable of object

Examples

use ruru::{AnyObject, Class, Fixnum, VM};
use ruru::types::Argc;
use ruru::traits::Object;

#[no_mangle]
pub extern fn counter_initialize(_: Argc,
                                 _: *const AnyObject,
                                 mut itself: AnyObject) -> AnyObject {
    itself.instance_variable_set("@state", Fixnum::new(0))
}

#[no_mangle]
pub extern fn counter_increment(_: Argc,
                                _: *const AnyObject,
                                mut itself: AnyObject) -> AnyObject {
    let state = itself.instance_variable_get("@state").to::<Fixnum>().to_i64();

    itself.instance_variable_set("@state", Fixnum::new(state + 1))
}

#[no_mangle]
pub extern fn counter_state(_: Argc, _: *const AnyObject, itself: AnyObject) -> Fixnum {
    itself.instance_variable_get("@state").to::<Fixnum>()
}

fn main() {
    let counter = Class::new("Counter").define(|itself| {
        itself.def("initialize", counter_initialize);
        itself.def("increment!", counter_increment);
        itself.def("state", counter_state);
    }).new_instance(vec![]);

    counter.send("increment!", vec![]);

    let new_state = counter.send("state", vec![]).to::<Fixnum>().to_i64();

    assert_eq!(new_state, 1);
}

Implementors