/***** BEGIN LICENSE BLOCK *****

* Version: EPL 2.0/GPL 2.0/LGPL 2.1

*

* The contents of this file are subject to the Eclipse Public

* License Version 2.0 (the "License"); you may not use this file

* except in compliance with the License. You may obtain a copy of

* the License at http://www.eclipse.org/legal/epl-v20.html

*

* Software distributed under the License is distributed on an "AS

* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or

* implied. See the License for the specific language governing

* rights and limitations under the License.

*

* Copyright (C) 2006 Ola Bini <ola@ologix.com>

*

* Alternatively, the contents of this file may be used under the terms of

* either of the GNU General Public License Version 2 or later (the "GPL"),

* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

* in which case the provisions of the GPL or the LGPL are applicable instead

* of those above. If you wish to allow use of your version of this file only

* under the terms of either the GPL or the LGPL, and not to allow others to

* use your version of this file under the terms of the EPL, indicate your

* decision by deleting the provisions above and replace them with the notice

* and other provisions required by the GPL or the LGPL. If you do not delete

* the provisions above, a recipient may use your version of this file under

* the terms of any one of the EPL, the GPL or the LGPL.

***** END LICENSE BLOCK *****/

package org.jruby;

import org.jruby.anno.JRubyMethod;

import org.jruby.anno.JRubyModule;

import org.jruby.exceptions.JumpException;

import org.jruby.exceptions.RaiseException;

import org.jruby.runtime.Block;

import org.jruby.runtime.BlockBody;

import org.jruby.runtime.BlockCallback;

import org.jruby.runtime.CallBlock;

import org.jruby.runtime.CallBlock19;

import org.jruby.runtime.CallSite;

import org.jruby.runtime.ClassIndex;

import org.jruby.runtime.Helpers;

import org.jruby.runtime.JavaInternalBlockBody;

import org.jruby.runtime.JavaSites.EnumerableSites;

import org.jruby.runtime.Signature;

import org.jruby.runtime.ThreadContext;

import org.jruby.runtime.Visibility;

import org.jruby.runtime.builtin.IRubyObject;

import org.jruby.runtime.builtin.InternalVariables;

import org.jruby.runtime.callsite.CachingCallSite;

import org.jruby.runtime.callsite.MonomorphicCallSite;

import org.jruby.util.TypeConverter;

import org.jruby.util.collections.DoubleObject;

import org.jruby.util.collections.SingleBoolean;

import org.jruby.util.collections.SingleDouble;

import org.jruby.util.collections.SingleInt;

import org.jruby.util.collections.SingleLong;

import org.jruby.util.collections.SingleObject;

import org.jruby.util.func.ObjectObjectIntFunction;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.concurrent.atomic.AtomicInteger;

import static org.jruby.RubyEnumerator.SizeFn;

import static org.jruby.RubyEnumerator.enumeratorize;

import static org.jruby.RubyEnumerator.enumeratorizeWithSize;

import static org.jruby.RubyObject.equalInternal;

import static org.jruby.api.Access.arrayClass;

import static org.jruby.api.Access.enumerableModule;

import static org.jruby.api.Access.hashClass;

import static org.jruby.api.Convert.asFixnum;

import static org.jruby.api.Convert.asFloat;

import static org.jruby.api.Convert.asSymbol;

import static org.jruby.api.Convert.toInt;

import static org.jruby.api.Convert.toLong;

import static org.jruby.api.Create.*;

import static org.jruby.api.Define.defineModule;

import static org.jruby.api.Error.*;

import static org.jruby.api.Warn.warn;

import static org.jruby.runtime.Helpers.arrayOf;

import static org.jruby.runtime.Helpers.invokedynamic;

import static org.jruby.runtime.builtin.IRubyObject.NULL_ARRAY;

import static org.jruby.runtime.invokedynamic.MethodNames.OP_CMP;

/**

* The implementation of Ruby's Enumerable module.

*/

@JRubyModule(name="Enumerable")

