com.cloudbees.groovy.cps

Class CpsDefaultGroovyMethods

java.lang.Object

com.cloudbees.groovy.cps.CpsDefaultGroovyMethods

@Generated(value="com.cloudbees.groovy.cps.tool.Translator",
           date="Mon Sep 09 10:17:15 EDT 2019",
           comments="based on groovy-cps-dgm-builder-1.31-jar-with-dependencies.jar")
public class CpsDefaultGroovyMethods
extends Object

Method Summary

Modifier and Type	Method and Description
static void	addShutdownHook(Object self, groovy.lang.Closure closure)
static <T> boolean	any(Iterable<T> self, groovy.lang.Closure closure)
static <T> boolean	any(Iterator<T> self, groovy.lang.Closure closure)
static <K,V> boolean	any(Map<K,V> self, groovy.lang.Closure<?> closure)
static boolean	any(Object self, groovy.lang.Closure closure)
static <T,E> Collection<T>	collect(Collection<E> self, Collection<T> collector, groovy.lang.Closure<? extends T> transform)
static <S,T> List<T>	collect(Collection<S> self, groovy.lang.Closure<T> transform)
static <T,K,V> List<T>	collect(Map<K,V> self, groovy.lang.Closure<T> transform)
static <T,K,V> Collection<T>	collect(Map<K,V> self, Collection<T> collector, groovy.lang.Closure<? extends T> transform)
static <T> List<T>	collect(Object self, groovy.lang.Closure<T> transform)
static <T> Collection<T>	collect(Object self, Collection<T> collector, groovy.lang.Closure<? extends T> transform)
static <K,V,E> Map<K,V>	collectEntries(E[] self, groovy.lang.Closure<?> transform)
static <K,V,E> Map<K,V>	collectEntries(E[] self, Map<K,V> collector, groovy.lang.Closure<?> transform)
static <K,V,E> Map<K,V>	collectEntries(Iterable<E> self, groovy.lang.Closure<?> transform)
static <K,V,E> Map<K,V>	collectEntries(Iterable<E> self, Map<K,V> collector, groovy.lang.Closure<?> transform)
static <K,V,E> Map<K,V>	collectEntries(Iterator<E> self, groovy.lang.Closure<?> transform)
static <K,V,E> Map<K,V>	collectEntries(Iterator<E> self, Map<K,V> collector, groovy.lang.Closure<?> transform)
static <K,V> Map<?,?>	collectEntries(Map<K,V> self, groovy.lang.Closure<?> transform)
static <K,V,S,T> Map<K,V>	collectEntries(Map<S,T> self, Map<K,V> collector, groovy.lang.Closure<?> transform)
static <T,E> List<T>	collectMany(E[] self, groovy.lang.Closure<Collection<? extends T>> projection)
static <T,E> List<T>	collectMany(Iterable<E> self, groovy.lang.Closure<Collection<? extends T>> projection)
static <T,E> Collection<T>	collectMany(Iterable<E> self, Collection<T> collector, groovy.lang.Closure<Collection<? extends T>> projection)
static <T,E> List<T>	collectMany(Iterator<E> self, groovy.lang.Closure<Collection<? extends T>> projection)
static <T,K,V> Collection<T>	collectMany(Map<K,V> self, groovy.lang.Closure<Collection<? extends T>> projection)
static <T,K,V> Collection<T>	collectMany(Map<K,V> self, Collection<T> collector, groovy.lang.Closure<Collection<? extends T>> projection)
static List	collectNested(Collection self, groovy.lang.Closure transform)
static List	collectNested(Iterable self, groovy.lang.Closure transform)
static Collection	collectNested(Iterable self, Collection collector, groovy.lang.Closure transform)
static List	combinations(Iterable self, groovy.lang.Closure<?> function)
static <T> Number	count(Iterable<T> self, groovy.lang.Closure closure)
static <T> Number	count(Iterator<T> self, groovy.lang.Closure closure)
static <K,V> Number	count(Map<K,V> self, groovy.lang.Closure<?> closure)
static <T> Number	count(T[] self, groovy.lang.Closure closure)
static <K,E> Map<K,Integer>	countBy(E[] self, groovy.lang.Closure<K> closure)
static <K,E> Map<K,Integer>	countBy(Iterable<E> self, groovy.lang.Closure<K> closure)
static <K,E> Map<K,Integer>	countBy(Iterator<E> self, groovy.lang.Closure<K> closure)
static <K,U,V> Map<K,Integer>	countBy(Map<U,V> self, groovy.lang.Closure<K> closure)
static void	downto(BigDecimal self, Number to, groovy.lang.Closure closure)
static void	downto(BigInteger self, Number to, groovy.lang.Closure closure)
static void	downto(double self, Number to, groovy.lang.Closure closure)
static void	downto(Double self, Number to, groovy.lang.Closure closure)
static void	downto(float self, Number to, groovy.lang.Closure closure)
static void	downto(Float self, Number to, groovy.lang.Closure closure)
static void	downto(long self, Number to, groovy.lang.Closure closure)
static void	downto(Long self, Number to, groovy.lang.Closure closure)
static void	downto(Number self, Number to, groovy.lang.Closure closure)
static <T> Collection<T>	each(Collection<T> self, groovy.lang.Closure closure)
static <T> Iterable<T>	each(Iterable<T> self, groovy.lang.Closure closure)
static <T> Iterator<T>	each(Iterator<T> self, groovy.lang.Closure closure)
static <T> List<T>	each(List<T> self, groovy.lang.Closure closure)
static <K,V> Map<K,V>	each(Map<K,V> self, groovy.lang.Closure closure)
static <T> Set<T>	each(Set<T> self, groovy.lang.Closure closure)
static <T> SortedSet<T>	each(SortedSet<T> self, groovy.lang.Closure closure)
static <T> T	each(T self, groovy.lang.Closure closure)
static void	eachByte(byte[] self, groovy.lang.Closure closure)
static void	eachByte(Byte[] self, groovy.lang.Closure closure)
static void	eachCombination(Iterable self, groovy.lang.Closure<?> function)
static <T> Iterator<List<T>>	eachPermutation(Iterable<T> self, groovy.lang.Closure closure)
static <T> Collection<T>	eachWithIndex(Collection<T> self, groovy.lang.Closure closure)
static <T> Iterable<T>	eachWithIndex(Iterable<T> self, groovy.lang.Closure closure)
static <T> Iterator<T>	eachWithIndex(Iterator<T> self, groovy.lang.Closure closure)
static <T> List<T>	eachWithIndex(List<T> self, groovy.lang.Closure closure)
static <K,V> Map<K,V>	eachWithIndex(Map<K,V> self, groovy.lang.Closure closure)
static <T> Set<T>	eachWithIndex(Set<T> self, groovy.lang.Closure closure)
static <T> SortedSet<T>	eachWithIndex(SortedSet<T> self, groovy.lang.Closure closure)
static <T> T	eachWithIndex(T self, groovy.lang.Closure closure)
static <T> boolean	every(Iterable<T> self, groovy.lang.Closure closure)
static <T> boolean	every(Iterator<T> self, groovy.lang.Closure closure)
static <K,V> boolean	every(Map<K,V> self, groovy.lang.Closure closure)
static boolean	every(Object self, groovy.lang.Closure closure)
static <T> T	find(Collection<T> self, groovy.lang.Closure closure)
static <K,V> Map.Entry<K,V>	find(Map<K,V> self, groovy.lang.Closure<?> closure)
static Object	find(Object self, groovy.lang.Closure closure)
static <T> T	find(T[] self, groovy.lang.Closure condition)
static <T> Collection<T>	findAll(Collection<T> self, groovy.lang.Closure closure)
static <T> List<T>	findAll(List<T> self, groovy.lang.Closure closure)
static <K,V> Map<K,V>	findAll(Map<K,V> self, groovy.lang.Closure closure)
static Collection	findAll(Object self, groovy.lang.Closure closure)
static <T> Set<T>	findAll(Set<T> self, groovy.lang.Closure closure)
static <T> Collection<T>	findAll(T[] self, groovy.lang.Closure condition)
static int	findIndexOf(Object self, groovy.lang.Closure closure)
static int	findIndexOf(Object self, int startIndex, groovy.lang.Closure closure)
static List<Number>	findIndexValues(Object self, groovy.lang.Closure closure)
static List<Number>	findIndexValues(Object self, Number startIndex, groovy.lang.Closure closure)
static int	findLastIndexOf(Object self, groovy.lang.Closure closure)
static int	findLastIndexOf(Object self, int startIndex, groovy.lang.Closure closure)
static <T,U extends T,V extends T,E> T	findResult(Collection<E> self, U defaultResult, groovy.lang.Closure<V> closure)
static <T,U> T	findResult(Collection<U> self, groovy.lang.Closure<T> closure)
static <T,U extends T,V extends T,A,B> T	findResult(Map<A,B> self, U defaultResult, groovy.lang.Closure<V> closure)
static <T,K,V> T	findResult(Map<K,V> self, groovy.lang.Closure<T> closure)
static Object	findResult(Object self, groovy.lang.Closure closure)
static Object	findResult(Object self, Object defaultResult, groovy.lang.Closure closure)
static <T,U> Collection<T>	findResults(Iterable<U> self, groovy.lang.Closure<T> filteringTransform)
static <T,K,V> Collection<T>	findResults(Map<K,V> self, groovy.lang.Closure<T> filteringTransform)
static <T> Collection<T>	flatten(Iterable<T> self, groovy.lang.Closure<? extends T> flattenUsing)
static <K,T> Map<K,List<T>>	groupBy(Iterable<T> self, groovy.lang.Closure<K> closure)
static Map	groupBy(Iterable self, List<groovy.lang.Closure> closures)
static Map	groupBy(Iterable self, Object... closures)
static <G,K,V> Map<G,Map<K,V>>	groupBy(Map<K,V> self, groovy.lang.Closure<G> closure)
static Map<Object,Map>	groupBy(Map self, List<groovy.lang.Closure> closures)
static Map<Object,Map>	groupBy(Map self, Object... closures)
static Map	groupBy(Object[] self, List<groovy.lang.Closure> closures)
static Map	groupBy(Object[] self, Object... closures)
static <K,T> Map<K,List<T>>	groupBy(T[] self, groovy.lang.Closure<K> closure)
static <G,K,V> Map<G,List<Map.Entry<K,V>>>	groupEntriesBy(Map<K,V> self, groovy.lang.Closure<G> closure)
static <T> T	identity(Object self, groovy.lang.Closure<T> closure)
static <E,T,U extends T,V extends T> T	inject(Collection<E> self, U initialValue, groovy.lang.Closure<V> closure)
static <T,V extends T> T	inject(Collection<T> self, groovy.lang.Closure<V> closure)
static <E,T,V extends T> T	inject(E[] self, groovy.lang.Closure<V> closure)
static <E,T,U extends T,V extends T> T	inject(E[] self, U initialValue, groovy.lang.Closure<V> closure)
static <E,T,U extends T,V extends T> T	inject(Iterator<E> self, U initialValue, groovy.lang.Closure<V> closure)
static <K,V,T,U extends T,W extends T> T	inject(Map<K,V> self, U initialValue, groovy.lang.Closure<W> closure)
static <T,V extends T> T	inject(Object self, groovy.lang.Closure<V> closure)
static <T,U extends T,V extends T> T	inject(Object self, U initialValue, groovy.lang.Closure<V> closure)
static <T> T	max(Iterable<T> self, groovy.lang.Closure closure)
static <T> T	max(Iterator<T> self, groovy.lang.Closure closure)
static <T> T	max(T[] self, groovy.lang.Closure closure)
static groovy.lang.MetaClass	metaClass(Class self, groovy.lang.Closure closure)
static groovy.lang.MetaClass	metaClass(Object self, groovy.lang.Closure closure)
static <T> T	min(Iterable<T> self, groovy.lang.Closure closure)
static <T> T	min(Iterator<T> self, groovy.lang.Closure closure)
static <T> T	min(T[] self, groovy.lang.Closure closure)
static <T,V> List<V>	permutations(Iterable<T> self, groovy.lang.Closure<V> function)
static <T> boolean	removeAll(Collection<T> self, groovy.lang.Closure condition)
static <T> boolean	retainAll(Collection<T> self, groovy.lang.Closure condition)
static <T> List<T>	reverseEach(List<T> self, groovy.lang.Closure closure)
static <K,V> Map<K,V>	reverseEach(Map<K,V> self, groovy.lang.Closure closure)
static <T> T[]	reverseEach(T[] self, groovy.lang.Closure closure)
static <T> Collection<Collection<T>>	split(Collection<T> self, groovy.lang.Closure closure)
static <T> List<List<T>>	split(List<T> self, groovy.lang.Closure closure)
static Collection	split(Object self, groovy.lang.Closure closure)
static <T> List<Set<T>>	split(Set<T> self, groovy.lang.Closure closure)
static void	step(Number self, Number to, Number stepNumber, groovy.lang.Closure closure)
static Object	sum(Iterable self, groovy.lang.Closure closure)
static Object	sum(Iterable self, Object initialValue, groovy.lang.Closure closure)
static Object	sum(Iterator<Object> self, groovy.lang.Closure closure)
static Object	sum(Iterator<Object> self, Object initialValue, groovy.lang.Closure closure)
static Object	sum(Object[] self, groovy.lang.Closure closure)
static Object	sum(Object[] self, Object initialValue, groovy.lang.Closure closure)
static void	times(Number self, groovy.lang.Closure closure)
static void	upto(BigDecimal self, Number to, groovy.lang.Closure closure)
static void	upto(BigInteger self, Number to, groovy.lang.Closure closure)
static void	upto(double self, Number to, groovy.lang.Closure closure)
static void	upto(Double self, Number to, groovy.lang.Closure closure)
static void	upto(float self, Number to, groovy.lang.Closure closure)
static void	upto(Float self, Number to, groovy.lang.Closure closure)
static void	upto(long self, Number to, groovy.lang.Closure closure)
static void	upto(Long self, Number to, groovy.lang.Closure closure)
static void	upto(Number self, Number to, groovy.lang.Closure closure)
static <T> T	use(Object self, Class categoryClass, groovy.lang.Closure<T> closure)
static <T> T	use(Object self, List<Class> categoryClassList, groovy.lang.Closure<T> closure)
static <T,U> T	with(U self, groovy.lang.Closure<T> closure)
static <T> List<T>	withDefault(List<T> self, groovy.lang.Closure init)
static <K,V> Map<K,V>	withDefault(Map<K,V> self, groovy.lang.Closure init)
static <T> List<T>	withEagerDefault(List<T> self, groovy.lang.Closure init)
static <T> List<T>	withLazyDefault(List<T> self, groovy.lang.Closure init)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

