# $Idaemons: /home/cvs/rb/generator.rb,v 1.8 2001/10/03 08:54:32 knu Exp $
# $RoughId: generator.rb,v 1.10 2003/10/14 19:36:58 knu Exp $
# $Id: generator.rb 15954 2008-04-10 10:52:50Z knu $
# = generator.rb: convert an internal iterator to an external one
# Copyright (c) 2001,2003 Akinori MUSHA <knu@iDaemons.org>
# All rights reserved. You can redistribute and/or modify it under
# the same terms as Ruby.
# This library provides the Generator class, which converts an
# internal iterator (i.e. an Enumerable object) to an external
# iterator. In that form, you can roll many iterators independently.
# The SyncEnumerator class, which is implemented using Generator,
# makes it easy to roll many Enumerable objects synchronously.
# See the respective classes for examples of usage.
# Generator converts an internal iterator (i.e. an Enumerable object)
# to an external iterator.
# Note that it is not very fast since it is implemented using
# continuations, which are currently slow.
# # Generator from an Enumerable object
# g = Generator.new(['A', 'B', 'C', 'Z'])
# # Generator from a block
# g = Generator.new { |g|
# # The same result as above
# Creates a new generator either from an Enumerable object or from a
# In the former, block is ignored even if given.
# In the latter, the given block is called with the generator
# itself, and expected to call the +yield+ method for each element.
def initialize(enum = nil, &block)
enum.each { |x| g.yield x }
@cont_next = @cont_yield = @cont_endp = nil
if @cont_next = callcc { |c| c }
@cont_endp.call(nil) if @cont_endp
# Yields an element to the generator.
if @cont_yield = callcc { |c| c }
# Returns true if the generator has reached the end.
if @cont_endp = callcc { |c| c }
@cont_yield.nil? && @queue.empty?
# Returns true if the generator has not reached the end yet.
# Returns the current index (position) counting from zero.
# Returns the current index (position) counting from zero.
# Returns the element at the current position and moves forward.
raise EOFError, "no more elements available"
if @cont_next = callcc { |c| c }
@cont_yield.call(nil) if @cont_yield
# Returns the element at the current position.
raise EOFError, "no more elements available"
initialize(nil, &@block) if @index.nonzero?
# Rewinds the generator and enumerates the elements.
class Enumerable::Enumerator
@generator ||= Generator.new(self)
# Returns the next object in the enumerator, and move the internal
# position forward. When the position reached at the end, internal
# position is rewinded then StopIteration is raised.
# Note that enumeration sequence by next method does not affect other
# non-external enumeration methods, unless underlying iteration
# methods itself has side-effect, e.g. IO#each_line.
# Caution: This feature internally uses Generator, which uses callcc
# to stop and resume enumeration to fetch each value. Use with care
# and be aware of the performance loss.
return g.next unless g.end?
raise StopIteration, 'iteration reached at end'
# Rewinds the enumeration sequence by the next method.
# SyncEnumerator creates an Enumerable object from multiple Enumerable
# objects and enumerates them synchronously.
# s = SyncEnumerator.new([1,2,3], ['a', 'b', 'c'])
# # Yields [1, 'a'], [2, 'b'], and [3,'c']
# s.each { |row| puts row.join(', ') }
# Creates a new SyncEnumerator which enumerates rows of given
@gens = enums.map { |e| Generator.new(e) }
# Returns the number of enumerated Enumerable objects, i.e. the size
# Returns the number of enumerated Enumerable objects, i.e. the size
# Returns true if the given nth Enumerable object has reached the
# end. If no argument is given, returns true if any of the
# Enumerable objects has reached the end.
@gens.detect { |g| g.end? } ? true : false
# Enumerates rows of the Enumerable objects.
@gens.each { |g| g.rewind }
eval DATA.read, nil, $0, __LINE__+4
class TC_Generator < Test::Unit::TestCase
assert_raises(EOFError) { g.current }
assert_equal('A', g.current)
assert_equal(true, g.next?)
assert_equal('A', g.current)
assert_equal('A', g.next)
assert_equal(true, g.next?)
assert_equal('B', g.current)
assert_equal('B', g.next)
assert_equal(g, g.rewind)
assert_equal('A', g.current)
assert_equal(true, g.next?)
assert_equal('A', g.current)
assert_equal('A', g.next)
assert_equal(true, g.next?)
assert_equal('B', g.current)
assert_equal('B', g.next)
assert_equal(true, g.next?)
assert_equal('C', g.current)
assert_equal('C', g.next)
assert_equal(true, g.next?)
assert_equal('Z', g.current)
assert_equal('Z', g.next)
assert_equal(false, g.next?)
assert_raises(EOFError) { g.next }
class TC_SyncEnumerator < Test::Unit::TestCase
r = ['a'..'f', 1..10, 10..20]
ra = r.map { |x| x.to_a }
a = (0...(ra.map {|x| x.size}.max)).map { |i| ra.map { |x| x[i] } }
s = SyncEnumerator.new(*r)
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
