hprose.util.concurrent

类 Promise<V>

java.lang.Object

hprose.util.concurrent.Promise<V>

所有已实现的接口:

Rejector, Resolver<V>, Thenable<V>

public final class Promise<V>
extends Object
implements Resolver<V>, Rejector, Thenable<V>

构造器概要

构造器

构造器和说明
Promise()
Promise(AsyncCall<V> computation)
Promise(Call<V> computation)
Promise(Executor<V> executor)

方法概要

限定符和类型	方法和说明
Promise<Object[]>	all()
<T> Promise<T[]>	all(Class<T> type)
static Promise<Object[]>	all(Object[] array)
static <T> Promise<T[]>	all(Object[] array, Class<T> type)
static Promise<Object[]>	all(Promise<Object[]> promise)
static <T> Promise<T[]>	all(Promise<Object[]> promise, Class<T> type)
void	always(Action<?> oncomplete)
Promise<?>	any()
<T> Promise<T>	any(Class<T> type)
static Promise<?>	any(Object[] array)
static <T> Promise<T>	any(Object[] array, Class<T> type)
static Promise<?>	any(Promise<Object[]> promise)
static <T> Promise<T>	any(Promise<Object[]> promise, Class<T> type)
Promise<?>	catchError(Action<Throwable> onreject)
Promise<?>	catchError(Action<Throwable> onreject, AsyncFunc<Boolean,Throwable> test)
Promise<?>	catchError(Action<Throwable> onreject, Func<Boolean,Throwable> test)
<R> Promise<R>	catchError(AsyncFunc<R,Throwable> onreject)
<R> Promise<R>	catchError(AsyncFunc<R,Throwable> onreject, AsyncFunc<Boolean,Throwable> test)
<R> Promise<R>	catchError(AsyncFunc<R,Throwable> onreject, Func<Boolean,Throwable> test)
<R> Promise<R>	catchError(Func<R,Throwable> onreject)
<R> Promise<R>	catchError(Func<R,Throwable> onreject, AsyncFunc<Boolean,Throwable> test)
<R> Promise<R>	catchError(Func<R,Throwable> onreject, Func<Boolean,Throwable> test)
Promise<?>	complete(Action<?> oncomplete)
<R> Promise<R>	complete(AsyncFunc<R,?> oncomplete)
<R> Promise<R>	complete(Func<R,?> oncomplete)
Promise<V>	delay(long duration)
Promise<V>	delay(long duration, TimeUnit timeunit)
static <T> Promise<T>	delayed(long duration, AsyncCall<T> computation)
static <T> Promise<T>	delayed(long duration, Call<T> computation)
static <T> Promise<T>	delayed(long duration, Promise<T> value)
static <T> Promise<T>	delayed(long duration, T value)
static <T> Promise<T>	delayed(long duration, TimeUnit timeunit, AsyncCall<T> computation)
static <T> Promise<T>	delayed(long duration, TimeUnit timeunit, Call<T> computation)
static <T> Promise<T>	delayed(long duration, TimeUnit timeunit, Promise<T> value)
static <T> Promise<T>	delayed(long duration, TimeUnit timeunit, T value)
void	done(Action<V> onfulfill)
void	done(Action<V> onfulfill, Action<Throwable> onreject)
static <T> Promise<T>	error(Throwable reason)
static <V> Promise<Boolean>	every(Func<Boolean,V> callback, Object... args)
<V> Promise<Boolean>	every(Handler<Boolean,V> callback)
static <V> Promise<Boolean>	every(Object[] array, Handler<Boolean,V> callback)
static <V> Promise<Boolean>	every(Promise<Object[]> array, Handler<Boolean,V> callback)
void	fail(Action<Throwable> onreject)
void	fill(Promise<V> promise)
static <V> Promise<Object[]>	filter(Func<Boolean,V> callback, Object... args)
<V> Promise<Object[]>	filter(Handler<Boolean,V> callback)
<V,T> Promise<T[]>	filter(Handler<Boolean,V> callback, Class<T> type)
static <V> Promise<Object[]>	filter(Object[] array, Handler<Boolean,V> callback)
static <V,T> Promise<T[]>	filter(Object[] array, Handler<Boolean,V> callback, Class<T> type)
static <V> Promise<Object[]>	filter(Promise<Object[]> array, Handler<Boolean,V> callback)
static <V,T> Promise<T[]>	filter(Promise<Object[]> array, Handler<Boolean,V> callback, Class<T> type)
static <V> Promise<?>	forEach(Action<V> callback, Object... args)
Promise<?>	forEach(Handler<?,V> callback)
static <V> Promise<?>	forEach(Object[] array, Handler<?,V> callback)
static <V> Promise<?>	forEach(Promise<Object[]> array, Handler<?,V> callback)
Throwable	getReason()
State	getState()
V	getValue()
static boolean	isPromise(Object value)
static boolean	isThenable(Object value)
static Promise<Object[]>	join(Object... args)
static <V> Promise<Object[]>	map(Func<?,V> callback, Object... args)
<V> Promise<Object[]>	map(Handler<?,V> callback)
<V,T> Promise<T[]>	map(Handler<T,V> callback, Class<T> type)
static <V> Promise<Object[]>	map(Object[] array, Handler<?,V> callback)
static <V,T> Promise<T[]>	map(Object[] array, Handler<T,V> callback, Class<T> type)
static <V> Promise<Object[]>	map(Promise<Object[]> array, Handler<?,V> callback)
static <V,T> Promise<T[]>	map(Promise<Object[]> array, Handler<T,V> callback, Class<T> type)
Promise<?>	race()
<T> Promise<T>	race(Class<T> type)
static Promise<?>	race(Object[] array)
static <T> Promise<T>	race(Object[] array, Class<T> type)
static Promise<?>	race(Promise<Object[]> promise)
static <T> Promise<T>	race(Promise<Object[]> promise, Class<T> type)
static <R,V> Promise<R>	reduce(Object[] array, Reducer<R,V> callback, R initialValue)
static <V> Promise<V>	reduce(Object[] array, Reducer<V,V> callback)
static <R,V> Promise<R>	reduce(Promise<Object[]> array, Reducer<R,V> callback, R initialValue)
static <V> Promise<V>	reduce(Promise<Object[]> array, Reducer<V,V> callback)
<R,V> Promise<R>	reduce(Reducer<R,V> callback, R initialValue)
<V> Promise<V>	reduce(Reducer<V,V> callback)
static <R,V> Promise<R>	reduceRight(Object[] array, Reducer<R,V> callback, R initialValue)
static <V> Promise<V>	reduceRight(Object[] array, Reducer<V,V> callback)
static <R,V> Promise<R>	reduceRight(Promise<Object[]> array, Reducer<R,V> callback, R initialValue)
static <V> Promise<V>	reduceRight(Promise<Object[]> array, Reducer<V,V> callback)
<R,V> Promise<R>	reduceRight(Reducer<R,V> callback, R initialValue)
<V> Promise<V>	reduceRight(Reducer<V,V> callback)
void	reject(Throwable e)
void	resolve(Object value)
void	resolve(Promise<V> value)
void	resolve(Thenable<V> value)
static Promise<?>	run(Action<Object[]> handler, Object... args)
static <V> Promise<V>	run(AsyncFunc<V,Object[]> handler, Object... args)
static <T> Promise<?>	run(Class<T> type, Action<T[]> handler, Object... args)
static <V,T> Promise<V>	run(Class<T> type, AsyncFunc<V,T[]> handler, Object... args)
static <V,T> Promise<V>	run(Class<T> type, Func<V,T[]> handler, Object... args)
static <V> Promise<V>	run(Func<V,Object[]> handler, Object... args)
static <V> Promise<Boolean>	some(Func<Boolean,V> callback, Object... args)
<V> Promise<Boolean>	some(Handler<Boolean,V> callback)
static <V> Promise<Boolean>	some(Object[] array, Handler<Boolean,V> callback)
static <V> Promise<Boolean>	some(Promise<Object[]> array, Handler<Boolean,V> callback)
static <T> Promise<T>	sync(AsyncCall<T> computation)
static <T> Promise<T>	sync(Call<T> computation)
Promise<V>	tap(Action<V> onfulfilledSideEffect)
Promise<?>	then(Action<V> onfulfill)
Promise<?>	then(Action<V> onfulfill, Action<Throwable> onreject)
<R> Promise<R>	then(AsyncFunc<R,V> onfulfill)
<R> Promise<R>	then(AsyncFunc<R,V> onfulfill, AsyncFunc<R,Throwable> onreject)
<R> Promise<R>	then(AsyncFunc<R,V> onfulfill, Func<R,Throwable> onreject)
<R> Promise<R>	then(Func<R,V> onfulfill)
<R> Promise<R>	then(Func<R,V> onfulfill, AsyncFunc<R,Throwable> onreject)
<R> Promise<R>	then(Func<R,V> onfulfill, Func<R,Throwable> onreject)
Promise<V>	timeout(long duration)
Promise<V>	timeout(long duration, Throwable reason)
Promise<V>	timeout(long duration, TimeUnit timeunit, Throwable reason)
Future<V>	toFuture()
static Promise<?>	toPromise(Object value)
static <T> Promise<T>	value(Promise<T> value)
static <T> Promise<T>	value(T value)
static <T> Promise<T>	value(Thenable<T> value)
Promise<V>	whenComplete(Action<?> action)
Promise<V>	whenComplete(Runnable action)