addShutdownHook

public static void addShutdownHook(Object self,
                                   groovy.lang.Closure closure)

any

public static <T> boolean any(Iterable<T> self,
                              groovy.lang.Closure closure)

any

public static boolean any(Object self,
                          groovy.lang.Closure closure)

any

public static <T> boolean any(Iterator<T> self,
                              groovy.lang.Closure closure)

any

public static <K,V> boolean any(Map<K,V> self,
                                groovy.lang.Closure<?> closure)

collectEntries

public static <K,V,E> Map<K,V> collectEntries(Iterable<E> self,
                                              groovy.lang.Closure<?> transform)

collectEntries

public static <K,V,E> Map<K,V> collectEntries(Iterable<E> self,
                                              Map<K,V> collector,
                                              groovy.lang.Closure<?> transform)

collectEntries

public static <K,V,E> Map<K,V> collectEntries(E[] self,
                                              groovy.lang.Closure<?> transform)

collectEntries

public static <K,V,E> Map<K,V> collectEntries(E[] self,
                                              Map<K,V> collector,
                                              groovy.lang.Closure<?> transform)

collectEntries

public static <K,V,E> Map<K,V> collectEntries(Iterator<E> self,
                                              groovy.lang.Closure<?> transform)

collectEntries

public static <K,V,E> Map<K,V> collectEntries(Iterator<E> self,
                                              Map<K,V> collector,
                                              groovy.lang.Closure<?> transform)