public class RubyEnumerable {

public static RubyModule createEnumerableModule(ThreadContext context) {

return defineModule(context, "Enumerable").defineMethods(context, RubyEnumerable.class);

}

public static IRubyObject callEach(ThreadContext context, IRubyObject self, Signature signature, BlockCallback callback) {

return callEach(context, eachSite(context), self, signature, callback);

}

public static IRubyObject callEach(ThreadContext context, CallSite each, IRubyObject self, Signature signature, BlockCallback callback) {

return each.call(context, self, self, CallBlock.newCallClosure(context, self, signature, callback));

}

public static IRubyObject callEach(ThreadContext context, CallSite each, IRubyObject self, BlockCallback callback) {

return each.call(context, self, self, CallBlock.newCallClosure(context, self, Signature.OPTIONAL, callback));

}

public static IRubyObject callEach(ThreadContext context, CallSite each, IRubyObject self, IRubyObject[] args, Signature signature,

BlockCallback callback) {

return each.call(context, self, self, args, CallBlock.newCallClosure(context, self, signature, callback));

}

public static IRubyObject callEach(ThreadContext context, CallSite each, IRubyObject self, IRubyObject arg0, Signature signature,

BlockCallback callback) {

return each.call(context, self, self, arg0, CallBlock.newCallClosure(context, self, signature, callback));

}

public static IRubyObject each(ThreadContext context, CallSite site, IRubyObject self, BlockBody body) {

return site.call(context, self, self, new Block(body, context.currentBinding(self, Visibility.PUBLIC)));

}

private static void checkContext(ThreadContext firstContext, ThreadContext secondContext, String name) {

if (firstContext != secondContext) {

throw secondContext.runtime.newThreadError("Enumerable#" + name + " cannot be parallelized");

}

}

@JRubyMethod(name = "count")

public static IRubyObject count(ThreadContext context, IRubyObject self, final Block block) {

return countCommon(context, eachSite(context), self, block);

}

private static IRubyObject countCommon(ThreadContext context, CallSite each, IRubyObject self, final Block block) {

final SingleInt result = new SingleInt();

if (block.isGiven()) {

each(context, each, self, new JavaInternalBlockBody(context.runtime, context, "Enumerable#count", block.getSignature()) {

public IRubyObject yield(ThreadContext context1, IRubyObject[] args) {

return this.yield(context1, packEnumValues(context1, args));

}

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject value) {

if (block.yield(context1, value).isTrue()) result.i++;

return context1.nil;

}

});

} else {

each(context, each, self, new JavaInternalBlockBody(context.runtime, context, "Enumerable#count", Signature.NO_ARGUMENTS) {

public IRubyObject yield(ThreadContext context1, IRubyObject[] args) {

result.i++;

return context1.nil;

}

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject value) {

result.i++;

return context1.nil;

}

});

}

return asFixnum(context, result.i);

}

@JRubyMethod(name = "count")

public static IRubyObject count(ThreadContext context, IRubyObject self, final IRubyObject methodArg, final Block block) {

final SingleInt result = new SingleInt();

if (block.isGiven()) warn(context, "given block not used");

each(context, eachSite(context), self, new JavaInternalBlockBody(context.runtime, context, "Enumerable#count", Signature.ONE_REQUIRED) {

public IRubyObject yield(ThreadContext context1, IRubyObject[] args) {

return this.yield(context1, packEnumValues(context1, args));

}

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject value) {

if (value.equals(methodArg)) result.i++;

return context1.nil;

}

});

return asFixnum(context, result.i);

}

@JRubyMethod

public static IRubyObject cycle(ThreadContext context, IRubyObject self, final Block block) {

if (!block.isGiven()) {

return enumeratorizeWithSize(context, self, "cycle", RubyEnumerable::cycleSize);

}

return cycleCommon(context, self, -1, block);

}

@JRubyMethod

public static IRubyObject cycle(ThreadContext context, IRubyObject self, IRubyObject arg, final Block block) {

if (arg.isNil()) return cycle(context, self, block);

if (!block.isGiven()) {

return enumeratorizeWithSize(context, self, "cycle", new IRubyObject[] { arg }, RubyEnumerable::cycleSize);

}

long times = toLong(context, arg);

if (times <= 0) return context.nil;

return cycleCommon(context, self, times, block);

}

/*

* @param nv number of times to cycle or -1 to cycle indefinitely

*/

private static IRubyObject cycleCommon(ThreadContext context, IRubyObject self, long nv, final Block block) {

final Ruby runtime = context.runtime;

final List<IRubyObject> result = new ArrayList<>();

each(context, eachSite(context), self, new JavaInternalBlockBody(runtime, Signature.OPTIONAL) {

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject[] args) {

return doYield(context1, null, packEnumValues(context1, args));

}

@Override

public IRubyObject doYield(ThreadContext context1, Block unused, IRubyObject args) {

synchronized (result) { result.add(args); }

block.yield(context1, args);

return context1.nil;

}

});

int length = result.size();

if (length == 0) return context.nil;

while (nv < 0 || 0 < --nv) {

for (int i = 0; i < length; i++) {

block.yield(context, result.get(i));

}

}

return context.nil;

}