从类继承的方法 java.lang.Object

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

构造器详细资料

Promise

public Promise()

Promise

public Promise(Call<V> computation)

Promise

public Promise(AsyncCall<V> computation)

Promise

public Promise(Executor<V> executor)

方法详细资料

value

public static final <T> Promise<T> value(T value)

value

public static final <T> Promise<T> value(Promise<T> value)

value

public static final <T> Promise<T> value(Thenable<T> value)

error

public static final <T> Promise<T> error(Throwable reason)

delayed

public static final <T> Promise<T> delayed(long duration,
                                           TimeUnit timeunit,
                                           Call<T> computation)

delayed

public static final <T> Promise<T> delayed(long duration,
                                           TimeUnit timeunit,
                                           AsyncCall<T> computation)

delayed

public static final <T> Promise<T> delayed(long duration,
                                           TimeUnit timeunit,
                                           T value)

delayed

public static final <T> Promise<T> delayed(long duration,
                                           TimeUnit timeunit,
                                           Promise<T> value)

delayed

public static final <T> Promise<T> delayed(long duration,
                                           Call<T> computation)

delayed

public static final <T> Promise<T> delayed(long duration,
                                           AsyncCall<T> computation)

delayed

public static final <T> Promise<T> delayed(long duration,
                                           T value)