collectEntries

public static <K,V> Map<?,?> collectEntries(Map<K,V> self,
                                            groovy.lang.Closure<?> transform)

collectEntries

public static <K,V,S,T> Map<K,V> collectEntries(Map<S,T> self,
                                                Map<K,V> collector,
                                                groovy.lang.Closure<?> transform)

collectMany

public static <T,E> List<T> collectMany(Iterable<E> self,
                                        groovy.lang.Closure<Collection<? extends T>> projection)

collectMany

public static <T,E> Collection<T> collectMany(Iterable<E> self,
                                              Collection<T> collector,
                                              groovy.lang.Closure<Collection<? extends T>> projection)

collectMany

public static <T,E> List<T> collectMany(E[] self,
                                        groovy.lang.Closure<Collection<? extends T>> projection)

collectMany

public static <T,E> List<T> collectMany(Iterator<E> self,
                                        groovy.lang.Closure<Collection<? extends T>> projection)

collectMany

public static <T,K,V> Collection<T> collectMany(Map<K,V> self,
                                                groovy.lang.Closure<Collection<? extends T>> projection)

collectMany

public static <T,K,V> Collection<T> collectMany(Map<K,V> self,
                                                Collection<T> collector,
                                                groovy.lang.Closure<Collection<? extends T>> projection)