/**

* A cycle size method suitable for lambda method reference implementation of {@link SizeFn#size(ThreadContext, IRubyObject, IRubyObject[])}

*

* @see SizeFn#size(ThreadContext, IRubyObject, IRubyObject[])

*/

private static IRubyObject cycleSize(ThreadContext context, IRubyObject self, IRubyObject[] args) {

long mul = 0;

IRubyObject n = context.nil;

if (args != null && args.length > 0) {

n = args[0];

if (!n.isNil()) mul = toLong(context, n);

}

IRubyObject size = size(context, self, args);

if (size == null || size.isNil() || size.equals(asFixnum(context, 0))) return size;

if (n == null || n.isNil()) return asFloat(context, RubyFloat.INFINITY);

if (mul <= 0) return asFixnum(context, 0);

return sites(context).cycle_op_mul.call(context, size, size, mul);

}

@JRubyMethod(name = "take")

public static IRubyObject take(ThreadContext context, IRubyObject self, IRubyObject n, Block block) {

final long len = toLong(context, n);

if (len < 0) throw argumentError(context, "attempt to take negative size");

if (len == 0) return newEmptyArray(context);

final var result = newArray(context);

try {

// Atomic ?

each(context, eachSite(context), self, new JavaInternalBlockBody(context.runtime, Signature.OPTIONAL) {

long i = len; // Atomic ?

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject[] args) {

return this.yield(context1, packEnumValues(context1, args));

}

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject value) {

synchronized (result) {

result.append(context, value);

if (--i == 0) throw JumpException.SPECIAL_JUMP;

}

return context1.nil;

}

});

} catch (JumpException.SpecialJump e) {}

return result;

}

@JRubyMethod(name = "take_while")

public static IRubyObject take_while(ThreadContext context, IRubyObject self, final Block block) {

if (!block.isGiven()) return enumeratorize(context.runtime, self, "take_while");

final var result = newArray(context);

try {

callEach(context, eachSite(context), self, Signature.OPTIONAL, (ctx, largs, unused) -> {

final IRubyObject larg; boolean ary = false;

switch (largs.length) {

case 0: larg = ctx.nil; break;

case 1: larg = largs[0]; break;

default: larg = RubyArray.newArrayMayCopy(ctx.runtime, largs); ary = true;

}

IRubyObject val = ary ? block.yieldArray(ctx, larg, null) : block.yield(ctx, larg);

if ( ! val.isTrue() ) throw JumpException.SPECIAL_JUMP;

synchronized (result) { result.append(context, larg); }

return ctx.nil;

});

} catch (JumpException.SpecialJump ignored) {}

return result;

}

@JRubyMethod(name = "drop")

public static IRubyObject drop(ThreadContext context, IRubyObject self, IRubyObject n, final Block block) {

final long len = toLong(context, n);

if (len < 0) throw argumentError(context, "attempt to drop negative size");

final var result = newArray(context);

try {

// Atomic ?

each(context, eachSite(context), self, new JavaInternalBlockBody(context.runtime, Signature.OPTIONAL) {

long i = len; // Atomic ?

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject[] args) {

return this.yield(context1, packEnumValues(context1, args));

}

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject value) {

synchronized (result) {

if (i == 0) {

result.append(context, value);

} else {

--i;

}

}

return context1.nil;

}

});

} catch (JumpException.SpecialJump e) {}

return result;

}

@JRubyMethod

public static IRubyObject drop_while(ThreadContext context, IRubyObject self, final Block block) {

if (!block.isGiven()) return enumeratorize(context.runtime, self, "drop_while");

final var result = newArray(context);

try {

each(context, eachSite(context), self, new JavaInternalBlockBody(context.runtime, context, "Enumerable#drop_while", Signature.OPTIONAL) {

boolean memo = false;

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject[] args) {

return this.yield(context1, packEnumValues(context1, args));

}

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject value) {

if (!memo && !block.yield(context1, value).isTrue()) memo = true;

if (memo) synchronized (result) { result.append(context, value); }

return context1.nil;

}

});

} catch (JumpException.SpecialJump sj) {}

return result;

}

@JRubyMethod(name = "first")

public static IRubyObject first(ThreadContext context, IRubyObject self) {

final SingleObject<IRubyObject> holder = new SingleObject(context.nil);

try {

each(context, eachSite(context), self, new JavaInternalBlockBody(context.runtime, context, "Enumerable#first", Signature.OPTIONAL) {

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject[] args) {

return this.yield(context1, packEnumValues(context1, args));

}

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject value) {

holder.object = value;

throw JumpException.SPECIAL_JUMP;

}

});

} catch (JumpException.SpecialJump sj) {}