delayed

public static final <T> Promise<T> delayed(long duration,
                                           Promise<T> value)

sync

public static final <T> Promise<T> sync(Call<T> computation)

sync

public static final <T> Promise<T> sync(AsyncCall<T> computation)

isThenable

public static final boolean isThenable(Object value)

isPromise

public static final boolean isPromise(Object value)

toPromise

public static final Promise<?> toPromise(Object value)

all

public static final <T> Promise<T[]> all(Object[] array,
                                         Class<T> type)

all

public static final Promise<Object[]> all(Object[] array)

all

public static final <T> Promise<T[]> all(Promise<Object[]> promise,
                                         Class<T> type)

all

public static final Promise<Object[]> all(Promise<Object[]> promise)

all

public final <T> Promise<T[]> all(Class<T> type)

all

public final Promise<Object[]> all()

join

public static final Promise<Object[]> join(Object... args)

race

public static final <T> Promise<T> race(Object[] array,
                                        Class<T> type)

race

public static final Promise<?> race(Object[] array)

race

public static final <T> Promise<T> race(Promise<Object[]> promise,
                                        Class<T> type)

race

public static final Promise<?> race(Promise<Object[]> promise)

race

public final <T> Promise<T> race(Class<T> type)

race

public final Promise<?> race()

any

public static final <T> Promise<T> any(Object[] array,
                                       Class<T> type)

any

public static final Promise<?> any(Object[] array)

any

public static final <T> Promise<T> any(Promise<Object[]> promise,
                                       Class<T> type)

any

public static final Promise<?> any(Promise<Object[]> promise)

any

public final <T> Promise<T> any(Class<T> type)

any

public final Promise<?> any()

run

public static final Promise<?> run(Action<Object[]> handler,
                                   Object... args)

run

public static final <V> Promise<V> run(Func<V,Object[]> handler,
                                       Object... args)

run

public static final <V> Promise<V> run(AsyncFunc<V,Object[]> handler,
                                       Object... args)