collectNested

public static List collectNested(Iterable self,
                                 groovy.lang.Closure transform)

collectNested

public static Collection collectNested(Iterable self,
                                       Collection collector,
                                       groovy.lang.Closure transform)

collectNested

public static List collectNested(Collection self,
                                 groovy.lang.Closure transform)

collect

public static <T> List<T> collect(Object self,
                                  groovy.lang.Closure<T> transform)

collect

public static <T> Collection<T> collect(Object self,
                                        Collection<T> collector,
                                        groovy.lang.Closure<? extends T> transform)

collect

public static <S,T> List<T> collect(Collection<S> self,
                                    groovy.lang.Closure<T> transform)

collect

public static <T,E> Collection<T> collect(Collection<E> self,
                                          Collection<T> collector,
                                          groovy.lang.Closure<? extends T> transform)

collect

public static <T,K,V> List<T> collect(Map<K,V> self,
                                      groovy.lang.Closure<T> transform)

collect

public static <T,K,V> Collection<T> collect(Map<K,V> self,
                                            Collection<T> collector,
                                            groovy.lang.Closure<? extends T> transform)

combinations

public static List combinations(Iterable self,
                                groovy.lang.Closure<?> function)

countBy

public static <K,E> Map<K,Integer> countBy(Iterable<E> self,
                                           groovy.lang.Closure<K> closure)

