Project

General

Profile

Feature #15144 ยป 0001-Implement-Enumerator-Chain-and-Enumerator-chain-Feat.patch

knu (Akinori MUSHA), 11/21/2018 06:12 AM

View differences:

enumerator.c
************************************************/
#include "ruby/ruby.h"
#include "internal.h"
#include "id.h"
......
static VALUE generator_allocate(VALUE klass);
static VALUE generator_init(VALUE obj, VALUE proc);
static VALUE rb_cEnumChain;
struct enum_chain {
VALUE enums;
long pos;
};
static VALUE rb_cArithSeq;
/*
......
return rb_attr_get(self, id_result);
}
/*
* Document-class: Enumerator::Chain
*
* Enumerator::Chain is a subclass of Enumerator, which represents a
* chain of enumerables that works as a single enumerator.
*/
static void
enum_chain_mark(void *p)
{
struct enum_chain *ptr = p;
rb_gc_mark(ptr->enums);
}
#define enum_chain_free RUBY_TYPED_DEFAULT_FREE
static size_t
enum_chain_memsize(const void *p)
{
return sizeof(struct enum_chain);
}
static const rb_data_type_t enum_chain_data_type = {
"chain",
{
enum_chain_mark,
enum_chain_free,
enum_chain_memsize,
},
0, 0, RUBY_TYPED_FREE_IMMEDIATELY
};
static struct enum_chain *
enum_chain_ptr(VALUE obj)
{
struct enum_chain *ptr;
TypedData_Get_Struct(obj, struct enum_chain, &enum_chain_data_type, ptr);
if (!ptr || ptr->enums == Qundef) {
rb_raise(rb_eArgError, "uninitialized chain");
}
return ptr;
}
/* :nodoc: */
static VALUE
enum_chain_allocate(VALUE klass)
{
struct enum_chain *ptr;
VALUE obj;
obj = TypedData_Make_Struct(klass, struct enum_chain, &enum_chain_data_type, ptr);
ptr->enums = Qundef;
ptr->pos = -1;
return obj;
}
/*
* call-seq:
* Enumerator::Chain.new(*enums) -> enum
* Enumerator.chain(*enums) -> enum
*
* Generates an Enumerator::Chain object from the given
* enumerable objects.
*
* e = Enumerator.chain(1..3, [4, 5])
* e.to_a #=> [1, 2, 3, 4, 5]
*/
static VALUE
enum_chain_initialize(VALUE obj, VALUE enums)
{
struct enum_chain *ptr;
rb_check_frozen(obj);
TypedData_Get_Struct(obj, struct enum_chain, &enum_chain_data_type, ptr);
if (!ptr) rb_raise(rb_eArgError, "unallocated chain");
ptr->enums = rb_obj_freeze(enums);
ptr->pos = -1;
return obj;
}
/* :nodoc: */
static VALUE
enum_chain_init_copy(VALUE obj, VALUE orig)
{
struct enum_chain *ptr0, *ptr1;
if (!OBJ_INIT_COPY(obj, orig)) return obj;
ptr0 = enum_chain_ptr(orig);
TypedData_Get_Struct(obj, struct enum_chain, &enum_chain_data_type, ptr1);
if (!ptr1) rb_raise(rb_eArgError, "unallocated chain");
ptr1->enums = ptr0->enums;
ptr1->pos = ptr0->pos;
return obj;
}
static VALUE
enum_chain_total_size(VALUE enums)
{
VALUE total = INT2FIX(0);
RARRAY_PTR_USE(enums, ptr, {
long i;
for (i = 0; i < RARRAY_LEN(enums); i++) {
VALUE size = enum_size(ptr[i]);
if (NIL_P(size) || (RB_TYPE_P(size, T_FLOAT) && isinf(NUM2DBL(size)))) {
return size;
}
if (!RB_INTEGER_TYPE_P(size)) {
return Qnil;
}
total = rb_funcall(total, '+', 1, size);
}
});
return total;
}
/*
* call-seq:
* obj.size -> integer
*
* Returns the total size of the enumerator chain calculated by
* summing up the size of each enumerable in the chain. If any of the
* enumerables reports its size as nil or Float::INFINITY, that value
* is returned as the total size.
*/
static VALUE
enum_chain_size(VALUE obj)
{
return enum_chain_total_size(enum_chain_ptr(obj)->enums);
}
static VALUE
enum_chain_enum_size(VALUE obj, VALUE args, VALUE eobj)
{
return enum_chain_size(obj);
}
static VALUE
enum_chain_yield_block(VALUE arg, VALUE block, int argc, VALUE *argv)
{
return rb_funcallv(block, rb_intern("call"), argc, argv);
}
static VALUE
enum_chain_enum_no_size(VALUE obj, VALUE args, VALUE eobj)
{
return Qnil;
}
/*
* call-seq:
* obj.each(*args) { |...| ... } -> obj
* obj.each(*args) -> enumerator
*
* Iterates over the first enumerable by calling the "each" method on
* it with the given arguments until it is exhausted, then proceeds to
* the next enumerable, until all of the enumerables are exhausted.
*
* If no block is given, returns an enumerator.
*/
static VALUE
enum_chain_each(int argc, VALUE *argv, VALUE obj)
{
VALUE enums, block;
struct enum_chain *objptr;
RETURN_SIZED_ENUMERATOR(obj, argc, argv, argc > 0 ? enum_chain_enum_no_size : enum_chain_enum_size);
objptr = enum_chain_ptr(obj);
enums = objptr->enums;
block = rb_block_proc();
RARRAY_PTR_USE(enums, ptr, {
long i;
for (i = 0; i < RARRAY_LEN(enums); i++) {
objptr->pos = i;
rb_block_call(ptr[i], id_each, argc, argv, enum_chain_yield_block, block);
}
});
return obj;
}
/*
* call-seq:
* obj.rewind -> obj
*
* Rewinds the enumerator chain by calling the "rewind" method on each
* enumerable in reverse order. Each call is performed only if the
* enumerable responds to the method.
*/
static VALUE
enum_chain_rewind(VALUE obj)
{
struct enum_chain *objptr = enum_chain_ptr(obj);
VALUE enums = objptr->enums;
RARRAY_PTR_USE(enums, ptr, {
long i;
for (i = objptr->pos; 0 <= i && i < RARRAY_LEN(enums); objptr->pos = --i) {
rb_check_funcall(ptr[i], id_rewind, 0, 0);
}
});
return obj;
}
static VALUE
inspect_enum_chain(VALUE obj, VALUE dummy, int recur)
{
VALUE klass = rb_obj_class(obj);
struct enum_chain *ptr;
TypedData_Get_Struct(obj, struct enum_chain, &enum_chain_data_type, ptr);
if (!ptr || ptr->enums == Qundef) {
return rb_sprintf("#<%"PRIsVALUE": uninitialized>", rb_class_path(klass));
}
if (recur) {
return rb_sprintf("#<%"PRIsVALUE": ...>", rb_class_path(klass));
}
return rb_sprintf("#<%"PRIsVALUE": %+"PRIsVALUE">", rb_class_path(klass), ptr->enums);
}
/*
* call-seq:
* obj.inspect -> string
*
* Returns a printable version of the enumerator chain.
*/
static VALUE
enum_chain_inspect(VALUE obj)
{
return rb_exec_recursive(inspect_enum_chain, obj, 0);
}
/*
* call-seq:
* e.chain(*enums) -> enumerator
*
* Returns an Enumerator::Chain object generated from this enumerator
* and given enumerables.
*
* e = (1..3).each.chain([4, 5])
* e.to_a #=> [1, 2, 3, 4, 5]
*/
static VALUE
enumerator_s_chain(int argc, VALUE enums)
{
return enum_chain_initialize(enum_chain_allocate(rb_cEnumChain), enums);
}
/*
* call-seq:
* e.chain(*enums) -> enumerator
*
* Returns an Enumerator::Chain object generated from this enumerator
* and given enumerables.
*
* e = (1..3).each.chain([4, 5])
* e.to_a #=> [1, 2, 3, 4, 5]
*/
static VALUE
enumerator_chain(int argc, VALUE *argv, VALUE obj)
{
VALUE enums = rb_ary_new_from_values(1, &obj);
rb_ary_cat(enums, argv, argc);
return enum_chain_initialize(enum_chain_allocate(rb_cEnumChain), enums);
}
/*
* call-seq:
* e + enum -> enumerator
*
* Returns an Enumerator::Chain object generated from this enumerator
* and a given enumerable.
*
* e = (1..3).each + [4, 5]
* e.to_a #=> [1, 2, 3, 4, 5]
*/
static VALUE
enumerator_plus(VALUE obj, VALUE eobj)
{
VALUE enums = rb_ary_new_from_args(2, obj, eobj);
return enum_chain_initialize(enum_chain_allocate(rb_cEnumChain), enums);
}
/*
* Document-class: Enumerator::ArithmeticSequence
*
......
rb_define_method(rb_cEnumerator, "rewind", enumerator_rewind, 0);
rb_define_method(rb_cEnumerator, "inspect", enumerator_inspect, 0);
rb_define_method(rb_cEnumerator, "size", enumerator_size, 0);
rb_define_method(rb_cEnumerator, "chain", enumerator_chain, -1);
rb_define_method(rb_cEnumerator, "+", enumerator_plus, 1);
/* Lazy */
rb_cLazy = rb_define_class_under(rb_cEnumerator, "Lazy", rb_cEnumerator);
......
rb_define_method(rb_cYielder, "yield", yielder_yield, -2);
rb_define_method(rb_cYielder, "<<", yielder_yield_push, 1);
/* Chain */
rb_cEnumChain = rb_define_class_under(rb_cEnumerator, "Chain", rb_cEnumerator);
rb_define_alloc_func(rb_cEnumChain, enum_chain_allocate);
rb_define_method(rb_cEnumChain, "initialize", enum_chain_initialize, -2);
rb_define_method(rb_cEnumChain, "initialize_copy", enum_chain_init_copy, 1);
rb_define_method(rb_cEnumChain, "each", enum_chain_each, -1);
rb_define_method(rb_cEnumChain, "size", enum_chain_size, 0);
rb_define_method(rb_cEnumChain, "rewind", enum_chain_rewind, 0);
rb_define_method(rb_cEnumChain, "inspect", enum_chain_inspect, 0);
rb_define_singleton_method(rb_cEnumerator, "chain", enumerator_s_chain, -2);
/* ArithmeticSequence */
rb_cArithSeq = rb_define_class_under(rb_cEnumerator, "ArithmeticSequence", rb_cEnumerator);
rb_undef_alloc_func(rb_cArithSeq);
test/ruby/test_enumerator.rb
assert_equal([0, 1], u.force)
assert_equal([0, 1], u.force)
end
def test_chain_and_plus
a = (1..5).each
e1 = a.chain()
assert_kind_of(Enumerator::Chain, e1)
assert_equal(5, e1.size)
ary = []
e1.each { |x| ary << x }
assert_equal([1, 2, 3, 4, 5], ary)
e2 = a + [6, 7, 8]
assert_kind_of(Enumerator::Chain, e2)
assert_equal(8, e2.size)
ary = []
e2.each { |x| ary << x }
assert_equal([1, 2, 3, 4, 5, 6, 7, 8], ary)
e3 = a.chain([6, 7], 8.step)
assert_kind_of(Enumerator::Chain, e3)
assert_equal(Float::INFINITY, e3.size)
ary = []
e3.take(10).each { |x| ary << x }
assert_equal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ary)
# `a + b + c` should not return `Enumerator.chain(a, b, c)`
# because it is expected that `(a + b).each` be called.
e4 = e2.dup
class << e4
attr_reader :each_is_called
def each
super
@each_is_called = true
end
end
e5 = e4 + 9.step
assert_kind_of(Enumerator::Chain, e5)
assert_equal(Float::INFINITY, e5.size)
ary = []
e5.take(10).each { |x| ary << x }
assert_equal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ary)
assert_equal(true, e4.each_is_called)
end
def test_chained_enums
a = (1..5).each
e0 = Enumerator::Chain.new()
assert_kind_of(Enumerator::Chain, e0)
assert_equal(0, e0.size)
ary = []
e0.each { |x| ary << x }
assert_equal([], ary)
e1 = Enumerator::Chain.new(a)
assert_kind_of(Enumerator::Chain, e1)
assert_equal(5, e1.size)
ary = []
e1.each { |x| ary << x }
assert_equal([1, 2, 3, 4, 5], ary)
e2 = Enumerator.chain(a, [6, 7, 8])
assert_kind_of(Enumerator::Chain, e2)
assert_equal(8, e2.size)
ary = []
e2.each { |x| ary << x }
assert_equal([1, 2, 3, 4, 5, 6, 7, 8], ary)
e3 = Enumerator.chain(a, [6, 7], 8.step)
assert_kind_of(Enumerator::Chain, e3)
assert_equal(Float::INFINITY, e3.size)
ary = []
e3.take(10).each { |x| ary << x }
assert_equal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ary)
e4 = Enumerator.chain(a, Enumerator.new { |y| y << 6 << 7 << 8 })
assert_kind_of(Enumerator::Chain, e4)
assert_equal(nil, e4.size)
ary = []
e4.each { |x| ary << x }
assert_equal([1, 2, 3, 4, 5, 6, 7, 8], ary)
e5 = Enumerator.chain(e1, e2)
assert_kind_of(Enumerator::Chain, e5)
assert_equal(13, e5.size)
ary = []
e5.each { |x| ary << x }
assert_equal([1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, 7, 8], ary)
rewound = []
e1.define_singleton_method(:rewind) { rewound << object_id }
e2.define_singleton_method(:rewind) { rewound << object_id }
e5.rewind
assert_equal(rewound, [e2.object_id, e1.object_id])
rewound = []
a = [1]
e6 = Enumerator.chain(a)
a.define_singleton_method(:rewind) { rewound << object_id }
e6.rewind
assert_equal(rewound, [])
assert_equal(
'#<Enumerator::Chain: [' +
'#<Enumerator::Chain: [' +
'#<Enumerator: 1..5:each>' +
']>, ' +
'#<Enumerator::Chain: [' +
'#<Enumerator: 1..5:each>, ' +
'[6, 7, 8]' +
']>' +
']>',
e5.inspect
)
end
end
    (1-1/1)