Examples with BooleanClosureWrapper org.codehaus.groovy.runtime.callsite.BooleanClosureWrapper used on opensource projects

Example 6 with BooleanClosureWrapper

use of org.codehaus.groovy.runtime.callsite.BooleanClosureWrapper in project groovy-core by groovy.

the class DefaultGroovyMethods method findIndexOf.

/**
     * Iterates over the elements of an iterable collection of items, starting from a
     * specified startIndex, and returns the index of the first item that matches the
     * condition specified in the closure.
     *
     * @param self       the iteration object over which to iterate
     * @param startIndex start matching from this index
     * @param closure    the filter to perform a match on the collection
     * @return an integer that is the index of the first matched object or -1 if no match was found
     * @since 1.5.0
     */
public static int findIndexOf(Object self, int startIndex, Closure closure) {
    int result = -1;
    int i = 0;
    BooleanClosureWrapper bcw = new BooleanClosureWrapper(closure);
    for (Iterator iter = InvokerHelper.asIterator(self); iter.hasNext(); i++) {
        Object value = iter.next();
        if (i < startIndex) {
            continue;
        }
        if (bcw.call(value)) {
            result = i;
            break;
        }
    }
    return result;
}

Example 7 with BooleanClosureWrapper

use of org.codehaus.groovy.runtime.callsite.BooleanClosureWrapper in project groovy-core by groovy.

the class DefaultGroovyMethods method dropWhile.

/**
     * Returns a suffix of this List where elements are dropped from the front
     * while the given Closure evaluates to true.
     * Similar to {@link #dropWhile(Iterable, groovy.lang.Closure)}
     * except that it attempts to preserve the type of the original list.
     * <pre class="groovyTestCase">
     * def nums = [ 1, 3, 2 ]
     * assert nums.dropWhile{ it < 4 } == []
     * assert nums.dropWhile{ it < 3 } == [ 3, 2 ]
     * assert nums.dropWhile{ it != 2 } == [ 2 ]
     * assert nums.dropWhile{ it == 0 } == [ 1, 3, 2 ]
     * </pre>
     *
     * @param self      the original list
     * @param condition the closure that must evaluate to true to continue dropping elements
     * @return the shortest suffix of the given List such that the given closure condition
     *         evaluates to true for each element dropped from the front of the List
     * @since 1.8.7
     */
public static <T> List<T> dropWhile(List<T> self, @ClosureParams(FirstParam.FirstGenericType.class) Closure<?> condition) {
    int num = 0;
    BooleanClosureWrapper bcw = new BooleanClosureWrapper(condition);
    for (T value : self) {
        if (bcw.call(value)) {
            num += 1;
        } else {
            break;
        }
    }
    return drop(self, num);
}

Example 8 with BooleanClosureWrapper

use of org.codehaus.groovy.runtime.callsite.BooleanClosureWrapper in project groovy-core by groovy.

the class DefaultGroovyMethods method removeAll.

/**
     * Modifies this collection by removing the elements that are matched according
     * to the specified closure condition.
     *
     * See also <code>findAll</code> and <code>grep</code> when wanting to produce a new list
     * containing items which don't match some criteria while leaving the original collection unchanged.
     *
     * @param  self a Collection to be modified
     * @param  condition a closure condition
     * @return <tt>true</tt> if this collection changed as a result of the call
     * @see    Iterator#remove()
     * @since 1.7.2
     */
public static <T> boolean removeAll(Collection<T> self, @ClosureParams(FirstParam.FirstGenericType.class) Closure condition) {
    Iterator iter = InvokerHelper.asIterator(self);
    BooleanClosureWrapper bcw = new BooleanClosureWrapper(condition);
    boolean result = false;
    while (iter.hasNext()) {
        Object value = iter.next();
        if (bcw.call(value)) {
            iter.remove();
            result = true;
        }
    }
    return result;
}

Example 9 with BooleanClosureWrapper

use of org.codehaus.groovy.runtime.callsite.BooleanClosureWrapper in project groovy by apache.

the class DefaultGroovyMethods method count.

/**
     * Counts the number of occurrences which satisfy the given closure from the
     * items within this Iterator.
     * The iterator will become exhausted of elements after determining the count value.
     * <p>
     * Example usage:
     * <pre class="groovyTestCase">assert [2,4,2,1,3,5,2,4,3].toSet().iterator().count{ it % 2 == 0 } == 2</pre>
     *
     * @param self  the Iterator from which we count the number of matching occurrences
     * @param closure a closure condition
     * @return the number of occurrences
     * @since 1.8.0
     */
public static <T> Number count(Iterator<T> self, @ClosureParams(FirstParam.FirstGenericType.class) Closure closure) {
    long answer = 0;
    BooleanClosureWrapper bcw = new BooleanClosureWrapper(closure);
    while (self.hasNext()) {
        if (bcw.call(self.next())) {
            ++answer;
        }
    }
    // for b/c with Java return an int if we can
    if (answer <= Integer.MAX_VALUE)
        return (int) answer;
    return answer;
}

Example 10 with BooleanClosureWrapper

use of org.codehaus.groovy.runtime.callsite.BooleanClosureWrapper in project groovy by apache.

the class DefaultGroovyMethods method takeWhile.

/**
     * Returns the longest prefix of this Map where each entry (or key/value pair) when
     * passed to the given closure evaluates to true.
     * <pre class="groovyTestCase">
     * def shopping = [milk:1, bread:2, chocolate:3]
     * assert shopping.takeWhile{ it.key.size() < 6 } == [milk:1, bread:2]
     * assert shopping.takeWhile{ it.value % 2 } == [milk:1]
     * assert shopping.takeWhile{ k, v -> k.size() + v <= 7 } == [milk:1, bread:2]
     * </pre>
     * If the map instance does not have ordered keys, then this function could appear to take random
     * entries. Groovy by default uses LinkedHashMap, so this shouldn't be an issue in the main.
     *
     * @param self      a Map
     * @param condition a 1 (or 2) arg Closure that must evaluate to true for the
     *                  entry (or key and value) to continue taking elements
     * @return a prefix of the given Map where each entry (or key/value pair) passed to
     *         the given closure evaluates to true
     * @since 1.8.7
     */
public static <K, V> Map<K, V> takeWhile(Map<K, V> self, @ClosureParams(MapEntryOrKeyValue.class) Closure condition) {
    if (self.isEmpty()) {
        return createSimilarMap(self);
    }
    Map<K, V> ret = createSimilarMap(self);
    BooleanClosureWrapper bcw = new BooleanClosureWrapper(condition);
    for (Map.Entry<K, V> entry : self.entrySet()) {
        if (!bcw.callForMap(entry))
            break;
        ret.put(entry.getKey(), entry.getValue());
    }
    return ret;
}