countBy

public static <K,E> Map<K,Integer> countBy(E[] self,
                                           groovy.lang.Closure<K> closure)

countBy

public static <K,E> Map<K,Integer> countBy(Iterator<E> self,
                                           groovy.lang.Closure<K> closure)

countBy

public static <K,U,V> Map<K,Integer> countBy(Map<U,V> self,
                                             groovy.lang.Closure<K> closure)

count

public static <T> Number count(Iterable<T> self,
                               groovy.lang.Closure closure)

count

public static <T> Number count(T[] self,
                               groovy.lang.Closure closure)

count

public static <T> Number count(Iterator<T> self,
                               groovy.lang.Closure closure)

count

public static <K,V> Number count(Map<K,V> self,
                                 groovy.lang.Closure<?> closure)

downto

public static void downto(double self,
                          Number to,
                          groovy.lang.Closure closure)

downto

public static void downto(float self,
                          Number to,
                          groovy.lang.Closure closure)

downto

public static void downto(Double self,
                          Number to,
                          groovy.lang.Closure closure)

downto

public static void downto(Float self,
                          Number to,
                          groovy.lang.Closure closure)

downto

public static void downto(Long self,
                          Number to,
                          groovy.lang.Closure closure)

downto

public static void downto(Number self,
                          Number to,
                          groovy.lang.Closure closure)

downto

public static void downto(BigDecimal self,
                          Number to,
                          groovy.lang.Closure closure)

downto

public static void downto(BigInteger self,
                          Number to,
                          groovy.lang.Closure closure)

