import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
@JRubyMethod(name = "fuzz", required = 1, module = true)
public static IRubyObject fuzz(IRubyObject self, IRubyObject length) {
    final Random rnd = new Random();
    final long llen = length.convertToInteger().getLongValue();
    final int len = (int) llen;
    final byte[] bytes = new byte[len];
    for (int i = 0; i < len; i++) {
        switch (rnd.nextInt(4)) {
            case 0:
                bytes[i] = '\'';
                break;
            case 1:
                bytes[i] = '\"';
                break;
            case 2:
                bytes[i] = '\\';
                break;
            case 3:
                bytes[i] = ' ';
                break;
        }
    }
    return RubyString.newString(self.getRuntime(), bytes);
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
@JRubyMethod(name = "set", required=2)
public IRubyObject set(ThreadContext context, IRubyObject i, IRubyObject val) {
    int j = RubyNumeric.num2int(i);
    if (j >=0 && j < cnt) {
        if (j >= tailoff()) {
            RubyArray newTail = tail.aryDup();
            newTail.store(j & 0x01f, val);
            return new PersistentVector(context.runtime, getMetaClass()).initialize(context, cnt, shift, root, newTail);
        }
        return new PersistentVector(context.runtime, getMetaClass()).initialize(context, cnt, shift, doSet(context, shift, root, j, val), tail);
    }

    if (j == cnt)
        add(context, val);

    throw new IndexOutOfBoundsException();
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
@JRubyMethod(name = {"add", "append"}, required = 1)
public IRubyObject add(ThreadContext context, IRubyObject val) {
    if (cnt - tailoff() < 32) {
        PersistentVector ret = new PersistentVector(context.runtime, getMetaClass());
        RubyArray newTail = tail.aryDup();
        newTail.append(val);
        return ret.initialize(context, this.cnt+1, this.shift, this.root, newTail);
    }

    Node newroot;
    Node tailnode = new Node(context.runtime, Node).initialize_params_arry(context, root.edit, tail);
    int newshift = shift;

    if ((cnt >>> 5) > (1 << shift)) {
        newroot = new Node(context.runtime, Node).initialize_params(context, root.edit);
        newroot.array.store(0, root);
        newroot.array.store(1, newPath(context, root.edit, shift, tailnode));
        newshift += 5;
    } else
        newroot = pushTail(context, shift, root, tailnode);

    RubyArray arry = RubyArray.newArray(context.runtime);
    arry.store(0, val);

    return new PersistentVector(context.runtime, getMetaClass()).initialize(context, cnt + 1, newshift, newroot, arry);
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
@JRubyMethod(name = "eql?")
public IRubyObject eql(ThreadContext context, IRubyObject obj) {
    Ruby runtime = context.runtime;

    if (this == obj) {
        return runtime.getTrue();
    }

    if (obj instanceof PersistentVector) {
        Node otherRoot = ((PersistentVector)obj).root;
        RubyArray otherTail = ((PersistentVector)obj).tail;
        if (root.equals(otherRoot) && tail.equals(otherTail)) {
            return runtime.getTrue();
        }
    }
    return runtime.getFalse();
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
/**
 * This calls to the static method compare of DataByteArray. Given two DataByteArrays, it will call it
 * on the underlying bytes.
 *
 * @param context the context the method is being executed in
 * @param self    an class which contains metadata on the calling class (required for static Ruby methods)
 * @param arg1    a RubyDataByteArray or byte array to compare
 * @param arg2    a RubyDataByteArray or byte array to compare
 * @return        the Fixnum result of comparing arg1 and arg2's bytes
 */
@JRubyMethod
public static RubyFixnum compare(ThreadContext context, IRubyObject self, IRubyObject arg1, IRubyObject arg2) {
    byte[] buf1, buf2;
    if (arg1 instanceof RubyDataByteArray) {
        buf1 = ((RubyDataByteArray)arg1).getDBA().get();
    } else {
        buf1 = (byte[])arg1.toJava(byte[].class);
    }
    if (arg2 instanceof RubyDataByteArray) {
        buf2 = ((RubyDataByteArray)arg2).getDBA().get();
    } else {
        buf2 = (byte[])arg2.toJava(byte[].class);
    }
    return RubyFixnum.newFixnum(context.getRuntime(), DataByteArray.compare(buf1, buf2));
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
/**
 * This method allows the user to set the name of the alias of the FieldSchema of the encapsulated
 * Schema. This method only works if the Schema has one FieldSchema.
 *
 * @param arg a RubyString to set the name to
 * @return    the new name
 */
@JRubyMethod(name = "name=")
public RubyString setName(IRubyObject arg) {
    if (arg instanceof RubyString) {
         if (internalSchema.size() != 1)
             throw new RuntimeException("Can only set name if there is one schema present");
         try {
             internalSchema.getField(0).alias = arg.toString();
             return (RubyString)arg;
         } catch (FrontendException e) {
             throw new RuntimeException("Unable to get field from Schema", e);
         }
    } else {
         throw new RuntimeException("Improper argument passed to 'name=':" + arg);
    }
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
/**
 * This is an implementation of the each method which opens up the Enumerable interface,
 * and makes it very convenient to iterate over the elements of a DataBag. Note that currently,
 * due to a deficiency in JRuby, it is not possible to call each without a block given.
 *
 * @param context the context the method is being executed in
 * @param block   a block to call on the elements of the bag
 * @return        enumerator object if null block given, nil otherwise
 */
@JRubyMethod
public IRubyObject each(ThreadContext context, Block block) throws ExecException{
    Ruby runtime = context.getRuntime();

    if (!block.isGiven())
        return PigJrubyLibrary.enumeratorize(runtime, this, "each");
    /*  In a future release of JRuby when enumeratorize is made public (which is planned), should replace the above with the below
    if (!block.isGiven())
        return RubyEnumerator.enumeratorize(context.getRuntime(), this, "each");
    */

    for (Tuple t : this)
        block.yield(context, PigJrubyLibrary.pigToRuby(runtime, t));

    return context.nil;
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
/**
 * This is a convenience method which will run the given block on the first element
 * of each tuple contained.
 *
 * @param context the context the method is being executed in
 * @param block   a block to call on the elements of the bag
 * @return        enumerator object if null block given, nil otherwise
 */
@JRubyMethod(name = {"flat_each", "flatten"})
public IRubyObject flatten(ThreadContext context, Block block) throws ExecException {
    Ruby runtime = context.getRuntime();

    if (!block.isGiven())
        return PigJrubyLibrary.enumeratorize(runtime, this, "flatten");
    /*  In a future release of JRuby when enumeratorize is made public (which is planned), should replace the above with the below
    if (!block.isGiven())
        return RubyEnumerator.enumeratorize(context.getRuntime(), this, "flatten");
    */

    for (Tuple t : this)
        block.yield(context, PigJrubyLibrary.pigToRuby(runtime, t.get(0)));

    return context.nil;
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
/**
 * A ruby method that adds two numbers. In practice we would do some more 
 * complex operation in java possibly using a library method, or a pure java
 * method of our own creation (possible private).
 * @param context ThreadContext
 * @param recv the receiver
 * @param args array of input arguments
 * @return The outcome of doing a plus b.
 */
@JRubyMethod(name = "add", module = true, rest = true)
public static IRubyObject add(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
    Ruby runtime = context.getRuntime();
    // Arity.checkArgumentCount(runtime, args, Arity.OPTIONAL.getValue(), 2);
    int a = (int) args[0].toJava(Integer.class);
    int b = (int) args[1].toJava(Integer.class);
    int result = a + b;
    return runtime.newFixnum(result);
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
/**
 * Multiplies two numbers (in practice you would implement some method in java, 
 * probably using an external library)
 * @param context ThreadContext
 * @param args the ruby way of coping with more than two arguments
 * @return result probably RubyFixnum
 */
@JRubyMethod(name = "multiply", rest = true)
public IRubyObject mult(ThreadContext context, IRubyObject[] args) {
    Ruby runtime = context.getRuntime();
    // Arity.checkArgumentCount(runtime, args, Arity.OPTIONAL.getValue(), 2);
    int a = (int) args[0].toJava(Integer.class);
    int b = (int) args[1].toJava(Integer.class);
    int result = a * b;
    return runtime.newFixnum(result);
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
@JRubyMethod(required = 1, optional = 2)
public IRubyObject initialize(ThreadContext context, IRubyObject[] args) {
    Ruby runtime = context.runtime;
    this.storage = runtime.newArray();
    IRubyObject ary = null;
    if (!(args[0] instanceof RubySymbol)) {
        throw runtime.newArgumentError("Expected Symbol for type name");
    }
    this.fieldType = Utils.rubyToFieldType(args[0]);
    if (fieldType == Descriptors.FieldDescriptor.Type.MESSAGE
            || fieldType == Descriptors.FieldDescriptor.Type.ENUM) {
        if (args.length < 2)
            throw runtime.newArgumentError("Expected at least 2 arguments for message/enum");
        typeClass = args[1];
        if (args.length > 2)
            ary = args[2];
        Utils.validateTypeClass(context, fieldType, typeClass);
    } else {
        if (args.length > 2)
            throw runtime.newArgumentError("Too many arguments: expected 1 or 2");
        if (args.length > 1)
            ary = args[1];
    }
    if (ary != null) {
        RubyArray arr = ary.convertToArray();
        for (int i = 0; i < arr.size(); i++) {
            this.storage.add(arr.eltInternal(i));
        }
    }
    return this;
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
/**
 * This method calls the set method of the underlying DataByteArray with one exception:
 * if given a RubyDataByteArray, it will set the encapsulated DataByteArray to be equal.
 *
 * @param arg an object to set the encapsulated DataByteArray's bits to. In the case of
 *            a RubyString or byte array, the underlying bytes will be sit directly. In
 *            the case of a RubyDataByteArray, the encapsulated DataByteArray will be set
 *            equal to arg.
 */
@JRubyMethod
public void set(IRubyObject arg) {
    if (arg instanceof RubyDataByteArray) {
        internalDBA = ((RubyDataByteArray)arg).getDBA();
    } else if (arg instanceof RubyString) {
        internalDBA.set(arg.toString());
    } else {
        internalDBA.set((byte[])arg.toJava(byte[].class));
    }
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
@JRubyMethod
public IRubyObject oneof(ThreadContext context, IRubyObject name, Block block) {
    RubyOneofDescriptor oneofdef = (RubyOneofDescriptor)
            cOneofDescriptor.newInstance(context, Block.NULL_BLOCK);
    RubyOneofBuilderContext ctx = (RubyOneofBuilderContext)
            cOneofBuilderContext.newInstance(context, oneofdef, Block.NULL_BLOCK);
    oneofdef.setName(context, name);
    Binding binding = block.getBinding();
    binding.setSelf(ctx);
    block.yieldSpecific(context);
    descriptor.addOneof(context, oneofdef);
    return context.runtime.getNil();
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
@JRubyMethod(name = "finalize_to_pool")
public IRubyObject finalizeToPool(ThreadContext context, IRubyObject rbPool) {
    RubyDescriptorPool pool = (RubyDescriptorPool) rbPool;
    for (int i = 0; i < this.pendingList.size(); i++) {
        IRubyObject defRb = this.pendingList.entry(i);
        if (defRb instanceof RubyDescriptor) {
            pool.addToSymtab(context, (RubyDescriptor) defRb);
        } else {
            pool.addToSymtab(context, (RubyEnumDescriptor) defRb);
        }
    }
    this.pendingList = context.runtime.newArray();
    return context.runtime.getNil();
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
@JRubyMethod
public IRubyObject each(ThreadContext context, Block block) {
    Ruby runtime = context.runtime;
    for (Descriptors.EnumValueDescriptor enumValueDescriptor : descriptor.getValues()) {
        block.yield(context, runtime.newArray(runtime.newSymbol(enumValueDescriptor.getName()),
                runtime.newFixnum(enumValueDescriptor.getNumber())));
    }
    return runtime.getNil();
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
@JRubyMethod
public IRubyObject each(ThreadContext context, Block block) {
    if (!block.isGiven()) return enumeratorize(context.runtime, this, "each");

    for(int i=0; i < cnt; i++) {
        block.yield(context, nth(context, RubyFixnum.newFixnum(context.runtime, i)));
    }
    return this;
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
@JRubyMethod(name = {"collect", "map"})
public IRubyObject collect(ThreadContext context, Block block) {
    Ruby runtime = context.runtime;
    if (!block.isGiven()) return emptyVector(context, getMetaClass());

    TransientVector ret = emptyVector(context, getMetaClass()).asTransient(context);

    for (int i = 0; i < cnt; i++) {
       ret = (TransientVector) ret.conj(context, block.yield(context, get(context, i)));
    }

    return ret.persistent(context, getMetaClass());
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
@JRubyMethod(required = 3, optional = 1)
public IRubyObject optional(ThreadContext context, IRubyObject[] args) {
    IRubyObject name = args[0];
    IRubyObject type = args[1];
    IRubyObject number = args[2];
    IRubyObject typeClass = args.length > 3 ? args[3] : context.runtime.getNil();
    RubyFieldDescriptor fieldDescriptor = Utils.msgdefCreateField(context, "optional",
            name, type, number, typeClass, cFieldDescriptor);
    descriptor.addField(context, fieldDescriptor);
    return this;
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
/**
 * The ruby initializer accepts any number of arguments. With no arguments,
 * it will return an empty Schema object. It can accept any number of arguments.
 * To understand the valid arguments, see the documentation for {@link #rubyArgToSchema}.
 *
 * @param args a varargs which can take any number of valid arguments to
 *             {@link #rubyArgToSchema}
 * @return     the initialized RubySchema
 */
@JRubyMethod(rest = true)
public RubySchema initialize(IRubyObject[] args) {
    internalSchema = new Schema();
    for (IRubyObject arg : args) {
        Schema rs = rubyArgToSchema(arg);
        for (Schema.FieldSchema i : rs.getFields())
            internalSchema.add(i);
    }
    RubySchema.fixSchemaNames(internalSchema);
    return this;
}
 

import org.jruby.anno.JRubyMethod; //导入依赖的package包/类
@JRubyMethod(meta = true)
public static IRubyObject lookup(ThreadContext context, IRubyObject recv, IRubyObject number) {
    RubyEnumDescriptor rubyEnumDescriptorescriptor = (RubyEnumDescriptor) getDescriptor(context, recv);
    Descriptors.EnumDescriptor descriptor = rubyEnumDescriptorescriptor.getDescriptor();
    Descriptors.EnumValueDescriptor value = descriptor.findValueByNumber(RubyNumeric.num2int(number));
    if (value == null) return context.runtime.getNil();
    return context.runtime.newSymbol(value.getName());
}