return holder.object;

}

@JRubyMethod(name = "first")

public static IRubyObject first(ThreadContext context, IRubyObject self, final IRubyObject num) {

final long firstCount = toLong(context, num);

if (firstCount == 0) return newEmptyArray(context);

if (firstCount < 0) throw argumentError(context, "attempt to take negative size");

final RubyArray<?> result = allocArray(context, firstCount);

try {

each(context, eachSite(context), self, new JavaInternalBlockBody(context.runtime, context, "Enumerable#first", Signature.OPTIONAL) {

private long iter = firstCount;

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject[] args) {

return this.yield(context1, packEnumValues(context1, args));

}

@Override

public IRubyObject yield(ThreadContext context1, IRubyObject value) {

result.append(context, value);

if (iter-- == 1) throw JumpException.SPECIAL_JUMP;

return context1.nil;

}

});

} catch (JumpException.SpecialJump sj) {}

return result;

}

@JRubyMethod

public static IRubyObject tally(ThreadContext context, IRubyObject self) {

RubyHash result = newHash(context);

callEach(context, eachSite(context), self, Signature.NO_ARGUMENTS, new TallyCallback(result));

return result;

}

@JRubyMethod

public static IRubyObject tally(ThreadContext context, IRubyObject self, IRubyObject hashArg) {

RubyHash result = (RubyHash) TypeConverter.convertToType(hashArg, hashClass(context), "to_hash");

result.checkFrozen();

callEach(context, eachSite(context), self, Signature.NO_ARGUMENTS, new TallyCallback(result));

return result;

}

@JRubyMethod(name = {"to_a", "entries"})

public static IRubyObject to_a(ThreadContext context, IRubyObject self) {

var result = newArray(context);

callEach(context, eachSite(context), self, Signature.OPTIONAL, new AppendBlockCallback(result));

return result;

}

@JRubyMethod(name = {"to_a", "entries"}, keywords = true)

public static IRubyObject to_a(ThreadContext context, IRubyObject self, IRubyObject arg) {

var result = newArray(context);

Helpers.invoke(context, self, "each", arg,

CallBlock.newCallClosure(context, self, Signature.OPTIONAL, new AppendBlockCallback(result)));

return result;

}

@JRubyMethod(name = {"to_a", "entries"}, rest = true, keywords = true)

public static IRubyObject to_a(ThreadContext context, IRubyObject self, IRubyObject[] args) {

final var result = newArray(context);

Helpers.invoke(context, self, "each", args,

CallBlock.newCallClosure(context, self, Signature.OPTIONAL, new AppendBlockCallback(result)));

return result;

}

@JRubyMethod(name = "to_h", rest = true)

public static IRubyObject to_h(ThreadContext context, IRubyObject self, IRubyObject[] args, Block block) {

final RubyHash result = newHash(context);

Helpers.invoke(context, self, "each", args,

CallBlock.newCallClosure(context, self, Signature.OPTIONAL, new PutKeyValueCallback(result, block)));

return result;

}

@JRubyMethod

public static IRubyObject sort(ThreadContext context, IRubyObject self, final Block block) {

final var result = newArray(context);

callEach(context, eachSite(context), self, Signature.OPTIONAL, new AppendBlockCallback(result));

result.sort_bang(context, block);

return result;

}

@JRubyMethod

public static IRubyObject sort_by(final ThreadContext context, IRubyObject self, final Block block) {

final Ruby runtime = context.runtime;

List<DoubleObject<IRubyObject, IRubyObject>> valuesAndCriteria;

if (!block.isGiven()) {

return enumeratorizeWithSize(context, self, "sort_by", (SizeFn) RubyEnumerable::size);

}

final CachingCallSite each = eachSite(context);

final ArrayList<DoubleObject<IRubyObject, IRubyObject>> valuesAndCriteriaList = new ArrayList<>();

callEach(context, each, self, Signature.OPTIONAL, new BlockCallback() {

public IRubyObject call(ThreadContext context1, IRubyObject[] args, Block unused) {

return call(context1, packEnumValues(context1, args), unused);

}

@Override

public IRubyObject call(ThreadContext context1, IRubyObject arg, Block unused) {

IRubyObject value = block.yield(context1, arg);

synchronized (valuesAndCriteriaList) {

valuesAndCriteriaList.add(new DoubleObject<>(arg, value));

}

return context1.nil;

}

});

valuesAndCriteria = valuesAndCriteriaList;

Collections.sort(valuesAndCriteria,

(o1, o2) -> RubyComparable.cmpint(context, invokedynamic(context, o1.object2, OP_CMP, o2.object2), o1.object2, o2.object2));

IRubyObject dstArray[] = new IRubyObject[valuesAndCriteria.size()];

for (int i = 0; i < dstArray.length; i++) {

dstArray[i] = valuesAndCriteria.get(i).object1;

}

return RubyArray.newArrayMayCopy(runtime, dstArray);

}