downto

public static void downto(long self,
                          Number to,
                          groovy.lang.Closure closure)

eachByte

public static void eachByte(byte[] self,
                            groovy.lang.Closure closure)

eachByte

public static void eachByte(Byte[] self,
                            groovy.lang.Closure closure)

eachCombination

public static void eachCombination(Iterable self,
                                   groovy.lang.Closure<?> function)

eachPermutation

public static <T> Iterator<List<T>> eachPermutation(Iterable<T> self,
                                                    groovy.lang.Closure closure)

eachWithIndex

public static <T> Iterable<T> eachWithIndex(Iterable<T> self,
                                            groovy.lang.Closure closure)

eachWithIndex

public static <T> T eachWithIndex(T self,
                                  groovy.lang.Closure closure)

eachWithIndex

public static <T> Collection<T> eachWithIndex(Collection<T> self,
                                              groovy.lang.Closure closure)

eachWithIndex

public static <T> Iterator<T> eachWithIndex(Iterator<T> self,
                                            groovy.lang.Closure closure)

eachWithIndex

public static <T> List<T> eachWithIndex(List<T> self,
                                        groovy.lang.Closure closure)

eachWithIndex

public static <K,V> Map<K,V> eachWithIndex(Map<K,V> self,
                                           groovy.lang.Closure closure)

eachWithIndex

public static <T> Set<T> eachWithIndex(Set<T> self,
                                       groovy.lang.Closure closure)

eachWithIndex

public static <T> SortedSet<T> eachWithIndex(SortedSet<T> self,
                                             groovy.lang.Closure closure)

each

public static <T> Iterable<T> each(Iterable<T> self,
                                   groovy.lang.Closure closure)

each

public static <T> T each(T self,
                         groovy.lang.Closure closure)

each

public static <T> Collection<T> each(Collection<T> self,
                                     groovy.lang.Closure closure)

each

public static <T> Iterator<T> each(Iterator<T> self,
                                   groovy.lang.Closure closure)

each

public static <T> List<T> each(List<T> self,
                               groovy.lang.Closure closure)

each

public static <K,V> Map<K,V> each(Map<K,V> self,
                                  groovy.lang.Closure closure)

each

public static <T> Set<T> each(Set<T> self,
                              groovy.lang.Closure closure)

each

public static <T> SortedSet<T> each(SortedSet<T> self,
                                    groovy.lang.Closure closure)

every

public static <T> boolean every(Iterable<T> self,
                                groovy.lang.Closure closure)

every

public static boolean every(Object self,
                            groovy.lang.Closure closure)

every

public static <T> boolean every(Iterator<T> self,
                                groovy.lang.Closure closure)

every

public static <K,V> boolean every(Map<K,V> self,
                                  groovy.lang.Closure closure)

findAll

public static Collection findAll(Object self,
                                 groovy.lang.Closure closure)

findAll

public static <T> Collection<T> findAll(T[] self,
                                        groovy.lang.Closure condition)

findAll

public static <T> Collection<T> findAll(Collection<T> self,
                                        groovy.lang.Closure closure)

findAll

public static <T> List<T> findAll(List<T> self,
                                  groovy.lang.Closure closure)

findAll

public static <K,V> Map<K,V> findAll(Map<K,V> self,
                                     groovy.lang.Closure closure)

findAll

public static <T> Set<T> findAll(Set<T> self,
                                 groovy.lang.Closure closure)

findIndexOf

public static int findIndexOf(Object self,
                              groovy.lang.Closure closure)

findIndexOf

public static int findIndexOf(Object self,
                              int startIndex,
                              groovy.lang.Closure closure)

findIndexValues

public static List<Number> findIndexValues(Object self,
                                           groovy.lang.Closure closure)

findIndexValues

public static List<Number> findIndexValues(Object self,
                                           Number startIndex,
                                           groovy.lang.Closure closure)

findLastIndexOf

public static int findLastIndexOf(Object self,
                                  groovy.lang.Closure closure)

findLastIndexOf

public static int findLastIndexOf(Object self,
                                  int startIndex,
                                  groovy.lang.Closure closure)