run

public static final <T> Promise<?> run(Class<T> type,
                                       Action<T[]> handler,
                                       Object... args)

run

public static final <V,T> Promise<V> run(Class<T> type,
                                         Func<V,T[]> handler,
                                         Object... args)

run

public static final <V,T> Promise<V> run(Class<T> type,
                                         AsyncFunc<V,T[]> handler,
                                         Object... args)

forEach

public static final <V> Promise<?> forEach(Action<V> callback,
                                           Object... args)

forEach

public static final <V> Promise<?> forEach(Object[] array,
                                           Handler<?,V> callback)

forEach

public static final <V> Promise<?> forEach(Promise<Object[]> array,
                                           Handler<?,V> callback)

forEach

public final Promise<?> forEach(Handler<?,V> callback)

every

public static final <V> Promise<Boolean> every(Func<Boolean,V> callback,
                                               Object... args)

every

public static final <V> Promise<Boolean> every(Object[] array,
                                               Handler<Boolean,V> callback)

every

public static final <V> Promise<Boolean> every(Promise<Object[]> array,
                                               Handler<Boolean,V> callback)

every

public final <V> Promise<Boolean> every(Handler<Boolean,V> callback)

some

public static final <V> Promise<Boolean> some(Func<Boolean,V> callback,
                                              Object... args)

some

public static final <V> Promise<Boolean> some(Object[] array,
                                              Handler<Boolean,V> callback)

some

public static final <V> Promise<Boolean> some(Promise<Object[]> array,
                                              Handler<Boolean,V> callback)

some

public final <V> Promise<Boolean> some(Handler<Boolean,V> callback)

filter

public static final <V> Promise<Object[]> filter(Func<Boolean,V> callback,
                                                 Object... args)

filter

public static final <V,T> Promise<T[]> filter(Object[] array,
                                              Handler<Boolean,V> callback,
                                              Class<T> type)

filter

public static final <V> Promise<Object[]> filter(Object[] array,
                                                 Handler<Boolean,V> callback)

filter

public static final <V,T> Promise<T[]> filter(Promise<Object[]> array,
                                              Handler<Boolean,V> callback,
                                              Class<T> type)

filter

public static final <V> Promise<Object[]> filter(Promise<Object[]> array,
                                                 Handler<Boolean,V> callback)

filter

public final <V,T> Promise<T[]> filter(Handler<Boolean,V> callback,
                                       Class<T> type)

filter

public final <V> Promise<Object[]> filter(Handler<Boolean,V> callback)

map

public static final <V> Promise<Object[]> map(Func<?,V> callback,
                                              Object... args)

map

public static final <V,T> Promise<T[]> map(Object[] array,
                                           Handler<T,V> callback,
                                           Class<T> type)

map

public static final <V> Promise<Object[]> map(Object[] array,
                                              Handler<?,V> callback)

map

public static final <V,T> Promise<T[]> map(Promise<Object[]> array,
                                           Handler<T,V> callback,
                                           Class<T> type)

map

public static final <V> Promise<Object[]> map(Promise<Object[]> array,
                                              Handler<?,V> callback)

map

public final <V,T> Promise<T[]> map(Handler<T,V> callback,
                                    Class<T> type)

map

public final <V> Promise<Object[]> map(Handler<?,V> callback)

reduce

public static final <V> Promise<V> reduce(Object[] array,
                                          Reducer<V,V> callback)

reduce

public static final <V> Promise<V> reduce(Promise<Object[]> array,
                                          Reducer<V,V> callback)

reduce

public final <V> Promise<V> reduce(Reducer<V,V> callback)

reduce

public static final <R,V> Promise<R> reduce(Object[] array,
                                            Reducer<R,V> callback,
                                            R initialValue)

reduce

public static final <R,V> Promise<R> reduce(Promise<Object[]> array,
                                            Reducer<R,V> callback,
                                            R initialValue)

reduce

public final <R,V> Promise<R> reduce(Reducer<R,V> callback,
                                     R initialValue)

reduceRight

public static final <V> Promise<V> reduceRight(Object[] array,
                                               Reducer<V,V> callback)

reduceRight

public static final <V> Promise<V> reduceRight(Promise<Object[]> array,
                                               Reducer<V,V> callback)

reduceRight

