Struct rutie::Enumerator

pub struct Enumerator { /* fields omitted */ }

Enumerator

Methods

impl Enumerator

pub fn next(&mut self) -> Result<AnyObject, AnyException>

Advances the iterator and returns the next value.

Returns Err when iteration is finished.

Examples

use rutie::{Array, Fixnum, Object, VM, VerifiedObject, Enumerator};

let mut iter = Array::new().push(Fixnum::new(2)).push(Fixnum::new(1)).to_enum();

// A call to next() returns the next value...
assert_eq!(Ok(Fixnum::new(2).to_any_object()), iter.next());
assert_eq!(Ok(Fixnum::new(1).to_any_object()), iter.next());

// ... and then Err once it's over.
assert!(iter.next().is_err(), "not error!");

// More calls will always retirn Err.
assert!(iter.next().is_err(), "not error!");
assert!(iter.next().is_err(), "not error!");

pub fn next_values(&mut self) -> Result<Array, AnyException>

Advances the iterator and returns the next values.

Returns Err when iteration is finished.

Examples

use rutie::{Array, Fixnum, Object, VM, VerifiedObject, Enumerator};

let mut array = Array::with_capacity(2);

array.push(Fixnum::new(1));
array.push(Fixnum::new(2));

let mut iter = array.to_enum();

// A call to next_values() returns the next values...
let mut result1 = Array::with_capacity(1);
result1.push(Fixnum::new(1));
assert_eq!(Ok(result1), iter.next_values());
let mut result2 = Array::with_capacity(1);
result2.push(Fixnum::new(2));
assert_eq!(Ok(result2), iter.next_values());

// ... and then Err once it's over.
assert!(iter.next_values().is_err(), "not error!");

// More calls will always retirn Err.
assert!(iter.next_values().is_err(), "not error!");
assert!(iter.next_values().is_err(), "not error!");

pub fn peek(&self) -> Result<AnyObject, AnyException>

Peeks into the iterator and returns the next value.

Returns Err when iteration is finished.

Examples

use rutie::{Array, Fixnum, Object, VM, VerifiedObject, Enumerator};

let mut iter = Array::new().push(Fixnum::new(2)).push(Fixnum::new(1)).to_enum();

// A call to peek() returns the next value without progressing the iteration
assert_eq!(Ok(Fixnum::new(2).to_any_object()), iter.peek());
assert_eq!(Ok(Fixnum::new(2).to_any_object()), iter.peek());

pub fn peek_values(&self) -> Result<Array, AnyException>

Peeks into the iterator and returns the next values.

Returns Err when iteration is finished.

Examples

use rutie::{Array, Fixnum, Object, VM, VerifiedObject, Enumerator};

let mut array = Array::with_capacity(2);

array.push(Fixnum::new(1));
array.push(Fixnum::new(2));

let mut iter = array.to_enum();

// A call to peek_values() returns the next values without progressing the iteration
let mut result1 = Array::with_capacity(1);
result1.push(Fixnum::new(1));
assert_eq!(Ok(result1.dup()), iter.peek_values());
assert_eq!(Ok(result1), iter.peek_values());

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn rewind(&mut self) -> &mut Self

Rewind the iteration back to the beginning.

Returns Err when iteration is finished.

Examples

use rutie::{Array, Fixnum, Object, VM, VerifiedObject, Enumerator};

let mut iter = Array::new().push(Fixnum::new(2)).push(Fixnum::new(1)).to_enum();

// A call to next() returns the next value...
assert_eq!(Ok(Fixnum::new(2).to_any_object()), iter.next());
assert_eq!(Ok(Fixnum::new(1).to_any_object()), iter.next());
assert!(iter.next().is_err(), "not error!");

iter.rewind();

// A call to next() returns the next value...
assert_eq!(Ok(Fixnum::new(2).to_any_object()), iter.next());
assert_eq!(Ok(Fixnum::new(1).to_any_object()), iter.next());
assert!(iter.next().is_err(), "not error!");

pub fn feed(&mut self, object: AnyObject) -> Result<(), AnyException>

Feed a return value back in to internal yield inside enumerator.

Examples

use rutie::{Array, Fixnum, Object, VM, VerifiedObject, Enumerator, Class};

let mut e_iter = VM::eval("[1,2,3].map").unwrap().
  try_convert_to::<Enumerator>().unwrap();

assert_eq!(Ok(Fixnum::new(1).to_any_object()), e_iter.next());
e_iter.feed(Fixnum::new(999).to_any_object());
assert_eq!(Ok(Fixnum::new(2).to_any_object()), e_iter.next());
e_iter.feed(Fixnum::new(888).to_any_object());
assert_eq!(Ok(Fixnum::new(3).to_any_object()), e_iter.next());
e_iter.feed(Fixnum::new(777).to_any_object());

match e_iter.next() {
    Ok(_) => unreachable!(),
    Err(e) => {
        let mut expected = Array::with_capacity(3);
        expected.push(Fixnum::new(999).to_any_object());
        expected.push(Fixnum::new(888).to_any_object());
        expected.push(Fixnum::new(777).to_any_object());

        assert!(Class::from_existing("StopIteration").case_equals(&e));
        assert_eq!(expected.to_any_object(), e.send("result", None));
    },
}

Ruby:

e = [1,2,3].map
p e.next           #=> 1
e.feed 999
p e.next           #=> 2
e.feed 888
p e.next           #=> 3
e.feed 777
begin
  e.next
rescue StopIteration
  p $!.result      #=> [999, 888, 777]
end

Trait Implementations

impl Debug for Enumerator

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

Formats the value using the given formatter.

impl From<Value> for Enumerator

fn from(value: Value) -> Self

Performs the conversion.

impl Into<Value> for Enumerator

fn into(self) -> Value

Performs the conversion.

impl Into<AnyObject> for Enumerator

fn into(self) -> AnyObject

Performs the conversion.

impl Object for Enumerator

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.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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).

fn send(&self, method: &str, arguments: Option<&[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: Option<&[AnyObject]> ) -> Result<AnyObject, AnyException>

protect_send returns Result<AnyObject, AnyObject>

fn protect_public_send(     &self,     method: &str,     arguments: Option<&[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 VerifiedObject for Enumerator

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

fn error_message() -> &'static str

impl PartialEq for Enumerator

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 !=.