findResult

public static Object findResult(Object self,
                                groovy.lang.Closure closure)

findResult

public static Object findResult(Object self,
                                Object defaultResult,
                                groovy.lang.Closure closure)

findResult

public static <T,U> T findResult(Collection<U> self,
                                 groovy.lang.Closure<T> closure)

findResult

public static <T,U extends T,V extends T,E> T findResult(Collection<E> self,
                                                         U defaultResult,
                                                         groovy.lang.Closure<V> closure)

findResult

public static <T,K,V> T findResult(Map<K,V> self,
                                   groovy.lang.Closure<T> closure)

findResult

public static <T,U extends T,V extends T,A,B> T findResult(Map<A,B> self,
                                                           U defaultResult,
                                                           groovy.lang.Closure<V> closure)

findResults

public static <T,U> Collection<T> findResults(Iterable<U> self,
                                              groovy.lang.Closure<T> filteringTransform)

findResults

public static <T,K,V> Collection<T> findResults(Map<K,V> self,
                                                groovy.lang.Closure<T> filteringTransform)

find

public static Object find(Object self,
                          groovy.lang.Closure closure)

find

public static <T> T find(T[] self,
                         groovy.lang.Closure condition)

find

public static <T> T find(Collection<T> self,
                         groovy.lang.Closure closure)

find

public static <K,V> Map.Entry<K,V> find(Map<K,V> self,
                                        groovy.lang.Closure<?> closure)

flatten

public static <T> Collection<T> flatten(Iterable<T> self,
                                        groovy.lang.Closure<? extends T> flattenUsing)

groupBy

public static <K,T> Map<K,List<T>> groupBy(Iterable<T> self,
                                           groovy.lang.Closure<K> closure)

groupBy

public static Map groupBy(Iterable self,
                          Object... closures)

groupBy

public static Map groupBy(Iterable self,
                          List<groovy.lang.Closure> closures)

groupBy

public static <K,T> Map<K,List<T>> groupBy(T[] self,
                                           groovy.lang.Closure<K> closure)

groupBy

public static Map groupBy(Object[] self,
                          Object... closures)

groupBy

public static Map groupBy(Object[] self,
                          List<groovy.lang.Closure> closures)

groupBy

public static <G,K,V> Map<G,Map<K,V>> groupBy(Map<K,V> self,
                                              groovy.lang.Closure<G> closure)

groupBy

public static Map<Object,Map> groupBy(Map self,
                                      Object... closures)

groupBy

public static Map<Object,Map> groupBy(Map self,
                                      List<groovy.lang.Closure> closures)

groupEntriesBy

public static <G,K,V> Map<G,List<Map.Entry<K,V>>> groupEntriesBy(Map<K,V> self,
                                                                 groovy.lang.Closure<G> closure)

identity

public static <T> T identity(Object self,
                             groovy.lang.Closure<T> closure)

inject

public static <T,V extends T> T inject(Object self,
                                       groovy.lang.Closure<V> closure)

inject

public static <T,U extends T,V extends T> T inject(Object self,
                                                   U initialValue,
                                                   groovy.lang.Closure<V> closure)

inject

public static <E,T,V extends T> T inject(E[] self,
                                         groovy.lang.Closure<V> closure)

inject

public static <E,T,U extends T,V extends T> T inject(E[] self,
                                                     U initialValue,
                                                     groovy.lang.Closure<V> closure)

inject

public static <T,V extends T> T inject(Collection<T> self,
                                       groovy.lang.Closure<V> closure)

inject

public static <E,T,U extends T,V extends T> T inject(Collection<E> self,
                                                     U initialValue,
                                                     groovy.lang.Closure<V> closure)

inject

public static <E,T,U extends T,V extends T> T inject(Iterator<E> self,
                                                     U initialValue,
                                                     groovy.lang.Closure<V> closure)

inject

public static <K,V,T,U extends T,W extends T> T inject(Map<K,V> self,
                                                       U initialValue,
                                                       groovy.lang.Closure<W> closure)

max

public static <T> T max(Iterable<T> self,
                        groovy.lang.Closure closure)

max

public static <T> T max(T[] self,
                        groovy.lang.Closure closure)