@JRubyMethod

public static IRubyObject grep(ThreadContext context, IRubyObject self, final IRubyObject pattern, final Block block) {

return grep(context, self, pattern, block, true);

}

@JRubyMethod(name = "grep_v")

public static IRubyObject inverseGrep(ThreadContext context, IRubyObject self, final IRubyObject pattern, final Block block) {

return grep(context, self, pattern, block, false);

}

private static IRubyObject grep(ThreadContext context, IRubyObject self, final IRubyObject pattern, final Block block,

final boolean isPresent) {

final var result = newArray(context);

final CachingCallSite each = eachSite(context);

if (block.isGiven()) {

// pattern === arg

callEach(context, each, self, Signature.ONE_REQUIRED, new BlockCallback() {

final MonomorphicCallSite site = new MonomorphicCallSite("===");

public IRubyObject call(ThreadContext ctx, IRubyObject[] args, Block unused) {

return call(ctx, packEnumValues(ctx, args), unused);

}

@Override

public IRubyObject call(ThreadContext ctx, IRubyObject arg, Block unused) {

if (site.call(ctx, pattern, pattern, arg).isTrue() == isPresent) { // pattern === arg

IRubyObject value = block.yield(ctx, arg);

synchronized (result) { result.append(context, value); }

}

return ctx.nil;

}

});

} else if ((pattern instanceof RubyRegexp) && pattern.getMetaClass().checkMethodBasicDefinition("===")) {

callEach(context, each, self, Signature.ONE_REQUIRED, new BlockCallback() {

public IRubyObject call(ThreadContext ctx, IRubyObject[] args, Block unused) {

return call(ctx, packEnumValues(ctx, args), unused);

}

@Override

public IRubyObject call(ThreadContext ctx, IRubyObject arg, Block unused) {

IRubyObject converted = arg instanceof RubySymbol ? arg : TypeConverter.checkStringType(ctx.runtime, arg);

if (((RubyRegexp) pattern).match_p(ctx, converted).isTrue() == isPresent) {

synchronized (result) { result.append(context, arg); }

}

return ctx.nil;

}

});

} else {

// pattern === arg

callEach(context, each, self, Signature.ONE_REQUIRED, new BlockCallback() {

final MonomorphicCallSite site = new MonomorphicCallSite("===");

public IRubyObject call(ThreadContext ctx, IRubyObject[] args, Block unused) {

return call(ctx, packEnumValues(ctx, args), unused);

}

@Override

public IRubyObject call(ThreadContext ctx, IRubyObject arg, Block unused) {

if (site.call(ctx, pattern, pattern, arg).isTrue() == isPresent) { // pattern === arg

synchronized (result) { result.append(ctx, arg); }

}

return ctx.nil;

}

});

}

return result;

}

public static IRubyObject detectCommon(ThreadContext context, IRubyObject self, final Block block) {

return detectCommon(context, eachSite(context), self, null, block);

}

public static IRubyObject detectCommon(ThreadContext context, CallSite each, IRubyObject self, final Block block) {

return detectCommon(context, each, self, null, block);

}

public static IRubyObject detectCommon(final ThreadContext context, IRubyObject self, IRubyObject ifnone, final Block block) {

return detectCommon(context, eachSite(context), self, ifnone, block);

}

public static IRubyObject detectCommon(final ThreadContext context, CallSite each, IRubyObject self, IRubyObject ifnone, final Block block) {

final SingleObject<IRubyObject> result = new SingleObject<>(null);

try {

callEach(context, each, self, Signature.OPTIONAL, new BlockCallback() {

public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) {

return call(ctx, packEnumValues(ctx, largs), blk);

}

@Override

public IRubyObject call(ThreadContext ctx, IRubyObject larg, Block blk) {

checkContext(context, ctx, "detect/find");

if (block.yield(ctx, larg).isTrue()) {

result.object = larg;

throw JumpException.SPECIAL_JUMP;

}

return ctx.nil;

}

});

} catch (JumpException.SpecialJump sj) {

return result.object;

}

return ifnone != null && !ifnone.isNil() ?

sites(context).detect_call.call(context, ifnone, ifnone) : context.nil;

}

@JRubyMethod

