org.ow2.proactive.utils

Class Lambda

java.lang.Object

org.ow2.proactive.utils.Lambda

public class Lambda
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	Lambda.CallableThatThrows<T>
static interface	Lambda.FunctionThatThrows<T,R>
static interface	Lambda.IteratorWithIndex<T>
static interface	Lambda.RunnableThatThrows
static interface	Lambda.RunnableThatThrows3Exceptions<A extends Throwable,B extends Throwable,C extends Throwable>

Field Summary

Fields

Modifier and Type	Field and Description
static BiConsumer<Integer,Lambda.RunnableThatThrows>	repeater repeats func function limit number of times

Method Summary

Modifier and Type	Method and Description
static <T> void	forEachWithIndex(Iterable<T> iterable, Lambda.IteratorWithIndex<T> iteratorWithIndex)
static <A,B,C> Map<B,C>	mapKeys(Map<A,C> map, Function<A,B> mapper)
static <A,B,C> Map<A,C>	mapValues(Map<A,B> map, Function<B,C> mapper)
static <T> Callable<T>	silent(Lambda.CallableThatThrows<T> functionThatThrows)
static <T,R> Function<T,R>	silent(Lambda.FunctionThatThrows<T,R> functionThatThrows)
static Runnable	silent(Lambda.RunnableThatThrows functionThatThrows)
static <T> T	withLock(Lock lock, Callable<T> callable) Execute a callable with lock acquire/release
static void	withLock(Lock lock, Runnable runnable) Execute a runnable with lock acquire/release
static <T,E1 extends Exception> T	withLockException1(Lock lock, Callable<T> callable, Class<E1> exception1Class) Execute a callable with lock acquire/release, handling one checked exception
static <T,E1 extends Exception,E2 extends Exception> T	withLockException2(Lock lock, Callable<T> callable, Class<E1> exception1Class, Class<E2> exception2Class) Execute a callable with lock acquire/release, handling two checked exceptions
static <T,E extends Exception> T	withLockInterruptible(Lock lock, Callable<T> callable, E interruptedException) Execute a callable with lock acquire/release, handling InterruptedException

Methods inherited from class java.lang.Object

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

Field Detail

repeater

public static final BiConsumer<Integer,Lambda.RunnableThatThrows> repeater

repeats func function limit number of times

Method Detail

withLock

public static void withLock(Lock lock,
                            Runnable runnable)

Execute a runnable with lock acquire/release

Parameters:

lock - the lock to acquire

runnable - code to execute

withLock

public static <T> T withLock(Lock lock,
                             Callable<T> callable)

Execute a callable with lock acquire/release

Type Parameters:

T - return type

Parameters:

lock - the lock to acquire

callable - code to execute

Returns:

the callable result

withLockInterruptible

public static <T,E extends Exception> T withLockInterruptible(Lock lock,
                                                              Callable<T> callable,
                                                              E interruptedException)
                                                       throws E extends Exception

Execute a callable with lock acquire/release, handling InterruptedException

Type Parameters:

T - return type

E - wrapper exception type

Parameters:

lock - the lock to acquire interruptibly

callable - code to execute

interruptedException - exception which will be used to wrap the InterruptedException (null to use a RuntimeException)

Returns:

the callable result

Throws:

E - when the lock is interrupted

E extends Exception

withLockException1

public static <T,E1 extends Exception> T withLockException1(Lock lock,
                                                            Callable<T> callable,
                                                            Class<E1> exception1Class)
                                                     throws E1 extends Exception

Execute a callable with lock acquire/release, handling one checked exception

Type Parameters:

T - return type

E1 - type of checked exception

Parameters:

lock - the lock to acquire

callable - code to execute

exception1Class - the class of the checked exception which will be handled

Returns:

the callable result

Throws:

E1 - when this exception occurs in the callable

E1 extends Exception

withLockException2

public static <T,E1 extends Exception,E2 extends Exception> T withLockException2(Lock lock,
                                                                                 Callable<T> callable,
                                                                                 Class<E1> exception1Class,
                                                                                 Class<E2> exception2Class)
                                                                          throws E1 extends Exception,
                                                                                 E2 extends Exception

Execute a callable with lock acquire/release, handling two checked exceptions

Type Parameters:

T - return type

E1 - type of the first checked exception

E2 - type of the second checked exception

Parameters:

lock - the lock to acquire

callable - code to execute

exception1Class - the class of the first checked exception which will be handled

exception2Class - the class of the second checked exception which will be handled

Returns:

the callable result

Throws:

E1 - when the first exception type occurs in the callable

E2 - when the second exception type occurs in the callable

E1 extends Exception

silent

public static <T,R> Function<T,R> silent(Lambda.FunctionThatThrows<T,R> functionThatThrows)

silent

public static <T> Callable<T> silent(Lambda.CallableThatThrows<T> functionThatThrows)

silent

public static Runnable silent(Lambda.RunnableThatThrows functionThatThrows)

forEachWithIndex

public static <T> void forEachWithIndex(Iterable<T> iterable,
                                        Lambda.IteratorWithIndex<T> iteratorWithIndex)

mapValues

public static <A,B,C> Map<A,C> mapValues(Map<A,B> map,
                                         Function<B,C> mapper)

mapKeys

public static <A,B,C> Map<B,C> mapKeys(Map<A,C> map,
                                       Function<A,B> mapper)