Java Block.isGiven方法代码示例

import org.jruby.runtime.Block; //导入方法依赖的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.runtime.Block; //导入方法依赖的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.runtime.Block; //导入方法依赖的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.runtime.Block; //导入方法依赖的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.runtime.Block; //导入方法依赖的package包/类
private XmlNode getStartingNode(Block block) {
    if (block.isGiven()) {
        if (block.getBinding().getSelf() instanceof XmlNode) {
            return (XmlNode)block.getBinding().getSelf();
        }
    }
    return this;
}
 

import org.jruby.runtime.Block; //导入方法依赖的package包/类
@JRubyMethod
public IRubyObject select(ThreadContext context, Block block) {
    return block.isGiven() ? selectCommon(context, block) : enumeratorize(context.runtime, this, "select");
}
 

import org.jruby.runtime.Block; //导入方法依赖的package包/类
@JRubyMethod
public IRubyObject reject(ThreadContext context, Block block) {
    return block.isGiven() ? rejectCommon(context, block) : enumeratorize(context.runtime, this, "reject");
}
 

import org.jruby.runtime.Block; //导入方法依赖的package包/类
/**
 * Allocate a new object, perform initialization, call that
 * object's initialize method, and call any block passing the
 * object as the only argument.  If <code>cls</code> is
 * Nokogiri::XML::Node, creates a new Nokogiri::XML::Element
 * instead.
 *
 * This static method seems to be inherited, strangely enough.
 * E.g. creating a new XmlAttr from Ruby code calls this method if
 * XmlAttr does not define its own 'new' method.
 *
 * Since there is some Java bookkeeping that always needs to
 * happen, we don't define the 'initialize' method in Java because
 * we'd have to count on subclasses calling 'super'.
 *
 * The main consequence of this is that every subclass needs to
 * define its own 'new' method.
 *
 * As a convenience, this method does the following:
 *
 * <ul>
 *
 * <li>allocates a new object using the allocator assigned to
 * <code>cls</code></li>
 *
 * <li>calls the Java method init(); subclasses can override this,
 * otherwise they should implement a specific 'new' method</li>
 *
 * <li>invokes the Ruby initializer</li>
 *
 * <li>if a block is given, calls the block with the new node as
 * the argument</li>
 *
 * </ul>
 *
 * -pmahoney
 */
@JRubyMethod(name = "new", meta = true, rest = true)
public static IRubyObject rbNew(ThreadContext context, IRubyObject cls,
                                IRubyObject[] args, Block block) {
    Ruby ruby = context.getRuntime();
    RubyClass klazz = (RubyClass) cls;

    if (cls.equals(getNokogiriClass(ruby, "Nokogiri::XML::Node"))) {
        klazz = getNokogiriClass(ruby, "Nokogiri::XML::Element");
    }

    XmlNode xmlNode = (XmlNode) klazz.allocate();
    xmlNode.init(context, args);
    xmlNode.callInit(args, block);
    if (xmlNode.node == null) context.getRuntime().newRuntimeError("NODE IS NULL");
    if (block.isGiven()) block.call(context, xmlNode);
    return xmlNode;
}