Struct rutie::Thread

#[repr(C)]
pub struct Thread { /* private fields */ }

Thread

Implementations

impl Thread

pub fn new<F, R>(func: F) -> Self

where F: FnMut() -> R, R: Object,

Creates a new green thread.

The returning value of the closure will be available as #value of the thread

Examples

use rutie::{Fixnum, Thread, VM};

Thread::new(|| {
    let computation_result = 1 + 2;

    Fixnum::new(computation_result)
});

Ruby:

Thread.new do
  computation_result = 1 + 2

  computation_result
end

pub fn wait_fd(fd: RawFd)

Tells scheduler to switch to other threads while current thread is waiting for a readable event on the given file descriptor.

Examples

use std::os::unix::io::AsRawFd;
use std::os::unix::net::UnixStream;

use rutie::{Thread, VM};

let (unix_socket, _) = UnixStream::pair().unwrap();

Thread::wait_fd(unix_socket.as_raw_fd());

pub fn call_without_gvl<F, R, G>(func: F, unblock_func: Option<G>) -> R

where F: FnMut() -> R, G: FnMut(),

Release GVL for current thread.

Warning! Due to MRI limitations, interaction with Ruby objects is not allowed while GVL is released, it may cause unexpected behaviour. Read more at Ruby documentation

You should extract all the information from Ruby world before invoking thread_call_without_gvl.

GVL will be re-acquired when the closure is finished.

Examples

#[macro_use] extern crate rutie;

use rutie::{Class, Fixnum, Object, Thread};

class!(Calculator);

methods!(
    Calculator,
    rtself,

    fn heavy_computation() -> Fixnum {
        let computation = || { 2 * 2 };
        let unblocking_function = || {};

        // release GVL for current thread until `computation` is completed
        let result = Thread::call_without_gvl(
            computation,
            Some(unblocking_function)
        );

        // GVL is re-acquired, we can interact with Ruby-world
        Fixnum::new(result)
    }
);

fn main() {
    Class::new("Calculator", None).define(|klass| {
        klass.def("heavy_computation", heavy_computation);
    });
}

pub fn call_without_gvl2<F, R, G>(func: F, unblock_func: Option<G>) -> R

where F: FnMut() -> R, G: FnMut(),

pub fn call_with_gvl<F, R>(func: F) -> R

where F: FnMut() -> R,

Trait Implementations

impl Debug for Thread

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

Formats the value using the given formatter.

impl From<Value> for Thread

fn from(value: Value) -> Self

Converts to this type from the input type.

impl Into<AnyObject> for Thread

fn into(self) -> AnyObject

Converts this type into the (usually inferred) input type.

impl Into<Value> for Thread

fn into(self) -> Value

Converts this type into the (usually inferred) input type.

impl Object for Thread

fn value(&self) -> Value

Returns internal value of current object.

fn class(&self) -> Class

Returns a class of current object.

fn singleton_class(&self) -> Class

Returns a singleton class of current object.

fn get_data<'a, T>(&'a self, wrapper: &'a dyn DataTypeWrapper<T>) -> &T

Gets an immutable reference to the Rust structure which is wrapped into a Ruby object.

fn get_data_mut<'a, T>( &'a mut self, wrapper: &'a dyn DataTypeWrapper<T> ) -> &mut T

Gets a mutable reference to the Rust structure which is wrapped into a Ruby object.

fn define<F: Fn(&mut Self)>(&mut self, f: F) -> &Self

Wraps calls to the object.

fn define_method<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

Defines an instance method for the given class or object.

fn define_private_method<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

Defines a private instance method for the given class or object.

fn define_singleton_method<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

Defines a class method for given class or singleton method for object.

fn def<I: Object, O: Object>(&mut self, name: &str, callback: Callback<I, O>)

An alias for define_method (similar to Ruby syntax def some_method).

fn def_private<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

An alias for define_private_method (similar to Ruby syntax private def some_method).

fn def_self<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

An alias for define_singleton_method (similar to Ruby def self.some_method).

unsafe fn send(&self, method: &str, arguments: &[AnyObject]) -> AnyObject

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

fn equals<T: Object>(&self, other: &T) -> bool

Alias for Ruby’s ==

fn case_equals<T: Object>(&self, other: &T) -> bool

Alias for Ruby’s ===

fn is_eql<T: Object>(&self, other: &T) -> bool

Alias for Ruby’s eql?

fn is_equal<T: Object>(&self, other: &T) -> bool

Alias for Ruby’s equal?

fn respond_to(&self, method: &str) -> bool

Checks whether the object responds to given method

fn protect_send( &self, method: &str, arguments: &[AnyObject] ) -> Result<AnyObject, AnyException>

protect_send returns Result<AnyObject, AnyObject>

fn protect_public_send( &self, method: &str, arguments: &[AnyObject] ) -> Result<AnyObject, AnyException>

protect_public_send returns Result<AnyObject, AnyObject>

fn is_nil(&self) -> bool

Checks whether the object is nil

fn to_any_object(&self) -> AnyObject

Converts struct to AnyObject

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

Gets an instance variable of object

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

Sets an instance variable for object

fn is_frozen(&self) -> bool

Returns the freeze status of the object.

fn freeze(&mut self) -> Self

Prevents further modifications to the object.

unsafe fn to<T: Object>(&self) -> T

Unsafely casts current object to the specified Ruby type

fn try_convert_to<T: VerifiedObject>(&self) -> Result<T, AnyException>

Safely casts current object to the specified Ruby type

fn ty(&self) -> ValueType

Determines the value type of the object

impl PartialEq for Thread

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl VerifiedObject for Thread

fn is_correct_type<T: Object>(object: &T) -> bool

fn error_message() -> &'static str