public static IRubyObject detect(ThreadContext context, IRubyObject self, final Block block) {

boolean blockGiven = block.isGiven();

if (self instanceof RubyArray && blockGiven) return ((RubyArray) self).find(context, null, block);

return block.isGiven() ? detectCommon(context, eachSite(context), self, null, block) : enumeratorize(context.runtime, self, "detect");

}

@JRubyMethod

public static IRubyObject detect(ThreadContext context, IRubyObject self, IRubyObject ifnone, final Block block) {

boolean blockGiven = block.isGiven();

if (self instanceof RubyArray && blockGiven) return ((RubyArray) self).find(context, ifnone, block);

return block.isGiven() ? detectCommon(context, eachSite(context), self, ifnone, block) : enumeratorize(context.runtime, self, "detect", ifnone);

}

// FIXME: Custom Array enumeratorize should be made for all of these methods which skip Array without a supplied block.

@JRubyMethod

public static IRubyObject find(ThreadContext context, IRubyObject self, final Block block) {

boolean blockGiven = block.isGiven();

if (self instanceof RubyArray && blockGiven) return ((RubyArray) self).find(context, null, block);

return blockGiven ? detectCommon(context, eachSite(context), self, null, block) : enumeratorize(context.runtime, self, "find");

}

@JRubyMethod

public static IRubyObject find(ThreadContext context, IRubyObject self, IRubyObject ifnone, final Block block) {

boolean blockGiven = block.isGiven();

if (self instanceof RubyArray && blockGiven) return ((RubyArray) self).find(context, ifnone, block);

return blockGiven ? detectCommon(context, eachSite(context), self, ifnone, block) :

enumeratorize(context.runtime, self, "find", ifnone);

}

@JRubyMethod(name = "find_index")

public static IRubyObject find_index(ThreadContext context, IRubyObject self, final Block block) {

boolean blockGiven = block.isGiven();

if (self instanceof RubyArray && blockGiven) return ((RubyArray) self).find_index(context, block);

return blockGiven ? find_indexCommon(context, eachSite(context), self, block, block.getSignature()) :

enumeratorize(context.runtime, self, "find_index");

}

@JRubyMethod(name = "find_index")

public static IRubyObject find_index(ThreadContext context, IRubyObject self, final IRubyObject cond, final Block block) {

if (block.isGiven()) warn(context, "given block not used");

return self instanceof RubyArray ary ?

ary.find_index(context, cond) :

find_indexCommon(context, eachSite(context), self, cond);

}

public static IRubyObject find_indexCommon(ThreadContext context, IRubyObject self, final Block block, Signature callbackArity) {

return find_indexCommon(context, eachSite(context), self, block, callbackArity);

}

public static IRubyObject find_indexCommon(ThreadContext context, CallSite each, IRubyObject self, final Block block, Signature callbackArity) {

final SingleLong result = new SingleLong();

try {

callEach(context, each, self, callbackArity, (ctx, largs, blk) -> {

if (block.yieldValues(ctx, largs).isTrue()) throw JumpException.SPECIAL_JUMP;

result.l++;

return ctx.nil;

});

} catch (JumpException.SpecialJump sj) {

return asFixnum(context, result.l);

}

return context.nil;

}

public static IRubyObject find_indexCommon(ThreadContext context, IRubyObject self, final IRubyObject cond) {

return find_indexCommon(context, eachSite(context), self, cond);

}

public static IRubyObject find_indexCommon(ThreadContext context, CallSite each, IRubyObject self, final IRubyObject cond) {

final SingleLong result = new SingleLong(0);

try {

callEach(context, each, self, Signature.OPTIONAL, new BlockCallback() {

public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) {

return call(ctx, packEnumValues(ctx, largs), blk);

}

@Override

public IRubyObject call(ThreadContext ctx, IRubyObject larg, Block blk) {

if (equalInternal(ctx, larg, cond)) throw JumpException.SPECIAL_JUMP;

result.l++;

return ctx.nil;

}

});

} catch (JumpException.SpecialJump sj) {

return asFixnum(context, result.l);

}

return context.nil;

}

public static IRubyObject selectCommon(ThreadContext context, IRubyObject self, final Block block, String methodName) {

if (!block.isGiven()) return enumeratorizeWithSize(context, self, methodName, (SizeFn) RubyEnumerable::size);

final var result = newArray(context);

callEach(context, eachSite(context), self, Signature.OPTIONAL, new BlockCallback() {

public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) {

return call(ctx, packEnumValues(ctx, largs), blk);

}

@Override

public IRubyObject call(ThreadContext ctx, IRubyObject larg, Block blk) {

if (block.yield(ctx, larg).isTrue()) {

synchronized (result) { result.append(ctx, larg); }

}

return ctx.nil;

}

});