max

public static <T> T max(Iterator<T> self,
                        groovy.lang.Closure closure)

metaClass

public static groovy.lang.MetaClass metaClass(Class self,
                                              groovy.lang.Closure closure)

metaClass

public static groovy.lang.MetaClass metaClass(Object self,
                                              groovy.lang.Closure closure)

min

public static <T> T min(Iterable<T> self,
                        groovy.lang.Closure closure)

min

public static <T> T min(T[] self,
                        groovy.lang.Closure closure)

min

public static <T> T min(Iterator<T> self,
                        groovy.lang.Closure closure)

permutations

public static <T,V> List<V> permutations(Iterable<T> self,
                                         groovy.lang.Closure<V> function)

removeAll

public static <T> boolean removeAll(Collection<T> self,
                                    groovy.lang.Closure condition)

retainAll

public static <T> boolean retainAll(Collection<T> self,
                                    groovy.lang.Closure condition)

reverseEach

public static <T> T[] reverseEach(T[] self,
                                  groovy.lang.Closure closure)

reverseEach

public static <T> List<T> reverseEach(List<T> self,
                                      groovy.lang.Closure closure)

reverseEach

public static <K,V> Map<K,V> reverseEach(Map<K,V> self,
                                         groovy.lang.Closure closure)

split

public static Collection split(Object self,
                               groovy.lang.Closure closure)

split

public static <T> Collection<Collection<T>> split(Collection<T> self,
                                                  groovy.lang.Closure closure)

split

public static <T> List<List<T>> split(List<T> self,
                                      groovy.lang.Closure closure)

split

public static <T> List<Set<T>> split(Set<T> self,
                                     groovy.lang.Closure closure)

step

public static void step(Number self,
                        Number to,
                        Number stepNumber,
                        groovy.lang.Closure closure)

sum

public static Object sum(Iterable self,
                         groovy.lang.Closure closure)

sum

public static Object sum(Iterable self,
                         Object initialValue,
                         groovy.lang.Closure closure)

sum

public static Object sum(Object[] self,
                         groovy.lang.Closure closure)

sum

public static Object sum(Object[] self,
                         Object initialValue,
                         groovy.lang.Closure closure)

sum

public static Object sum(Iterator<Object> self,
                         groovy.lang.Closure closure)

sum

public static Object sum(Iterator<Object> self,
                         Object initialValue,
                         groovy.lang.Closure closure)

times

public static void times(Number self,
                         groovy.lang.Closure closure)

upto

public static void upto(double self,
                        Number to,
                        groovy.lang.Closure closure)

upto

public static void upto(float self,
                        Number to,
                        groovy.lang.Closure closure)

upto

public static void upto(Double self,
                        Number to,
                        groovy.lang.Closure closure)

upto

public static void upto(Float self,
                        Number to,
                        groovy.lang.Closure closure)

upto

public static void upto(Long self,
                        Number to,
                        groovy.lang.Closure closure)

upto

public static void upto(Number self,
                        Number to,
                        groovy.lang.Closure closure)

upto

public static void upto(BigDecimal self,
                        Number to,
                        groovy.lang.Closure closure)

upto

public static void upto(BigInteger self,
                        Number to,
                        groovy.lang.Closure closure)

upto

public static void upto(long self,
                        Number to,
                        groovy.lang.Closure closure)

use

public static <T> T use(Object self,
                        Class categoryClass,
                        groovy.lang.Closure<T> closure)

use

public static <T> T use(Object self,
                        List<Class> categoryClassList,
                        groovy.lang.Closure<T> closure)

withDefault

public static <T> List<T> withDefault(List<T> self,
                                      groovy.lang.Closure init)

withDefault

public static <K,V> Map<K,V> withDefault(Map<K,V> self,
                                         groovy.lang.Closure init)

withEagerDefault

public static <T> List<T> withEagerDefault(List<T> self,
                                           groovy.lang.Closure init)

withLazyDefault

public static <T> List<T> withLazyDefault(List<T> self,
                                          groovy.lang.Closure init)

with

public static <T,U> T with(U self,
                           groovy.lang.Closure<T> closure)