public final <V> Promise<V> reduceRight(Reducer<V,V> callback)

reduceRight

public static final <R,V> Promise<R> reduceRight(Object[] array,
                                                 Reducer<R,V> callback,
                                                 R initialValue)

reduceRight

public static final <R,V> Promise<R> reduceRight(Promise<Object[]> array,
                                                 Reducer<R,V> callback,
                                                 R initialValue)

reduceRight

public final <R,V> Promise<R> reduceRight(Reducer<R,V> callback,
                                          R initialValue)

resolve

public final void resolve(Object value)

指定者:

resolve 在接口中 Resolver<V>

resolve

public final void resolve(Thenable<V> value)

resolve

public final void resolve(Promise<V> value)

指定者:

resolve 在接口中 Resolver<V>

reject

public final void reject(Throwable e)

指定者:

reject 在接口中 Rejector

then

public final Promise<?> then(Action<V> onfulfill)

then

public final <R> Promise<R> then(Func<R,V> onfulfill)

then

public final <R> Promise<R> then(AsyncFunc<R,V> onfulfill)

then

public final Promise<?> then(Action<V> onfulfill,
                             Action<Throwable> onreject)

指定者:

then 在接口中 Thenable<V>

then

public final <R> Promise<R> then(Func<R,V> onfulfill,
                                 Func<R,Throwable> onreject)

指定者:

then 在接口中 Thenable<V>

then

public final <R> Promise<R> then(AsyncFunc<R,V> onfulfill,
                                 Func<R,Throwable> onreject)

指定者:

then 在接口中 Thenable<V>

then

public final <R> Promise<R> then(AsyncFunc<R,V> onfulfill,
                                 AsyncFunc<R,Throwable> onreject)

指定者:

then 在接口中 Thenable<V>

then

public final <R> Promise<R> then(Func<R,V> onfulfill,
                                 AsyncFunc<R,Throwable> onreject)

指定者:

then 在接口中 Thenable<V>

done

public final void done(Action<V> onfulfill)

done

public final void done(Action<V> onfulfill,
                       Action<Throwable> onreject)

getState

public final State getState()

getValue

public final V getValue()

getReason

public final Throwable getReason()

catchError

public final Promise<?> catchError(Action<Throwable> onreject)

catchError

public final <R> Promise<R> catchError(Func<R,Throwable> onreject)

catchError

public final <R> Promise<R> catchError(AsyncFunc<R,Throwable> onreject)

catchError

public final Promise<?> catchError(Action<Throwable> onreject,
                                   Func<Boolean,Throwable> test)

catchError

public final <R> Promise<R> catchError(Func<R,Throwable> onreject,
                                       Func<Boolean,Throwable> test)

catchError

public final <R> Promise<R> catchError(AsyncFunc<R,Throwable> onreject,
                                       Func<Boolean,Throwable> test)

catchError

public final Promise<?> catchError(Action<Throwable> onreject,
                                   AsyncFunc<Boolean,Throwable> test)

catchError

public final <R> Promise<R> catchError(Func<R,Throwable> onreject,
                                       AsyncFunc<Boolean,Throwable> test)

catchError

public final <R> Promise<R> catchError(AsyncFunc<R,Throwable> onreject,
                                       AsyncFunc<Boolean,Throwable> test)

fail

public final void fail(Action<Throwable> onreject)

whenComplete

public final Promise<V> whenComplete(Runnable action)

whenComplete

public final Promise<V> whenComplete(Action<?> action)

complete

public final Promise<?> complete(Action<?> oncomplete)

complete

public final <R> Promise<R> complete(Func<R,?> oncomplete)

complete

public final <R> Promise<R> complete(AsyncFunc<R,?> oncomplete)

always

public final void always(Action<?> oncomplete)

fill

public final void fill(Promise<V> promise)

timeout

public final Promise<V> timeout(long duration,
                                TimeUnit timeunit,
                                Throwable reason)

timeout

public final Promise<V> timeout(long duration,
                                Throwable reason)

timeout

public final Promise<V> timeout(long duration)

delay

public final Promise<V> delay(long duration,
                              TimeUnit timeunit)

delay

public final Promise<V> delay(long duration)

tap

public final Promise<V> tap(Action<V> onfulfilledSideEffect)

toFuture

public final Future<V> toFuture()