Struct rutie::Class [−][src]
Class
Also see def
, def_self
, define
and some more functions from Object
trait.
#[macro_use] extern crate rutie; use std::error::Error; use rutie::{Class, Fixnum, Object, Exception, VM}; methods!( Fixnum, rtself, fn pow(exp: Fixnum) -> Fixnum { // `exp` is not a valid `Fixnum`, raise an exception if let Err(ref error) = exp { VM::raise(error.class(), &error.message()); } // We can safely unwrap here, because an exception was raised if `exp` is `Err` let exp = exp.unwrap().to_i64() as u32; Fixnum::new(rtself.to_i64().pow(exp)) } ); fn main() { Class::from_existing("Fixnum").define(|klass| { klass.def("pow", pow); }); }
Ruby:
class Fixnum
def pow(exp)
raise TypeError unless exp.is_a?(Fixnum)
self ** exp
end
end
Implementations
impl Class
[src]
pub fn new(name: &str, superclass: Option<&Self>) -> Self
[src]
Creates a new Class
.
superclass
can receive the following values:
None
to inherit fromObject
class (standard Ruby behavior when superclass is not given explicitly);Some(&Class)
to inherit from the given class
Examples
use rutie::{Class, VM}; let basic_record_class = Class::new("BasicRecord", None); assert_eq!(basic_record_class, Class::from_existing("BasicRecord")); assert_eq!(basic_record_class.superclass(), Some(Class::from_existing("Object"))); let record_class = Class::new("Record", Some(&basic_record_class)); assert_eq!(record_class, Class::from_existing("Record")); assert_eq!(record_class.superclass(), Some(Class::from_existing("BasicRecord")));
Ruby:
class BasicRecord
end
class Record < BasicRecord
end
BasicRecord.superclass == Object
Record.superclass == BasicRecord
pub fn from_existing(name: &str) -> Self
[src]
Retrieves an existing Class
object.
Examples
use rutie::{Class, VM}; let class = Class::new("Record", None); assert_eq!(class, Class::from_existing("Record"));
Ruby:
class Record
end
# get class
Record
# or
Object.const_get('Record')
pub fn new_instance(&self, arguments: &[AnyObject]) -> AnyObject
[src]
Creates a new instance of Class
Arguments must be passed as a vector of AnyObject
(see example).
Examples
use rutie::{Class, Fixnum, Object}; // Without arguments Class::from_existing("Hello").new_instance(&[]); // With arguments passing arguments to constructor let arguments = [ Fixnum::new(1).to_any_object(), Fixnum::new(2).to_any_object() ]; Class::from_existing("Worker").new_instance(&arguments);
Ruby:
Hello.new
Worker.new(1, 2)
pub fn allocate(&self) -> Class
[src]
Creates a new instance of Class
Examples
use rutie::{Class, Object}; Class::from_existing("String").allocate();
Ruby:
String.allocate
pub fn superclass(&self) -> Option<Class>
[src]
Returns a superclass of the current class
Examples
use rutie::{Class, Object, VM}; assert_eq!( Class::from_existing("Array").superclass(), Some(Class::from_existing("Object")) ); assert_eq!(Class::from_existing("BasicObject").superclass(), None);
pub fn ancestors(&self) -> Vec<Class>
[src]
Returns a Vector of ancestors of current class
Examples
Getting all the ancestors
use rutie::{Class, VM}; let true_class_ancestors = Class::from_existing("TrueClass").ancestors(); let expected_ancestors = vec![ Class::from_existing("TrueClass"), Class::from_existing("Object"), Class::from_existing("Kernel"), Class::from_existing("BasicObject") ]; assert_eq!(true_class_ancestors, expected_ancestors);
Searching for an ancestor
use rutie::{Class, VM}; let basic_record_class = Class::new("BasicRecord", None); let record_class = Class::new("Record", Some(&basic_record_class)); let ancestors = record_class.ancestors(); assert!(ancestors.iter().any(|class| *class == basic_record_class));
pub fn get_nested_class(&self, name: &str) -> Self
[src]
Retrieves a Class
nested to current Class
.
Examples
use rutie::{Class, Object, VM}; Class::new("Outer", None).define(|klass| { klass.define_nested_class("Inner", None); }); Class::from_existing("Outer").get_nested_class("Inner");
Ruby:
class Outer
class Inner
end
end
Outer::Inner
# or
Outer.const_get('Inner')
pub fn get_nested_module(&self, name: &str) -> Module
[src]
Retrieves a Module
nested to current Class
.
Examples
use rutie::{Class, Module, Object, VM}; Class::new("Outer", None).define(|klass| { klass.define_nested_module("Inner"); }); Class::from_existing("Outer").get_nested_module("Inner");
Ruby:
class Outer
module Inner
end
end
Outer::Inner
# or
Outer.const_get('Inner')
pub fn define_nested_class(
&mut self,
name: &str,
superclass: Option<&Class>
) -> Self
[src]
&mut self,
name: &str,
superclass: Option<&Class>
) -> Self
Creates a new Class
nested into current class.
superclass
can receive the following values:
None
to inherit fromObject
class (standard Ruby behavior when superclass is not given explicitly);Some(&class)
to inherit from the given class
Examples
use rutie::{Class, Object, VM}; Class::new("Outer", None).define(|klass| { klass.define_nested_class("Inner", None); }); Class::from_existing("Outer").get_nested_class("Inner");
Ruby:
class Outer
class Inner
end
end
Outer::Inner
# or
Outer.const_get('Inner')
pub fn define_nested_module(&mut self, name: &str) -> Module
[src]
Creates a new Module
nested into current Class
.
Examples
use rutie::{Class, Module, Object, VM}; Class::new("Outer", None).define(|klass| { klass.define_nested_module("Inner"); }); Module::from_existing("Outer").get_nested_module("Inner");
Ruby:
class Outer
module Inner
end
end
Outer::Inner
# or
Outer.const_get('Inner')
pub fn const_get(&self, name: &str) -> AnyObject
[src]
Retrieves a constant from class.
Examples
use rutie::{Class, Object, RString, VM}; Class::new("Greeter", None).define(|klass| { klass.const_set("GREETING", &RString::new_utf8("Hello, World!")); }); let greeting = Class::from_existing("Greeter") .const_get("GREETING") .try_convert_to::<RString>() .unwrap(); assert_eq!(greeting.to_str(), "Hello, World!");
Ruby:
class Greeter
GREETING = 'Hello, World!'
end
# or
Greeter = Class.new
Greeter.const_set('GREETING', 'Hello, World!')
# ...
Greeter::GREETING == 'Hello, World!'
# or
Greeter.const_get('GREETING') == 'Hello, World'
pub fn const_set<T: Object>(&mut self, name: &str, value: &T)
[src]
Defines a constant for class.
Examples
use rutie::{Class, Object, RString, VM}; Class::new("Greeter", None).define(|klass| { klass.const_set("GREETING", &RString::new_utf8("Hello, World!")); }); let greeting = Class::from_existing("Greeter") .const_get("GREETING") .try_convert_to::<RString>() .unwrap(); assert_eq!(greeting.to_str(), "Hello, World!");
Ruby:
class Greeter
GREETING = 'Hello, World!'
end
# or
Greeter = Class.new
Greeter.const_set('GREETING', 'Hello, World!')
# ...
Greeter::GREETING == 'Hello, World!'
# or
Greeter.const_get('GREETING') == 'Hello, World'
pub fn include(&self, md: &str)
[src]
Includes module into current class
Examples
use rutie::{Class, Module, VM}; let a_module = Module::new("A"); Class::new("B", None).include("A"); let b_class_ancestors = Class::from_existing("B").ancestors(); let expected_ancestors = vec![Module::from_existing("A")]; assert!(expected_ancestors.iter().any(|anc| *anc == a_module));
pub fn prepend(&self, md: &str)
[src]
Prepends module into current class
Examples
use rutie::{Class, Module, VM}; let a_module = Module::new("A"); Class::new("B", None).prepend("A"); let b_class_ancestors = Class::from_existing("B").ancestors(); let expected_ancestors = vec![Module::from_existing("A")]; assert!(expected_ancestors.iter().any(|anc| *anc == a_module));
pub fn attr_reader(&mut self, name: &str)
[src]
Defines an attr_reader
for class
Examples
use rutie::{Class, Object, VM}; Class::new("Test", None).define(|klass| { klass.attr_reader("reader"); });
Ruby:
class Test
attr_reader :reader
end
pub fn attr_writer(&mut self, name: &str)
[src]
Defines an attr_writer
for class
Examples
use rutie::{Class, Object, VM}; Class::new("Test", None).define(|klass| { klass.attr_writer("writer"); });
Ruby:
class Test
attr_writer :writer
end
pub fn attr_accessor(&mut self, name: &str)
[src]
Defines an attr_accessor
for class
Examples
use rutie::{Class, Object, VM}; Class::new("Test", None).define(|klass| { klass.attr_accessor("accessor"); });
Ruby:
class Test
attr_accessor :accessor
end
pub fn wrap_data<T, O: Object>(
&self,
data: T,
wrapper: &dyn DataTypeWrapper<T>
) -> O
[src]
&self,
data: T,
wrapper: &dyn DataTypeWrapper<T>
) -> O
Wraps Rust structure into a new Ruby object of the current class.
See the documentation for wrappable_struct!
macro for more information.
Examples
Wrap Server
structs to RubyServer
objects
#[macro_use] extern crate rutie; #[macro_use] extern crate lazy_static; use rutie::{AnyObject, Class, Fixnum, Object, RString, VM}; // The structure which we want to wrap pub struct Server { host: String, port: u16, } impl Server { fn new(host: String, port: u16) -> Self { Server { host: host, port: port, } } fn host(&self) -> &str { &self.host } fn port(&self) -> u16 { self.port } } wrappable_struct!(Server, ServerWrapper, SERVER_WRAPPER); class!(RubyServer); methods!( RubyServer, rtself, fn ruby_server_new(host: RString, port: Fixnum) -> AnyObject { let server = Server::new(host.unwrap().to_string(), port.unwrap().to_i64() as u16); Class::from_existing("RubyServer").wrap_data(server, &*SERVER_WRAPPER) } fn ruby_server_host() -> RString { let host = rtself.get_data(&*SERVER_WRAPPER).host(); RString::new_utf8(host) } fn ruby_server_port() -> Fixnum { let port = rtself.get_data(&*SERVER_WRAPPER).port(); Fixnum::new(port as i64) } ); fn main() { let data_class = Class::from_existing("Object"); Class::new("RubyServer", Some(&data_class)).define(|klass| { klass.def_self("new", ruby_server_new); klass.def("host", ruby_server_host); klass.def("port", ruby_server_port); }); }
To use the RubyServer
class in Ruby:
server = RubyServer.new("127.0.0.1", 3000)
server.host == "127.0.0.1"
server.port == 3000
Trait Implementations
impl Debug for Class
[src]
impl From<Value> for Class
[src]
impl Into<AnyObject> for Class
[src]
impl Into<Value> for Class
[src]
impl Object for Class
[src]
fn value(&self) -> Value
[src]
fn class(&self) -> Class
[src]
fn singleton_class(&self) -> Class
[src]
fn get_data<'a, T>(&'a self, wrapper: &'a dyn DataTypeWrapper<T>) -> &T
[src]
fn get_data_mut<'a, T>(
&'a mut self,
wrapper: &'a dyn DataTypeWrapper<T>
) -> &mut T
[src]
&'a mut self,
wrapper: &'a dyn DataTypeWrapper<T>
) -> &mut T
fn define<F: Fn(&mut Self)>(&mut self, f: F) -> &Self
[src]
fn define_method<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
[src]
&mut self,
name: &str,
callback: Callback<I, O>
)
fn define_private_method<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
[src]
&mut self,
name: &str,
callback: Callback<I, O>
)
fn define_singleton_method<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
[src]
&mut self,
name: &str,
callback: Callback<I, O>
)
fn def<I: Object, O: Object>(&mut self, name: &str, callback: Callback<I, O>)
[src]
fn def_private<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
[src]
&mut self,
name: &str,
callback: Callback<I, O>
)
fn def_self<I: Object, O: Object>(
&mut self,
name: &str,
callback: Callback<I, O>
)
[src]
&mut self,
name: &str,
callback: Callback<I, O>
)
unsafe fn send(&self, method: &str, arguments: &[AnyObject]) -> AnyObject
[src]
fn equals<T: Object>(&self, other: &T) -> bool
[src]
fn case_equals<T: Object>(&self, other: &T) -> bool
[src]
fn is_eql<T: Object>(&self, other: &T) -> bool
[src]
fn is_equal<T: Object>(&self, other: &T) -> bool
[src]
fn respond_to(&self, method: &str) -> bool
[src]
fn protect_send(
&self,
method: &str,
arguments: &[AnyObject]
) -> Result<AnyObject, AnyException>
[src]
&self,
method: &str,
arguments: &[AnyObject]
) -> Result<AnyObject, AnyException>
fn protect_public_send(
&self,
method: &str,
arguments: &[AnyObject]
) -> Result<AnyObject, AnyException>
[src]
&self,
method: &str,
arguments: &[AnyObject]
) -> Result<AnyObject, AnyException>
fn is_nil(&self) -> bool
[src]
fn to_any_object(&self) -> AnyObject
[src]
fn instance_variable_get(&self, variable: &str) -> AnyObject
[src]
fn instance_variable_set<T: Object>(
&mut self,
variable: &str,
value: T
) -> AnyObject
[src]
&mut self,
variable: &str,
value: T
) -> AnyObject
fn is_frozen(&self) -> bool
[src]
fn freeze(&mut self) -> Self
[src]
unsafe fn to<T: Object>(&self) -> T
[src]
fn try_convert_to<T: VerifiedObject>(&self) -> Result<T, AnyException>
[src]
fn ty(&self) -> ValueType
[src]
impl PartialEq<Class> for Class
[src]
impl VerifiedObject for Class
[src]
fn is_correct_type<T: Object>(object: &T) -> bool
[src]
fn error_message() -> &'static str
[src]
Auto Trait Implementations
impl RefUnwindSafe for Class
[src]
impl Send for Class
[src]
impl Sync for Class
[src]
impl Unpin for Class
[src]
impl UnwindSafe for Class
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,