return result;

}

@JRubyMethod

public static IRubyObject select(ThreadContext context, IRubyObject self, final Block block) {

return selectCommon(context, self, block, "select");

}

@JRubyMethod(alias = "filter")

public static IRubyObject find_all(ThreadContext context, IRubyObject self, final Block block) {

return selectCommon(context, self, block, "find_all");

}

@JRubyMethod

public static IRubyObject reject(ThreadContext context, IRubyObject self, final Block block) {

if (!block.isGiven()) return enumeratorizeWithSize(context, self, "reject", (SizeFn) RubyEnumerable::size);

final var result = newArray(context);

callEach(context, eachSite(context), self, Signature.OPTIONAL, new BlockCallback() {

public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) {

return call(ctx, packEnumValues(ctx, largs), blk);

}

@Override

public IRubyObject call(ThreadContext ctx, IRubyObject larg, Block blk) {

if ( ! block.yield(ctx, larg).isTrue() ) {

synchronized (result) { result.append(ctx, larg); }

}

return ctx.nil;

}

@Override

public IRubyObject call(ThreadContext ctx, IRubyObject larg) {

if ( ! block.yield(ctx, larg).isTrue() ) {

synchronized (result) { result.append(ctx, larg); }

}

return ctx.nil;

}

});

return result;

}

@JRubyMethod(name = "collect")

public static IRubyObject collect(ThreadContext context, IRubyObject self, final Block block) {

return collectCommon(context, self, block, "collect");

}

@JRubyMethod(name = "map")

public static IRubyObject map(ThreadContext context, IRubyObject self, final Block block) {

return collectCommon(context, self, block, "map");

}

private static IRubyObject collectCommon(ThreadContext context, IRubyObject self, final Block block, String methodName) {

if (!block.isGiven()) return enumeratorizeWithSize(context, self, methodName, (SizeFn) RubyEnumerable::size);

final var result = newArray(context);

eachSite(context).call(context, self, self, CallBlock19.newCallClosure(self, enumerableModule(context),

block.getSignature(), new BlockCallback() {

public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) {

final IRubyObject larg;

boolean ary = false;

switch (largs.length) {

case 0: larg = ctx.nil; break;

case 1: larg = largs[0]; break;

default: larg = RubyArray.newArrayMayCopy(ctx.runtime, largs); ary = true;

}

IRubyObject val = ary ? block.yieldArray(ctx, larg, null) : block.yield(ctx, larg);

synchronized (result) { result.append(ctx, val); }

return ctx.nil;

}

@Override

public IRubyObject call(ThreadContext ctx, IRubyObject larg, Block blk) {

IRubyObject val = block.yield(ctx, larg);

synchronized (result) { result.append(ctx, val); }

return ctx.nil;

}

}, context));

return result;

}

@JRubyMethod

public static IRubyObject filter_map(ThreadContext context, IRubyObject self, Block block) {

if (!block.isGiven()) return enumeratorizeWithSize(context, self, "filter_map", (SizeFn) RubyEnumerable::size);

var result = newArray(context);

eachSite(context).call(context, self, self, CallBlock19.newCallClosure(self, enumerableModule(context),

block.getSignature(), new BlockCallback() {

public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) {

final IRubyObject larg; boolean ary = false;

switch (largs.length) {

case 0: larg = ctx.nil; break;

case 1: larg = largs[0]; break;

default: larg = RubyArray.newArrayMayCopy(ctx.runtime, largs); ary = true;

}

IRubyObject val = ary ? block.yieldArray(ctx, larg, null) : block.yield(ctx, larg);

if (val.isTrue()) {

synchronized (result) { result.append(ctx, val); }

}

return ctx.nil;

}

@Override

public IRubyObject call(ThreadContext ctx, IRubyObject larg, Block blk) {

IRubyObject val = block.yield(ctx, larg);

if (val.isTrue()) {

synchronized (result) { result.append(ctx, val); }

}

return ctx.nil;

}

}, context));

return result;

}

@JRubyMethod(name = "flat_map")

public static IRubyObject flat_map(ThreadContext context, IRubyObject self, final Block block) {

return flatMapCommon(context, self, block, "flat_map");

}

@JRubyMethod(name = "collect_concat")

public static IRubyObject collect_concat(ThreadContext context, IRubyObject self, final Block block) {

return flatMapCommon(context, self, block, "collect_concat");

}

