Struct rutie::Enumerator

source ·

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

Expand description

Enumerator

Implementations§

source §

impl Enumerator

source

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 return Err.
assert!(iter.next().is_err(), "not error!");
assert!(iter.next().is_err(), "not error!");

source

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!");

source

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());

source

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());

source

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!");

source

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(), unsafe { e.send("result", &[]) });
    },
}

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