org.jruby/jruby-core/9.2.9.0 : org/jruby/gen/org$jruby$RubyEnumerable$POPULATOR.java

org$jruby$RubyEnumerable$POPULATOR
- populate(RubyModule, Class): void
- static class initializer
https://github.com/jruby/jruby/jruby-core: JRuby is the effort to recreate the Ruby (https://www.ruby-lang.org) interpreter in Java. (JRuby)
headius
enebo
wmeissner
BanzaiMan
mkristian
/* THIS FILE IS GENERATED. DO NOT EDIT */
package org.jruby.gen;

import org.jruby.Ruby;
import org.jruby.RubyModule;
import org.jruby.RubyClass;
import org.jruby.anno.TypePopulator;
import org.jruby.internal.runtime.methods.JavaMethod;
import org.jruby.internal.runtime.methods.DynamicMethod;
import org.jruby.runtime.Arity;
import org.jruby.runtime.Visibility;
import org.jruby.runtime.MethodIndex;
import java.util.Arrays;
import java.util.List;
import javax.annotation.Generated;

@Generated("org.jruby.anno.AnnotationBinder")
@SuppressWarnings("deprecation")
public class org$jruby$RubyEnumerable$POPULATOR extends TypePopulator {
    public void populate(RubyModule cls, Class clazz) {
        JavaMethod javaMethod;
        DynamicMethod moduleMethod, aliasedMethod;
        Ruby runtime = cls.getRuntime();
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$1$0$drop(cls, Visibility.PUBLIC, "drop");
        populateMethod(javaMethod, 1, "drop", true, false, org.jruby.RubyEnumerable.class, "drop", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "drop", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$min_by(cls, Visibility.PUBLIC, "min_by");
        populateMethod(javaMethod, -1, "min_by", true, false, org.jruby.RubyEnumerable.class, "min_by", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "min_by", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$find(cls, Visibility.PUBLIC, "find");
        populateMethod(javaMethod, -1, "find", true, false, org.jruby.RubyEnumerable.class, "find", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "find", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$drop_while(cls, Visibility.PUBLIC, "drop_while");
        populateMethod(javaMethod, 0, "drop_while", true, false, org.jruby.RubyEnumerable.class, "drop_while", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "drop_while", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$1$none_p(cls, Visibility.PUBLIC, "none?");
        populateMethod(javaMethod, -1, "none_p", true, false, org.jruby.RubyEnumerable.class, "none_p", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "none?", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$reject(cls, Visibility.PUBLIC, "reject");
        populateMethod(javaMethod, 0, "reject", true, false, org.jruby.RubyEnumerable.class, "reject", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "reject", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$sum(cls, Visibility.PUBLIC, "sum");
        populateMethod(javaMethod, -1, "sum", true, false, org.jruby.RubyEnumerable.class, "sum", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "sum", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$reverse_each(cls, Visibility.PUBLIC, "reverse_each");
        populateMethod(javaMethod, -1, "reverse_each", true, false, org.jruby.RubyEnumerable.class, "reverse_each", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "reverse_each", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$sort(cls, Visibility.PUBLIC, "sort");
        populateMethod(javaMethod, 0, "sort", true, false, org.jruby.RubyEnumerable.class, "sort", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "sort", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$find_index(cls, Visibility.PUBLIC, "find_index");
        populateMethod(javaMethod, -1, "find_index", true, false, org.jruby.RubyEnumerable.class, "find_index", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "find_index", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$select(cls, Visibility.PUBLIC, "select");
        populateMethod(javaMethod, 0, "select", true, false, org.jruby.RubyEnumerable.class, "select", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "select", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$cycle(cls, Visibility.PUBLIC, "cycle");
        populateMethod(javaMethod, -1, "cycle", true, false, org.jruby.RubyEnumerable.class, "cycle", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "cycle", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$to_h(cls, Visibility.PUBLIC, "to_h");
        populateMethod(javaMethod, -1, "to_h", true, false, org.jruby.RubyEnumerable.class, "to_h", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY);
        aliasedMethod = cls.putMethod(runtime, "to_h", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$1$0$each_cons(cls, Visibility.PUBLIC, "each_cons");
        populateMethod(javaMethod, 1, "each_cons", true, false, org.jruby.RubyEnumerable.class, "each_cons", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "each_cons", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$1$all_p(cls, Visibility.PUBLIC, "all?");
        populateMethod(javaMethod, -1, "all_p", true, false, org.jruby.RubyEnumerable.class, "all_p", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "all?", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$detect(cls, Visibility.PUBLIC, "detect");
        populateMethod(javaMethod, -1, "detect", true, false, org.jruby.RubyEnumerable.class, "detect", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "detect", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$max(cls, Visibility.PUBLIC, "max");
        populateMethod(javaMethod, -1, "max", true, false, org.jruby.RubyEnumerable.class, "max", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "max", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$minmax_by(cls, Visibility.PUBLIC, "minmax_by");
        populateMethod(javaMethod, 0, "minmax_by", true, false, org.jruby.RubyEnumerable.class, "minmax_by", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "minmax_by", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$minmax(cls, Visibility.PUBLIC, "minmax");
        populateMethod(javaMethod, 0, "minmax", true, false, org.jruby.RubyEnumerable.class, "minmax", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "minmax", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$map(cls, Visibility.PUBLIC, "map");
        populateMethod(javaMethod, 0, "map", true, false, org.jruby.RubyEnumerable.class, "map", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "map", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$zip(cls, Visibility.PUBLIC, "zip");
        populateMethod(javaMethod, -1, "zip", true, false, org.jruby.RubyEnumerable.class, "zip", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "zip", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$each_entry(cls, Visibility.PUBLIC, "each_entry");
        populateMethod(javaMethod, -1, "each_entry", true, false, org.jruby.RubyEnumerable.class, "each_entry", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "each_entry", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$group_by(cls, Visibility.PUBLIC, "group_by");
        populateMethod(javaMethod, 0, "group_by", true, false, org.jruby.RubyEnumerable.class, "group_by", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "group_by", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$chunk(cls, Visibility.PUBLIC, "chunk");
        populateMethod(javaMethod, 0, "chunk", true, false, org.jruby.RubyEnumerable.class, "chunk", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "chunk", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$collect_concat(cls, Visibility.PUBLIC, "collect_concat");
        populateMethod(javaMethod, 0, "collect_concat", true, false, org.jruby.RubyEnumerable.class, "collect_concat", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "collect_concat", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$count(cls, Visibility.PUBLIC, "count");
        populateMethod(javaMethod, -1, "count", true, false, org.jruby.RubyEnumerable.class, "count", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "count", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$uniq(cls, Visibility.PUBLIC, "uniq");
        populateMethod(javaMethod, 0, "uniq", true, false, org.jruby.RubyEnumerable.class, "uniq", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "uniq", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$to_a(cls, Visibility.PUBLIC, "to_a");
        populateMethod(javaMethod, -1, "to_a", true, false, org.jruby.RubyEnumerable.class, "to_a", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "to_a", javaMethod);
        cls.putMethod(runtime, "entries", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$1$0$each_with_object(cls, Visibility.PUBLIC, "each_with_object");
        populateMethod(javaMethod, 1, "each_with_object", true, false, org.jruby.RubyEnumerable.class, "each_with_object", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "each_with_object", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$1$one_p(cls, Visibility.PUBLIC, "one?");
        populateMethod(javaMethod, -1, "one_p", true, false, org.jruby.RubyEnumerable.class, "one_p", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "one?", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$1$0$take(cls, Visibility.PUBLIC, "take");
        populateMethod(javaMethod, 1, "take", true, false, org.jruby.RubyEnumerable.class, "take", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "take", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$1$0$each_slice(cls, Visibility.PUBLIC, "each_slice");
        populateMethod(javaMethod, 1, "each_slice", true, false, org.jruby.RubyEnumerable.class, "each_slice", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "each_slice", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$1$0$inverseGrep(cls, Visibility.PUBLIC, "grep_v");
        populateMethod(javaMethod, 1, "inverseGrep", true, false, org.jruby.RubyEnumerable.class, "inverseGrep", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "grep_v", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$max_by(cls, Visibility.PUBLIC, "max_by");
        populateMethod(javaMethod, -1, "max_by", true, false, org.jruby.RubyEnumerable.class, "max_by", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "max_by", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$find_all(cls, Visibility.PUBLIC, "find_all");
        populateMethod(javaMethod, 0, "find_all", true, false, org.jruby.RubyEnumerable.class, "find_all", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "find_all", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$1$0$include_p(cls, Visibility.PUBLIC, "include?");
        populateMethod(javaMethod, 1, "include_p", true, false, org.jruby.RubyEnumerable.class, "include_p", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "include?", javaMethod);
        cls.putMethod(runtime, "member?", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$flat_map(cls, Visibility.PUBLIC, "flat_map");
        populateMethod(javaMethod, 0, "flat_map", true, false, org.jruby.RubyEnumerable.class, "flat_map", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "flat_map", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$min(cls, Visibility.PUBLIC, "min");
        populateMethod(javaMethod, -1, "min", true, false, org.jruby.RubyEnumerable.class, "min", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "min", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$partition(cls, Visibility.PUBLIC, "partition");
        populateMethod(javaMethod, 0, "partition", true, false, org.jruby.RubyEnumerable.class, "partition", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "partition", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$take_while(cls, Visibility.PUBLIC, "take_while");
        populateMethod(javaMethod, 0, "take_while", true, false, org.jruby.RubyEnumerable.class, "take_while", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "take_while", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$each_with_index(cls, Visibility.PUBLIC, "each_with_index");
        populateMethod(javaMethod, -1, "each_with_index", true, false, org.jruby.RubyEnumerable.class, "each_with_index", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "each_with_index", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$sort_by(cls, Visibility.PUBLIC, "sort_by");
        populateMethod(javaMethod, 0, "sort_by", true, false, org.jruby.RubyEnumerable.class, "sort_by", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "sort_by", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$0$collect(cls, Visibility.PUBLIC, "collect");
        populateMethod(javaMethod, 0, "collect", true, false, org.jruby.RubyEnumerable.class, "collect", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "collect", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$inject(cls, Visibility.PUBLIC, "inject");
        populateMethod(javaMethod, -1, "inject", true, false, org.jruby.RubyEnumerable.class, "inject", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "inject", javaMethod);
        cls.putMethod(runtime, "reduce", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$first(cls, Visibility.PUBLIC, "first");
        populateMethod(javaMethod, -1, "first", true, false, org.jruby.RubyEnumerable.class, "first", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "first", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$0$1$any_p(cls, Visibility.PUBLIC, "any?");
        populateMethod(javaMethod, -1, "any_p", true, false, org.jruby.RubyEnumerable.class, "any_p", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "any?", javaMethod);
        javaMethod = new org.jruby.RubyEnumerable$INVOKER$s$1$0$grep(cls, Visibility.PUBLIC, "grep");
        populateMethod(javaMethod, 1, "grep", true, false, org.jruby.RubyEnumerable.class, "grep", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "grep", javaMethod);

        runtime.addBoundMethods("org.jruby.RubyEnumerable", "drop", "drop", "zip", "zip", "collect_concat", "collect_concat", "none_p", "none?", "count", "count", "to_a", "to_a", "one_p", "one?", "find_index", "find_index", "take", "take", "to_h", "to_h", "each_cons", "each_cons", "all_p", "all?", "each_slice", "each_slice", "inverseGrep", "grep_v", "include_p", "include?", "flat_map", "flat_map", "take_while", "take_while", "each_with_index", "each_with_index", "map", "map", "collect", "collect", "inject", "inject", "first", "first", "any_p", "any?", "min_by", "min_by", "find", "find", "drop_while", "drop_while", "reject", "reject", "sum", "sum", "reverse_each", "reverse_each", "sort", "sort", "select", "select", "cycle", "cycle", "detect", "detect", "max", "max", "minmax_by", "minmax_by", "minmax", "minmax", "each_entry", "each_entry", "group_by", "group_by", "chunk", "chunk", "uniq", "uniq", "each_with_object", "each_with_object", "max_by", "max_by", "find_all", "find_all", "min", "min", "partition", "partition", "sort_by", "sort_by", "grep", "grep");
    }
    static {
    }
}
/

org.jruby/ jruby-core/ 9.2.9.0/ org/jruby/gen/org$jruby$RubyEnumerable$POPULATOR.java