private static IRubyObject flatMapCommon(ThreadContext context, IRubyObject self, final Block block, String methodName) {

if (!block.isGiven()) return enumeratorizeWithSize(context, self, methodName, (SizeFn) RubyEnumerable::size);

final var ary = newArray(context);

callEach(context, eachSite(context), self, block.getSignature(), new BlockCallback() {

public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) {

return call(ctx, packEnumValues(ctx, largs), blk);

}

@Override

public IRubyObject call(ThreadContext ctx, IRubyObject larg, Block blk) {

IRubyObject i = block.yield(ctx, larg);

IRubyObject tmp = i.checkArrayType();

synchronized(ary) {

if (tmp.isNil()) {

ary.append(ctx, i);

} else {

ary.concat(ctx, tmp);

}

}

return ctx.nil;

}

});

return ary;

}

@JRubyMethod

public static IRubyObject sum(ThreadContext context, IRubyObject self, final Block block) {

final Ruby runtime = context.runtime;

RubyFixnum zero = RubyFixnum.zero(runtime);

return sumCommon(context, self, zero, block);

}

@JRubyMethod

public static IRubyObject sum(ThreadContext context, IRubyObject self, IRubyObject init, final Block block) {

return sumCommon(context, self, init, block);

}

public static IRubyObject sumCommon(final ThreadContext context, IRubyObject self, IRubyObject init, final Block block) {

return sumCommon(context, eachSite(context), self, init, block);

}

/* TODO: optimise for special types (e.g. Range, Hash, ...) */

public static IRubyObject sumCommon(final ThreadContext context, CallSite each, IRubyObject self, IRubyObject init, final Block block) {

final SingleObject<IRubyObject> result = new SingleObject<>(init);

final SingleDouble memo = new SingleDouble(0.0);

if (block.isGiven()) {

callEach(context, each, self, Signature.OPTIONAL, new BlockCallback() {

public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) {

return call(ctx, packEnumValues(ctx, largs), blk);

}

@Override

public IRubyObject call(ThreadContext ctx, IRubyObject larg, Block blk) {

result.object = sumAdd(ctx, result.object, block.yield(ctx, larg), memo);

return ctx.nil;

}

});

} else {

callEach(context, each, self, Signature.OPTIONAL, new BlockCallback() {

public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) {

return call(ctx, packEnumValues(ctx, largs), blk);

}

@Override

public IRubyObject call(ThreadContext ctx, IRubyObject larg, Block blk) {

result.object = sumAdd(ctx, result.object, larg, memo);

return ctx.nil;

}

});

}

if (result.object instanceof RubyFloat) {

return ((RubyFloat) result.object).op_plus(context, memo.d);

}

return result.object;

}

/* FIXME: optimise for special types (e.g. Integer)? */

/* NB: MRI says "Enumerable#sum method may not respect method redefinition of "+" methods such as Integer#+." */

public static IRubyObject sumAdd(final ThreadContext context, IRubyObject lhs, IRubyObject rhs, final SingleDouble c) {

switch (lhs.getType().classIndex) {

default: return sites(context).sum_op_plus.call(context, lhs, lhs, rhs);

case ClassIndex.FLOAT:

case ClassIndex.INTEGER:

case ClassIndex.RATIONAL:

switch (rhs.getType().classIndex) {

default: return sites(context).sum_op_plus.call(context, lhs, lhs, rhs);

case ClassIndex.INTEGER:

case ClassIndex.RATIONAL:

case ClassIndex.FLOAT:

}

}

boolean floats = false;

double f = 0.0;

/*

* Kahan-Babuska balancing compensated summation algorithm

* See http://link.springer.com/article/10.1007/s00607-005-0139-x

*/

double x = 0.0, t;

if (lhs instanceof RubyFloat lhsFloat) {

if (rhs instanceof RubyNumeric num) {

f = lhsFloat.value;

x = num.asDouble(context);

floats = true;

}

} else if (rhs instanceof RubyFloat rhsFloat) {

if (lhs instanceof RubyNumeric num) {

c.d = 0.0;

f = num.asDouble(context);

x = rhsFloat.value;

floats = true;

}

}

if (!floats) return sites(context).sum_op_plus.call(context, lhs, lhs, rhs);

if (Double.isNaN(f)) return lhs;

if (Double.isNaN(x)) return lhs;

if (Double.isInfinite(x)) {

if (Double.isInfinite(f) && Math.signum(x) != Math.signum(f)) {

return asFloat(context, RubyFloat.NAN);

} else {

return rhs;

}

}

if (Double.isInfinite(f)) return lhs;

// Kahan's compensated summation algorithm