Package org.ores.async

Class Asyncc

java.lang.Object

org.ores.async.Asyncc

public class Asyncc
extends java.lang.Object

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	Asyncc.AsyncCallback<T,E>
static interface	Asyncc.AsyncTask<T,E>
static class	Asyncc.EachCallback<E>
static interface	Asyncc.Eacher<T,E>
static interface	Asyncc.IAcceptRunnable
static interface	Asyncc.IAsyncCallback<T,E>
static interface	Asyncc.ICallbacks<T,E>
static interface	Asyncc.IEachCallback<E>
static interface	Asyncc.IEachCallbacks<E>
static class	Asyncc.KeyValue<K,V>
static interface	Asyncc.Mapper<T,V,E>
static class	Asyncc.ReduceArg<T,V>
static interface	Asyncc.Reducer<V,E>

Field Summary

Fields

Modifier and Type	Field	Description
static java.lang.Object	sync

Constructor Summary

Constructors

Constructor	Description
Asyncc()

Method Summary

Modifier and Type	Method	Description
static <T,E> void	Concat(int depth, java.util.List<Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.List<T>,E> f)
static <T,V,E> void	Concat(int depth, java.util.List<T> tasks, Asyncc.Mapper<T,V,E> m, Asyncc.IAsyncCallback<java.util.List<V>,E> f)
static <T,E> void	Concat(java.util.List<Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.List<T>,E> f)
static <T,V,E> void	Concat(java.util.List<T> tasks, Asyncc.Mapper<T,V,E> m, Asyncc.IAsyncCallback<java.util.List<V>,E> f)
static <T,E> void	ConcatDeep(java.util.List<Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.List<T>,E> f)
static <T,V,E> void	ConcatDeep(java.util.List<T> tasks, Asyncc.Mapper<T,V,E> m, Asyncc.IAsyncCallback<java.util.List<V>,E> f)
static <T,E> void	ConcatDeepLimit(int lim, java.util.List<Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.List<T>,E> f)
static <T,V,E> void	ConcatDeepLimit(int lim, java.util.List<T> tasks, Asyncc.Mapper<T,V,E> m, Asyncc.IAsyncCallback<java.util.List<V>,E> f)
static <T,E> void	ConcatDeepSeries(java.util.List<Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.List<T>,E> f)
static <T,V,E> void	ConcatDeepSeries(java.util.List<T> tasks, Asyncc.Mapper<T,V,E> m, Asyncc.IAsyncCallback<java.util.List<V>,E> f)
static <T,E> void	ConcatLimit(int depth, int lim, java.util.List<Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.List<T>,E> f)
static <T,V,E> void	ConcatLimit(int depth, int lim, java.util.List<T> tasks, Asyncc.Mapper<T,V,E> m, Asyncc.IAsyncCallback<java.util.List<V>,E> f)
static <T,E> void	ConcatLimit(int lim, java.util.List<Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.List<T>,E> f)
static <T,V,E> void	ConcatLimit(int lim, java.util.List<T> tasks, Asyncc.Mapper<T,V,E> m, Asyncc.IAsyncCallback<java.util.List<V>,E> f)
static <T,E> void	ConcatSeries(int depth, java.util.List<Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.List<T>,E> f)
static <T,V,E> void	ConcatSeries(int depth, java.util.List<T> tasks, Asyncc.Mapper<T,V,E> m, Asyncc.IAsyncCallback<java.util.List<V>,E> f)
static <T,E> void	ConcatSeries(java.util.List<Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.List<T>,E> f)
static <T,V,E> void	ConcatSeries(java.util.List<T> tasks, Asyncc.Mapper<T,V,E> m, Asyncc.IAsyncCallback<java.util.List<V>,E> f)
static <T,V,E> void	Each(java.lang.Iterable<T> i, Asyncc.Eacher<T,E> m, Asyncc.IEachCallback<E> f)
static <T,V,E> void	EachLimit(int limit, java.lang.Iterable<T> i, Asyncc.Eacher<T,E> m, Asyncc.IEachCallback<E> f)
static <T,V,E> void	EachSeries(java.lang.Iterable<T> i, Asyncc.Eacher<T,E> m, Asyncc.IEachCallback<E> f)
static void	getLockSync(java.lang.Runnable r)
static <T,E> void	Inject(java.util.Map.Entry<java.lang.String,NeoInject.Task<T,E>> a, Asyncc.IAsyncCallback<java.util.Map<java.lang.String,java.lang.Object>,E> f)
static <T,E> void	Inject(java.util.Map<java.lang.String,NeoInject.Task<T,E>> tasks, Asyncc.IAsyncCallback<java.util.Map<java.lang.String,java.lang.Object>,E> f)
static <V,T,E> Asyncc.AsyncTask<java.util.List<V>,E>	Map(java.lang.Integer lim, java.util.List<T> items, Asyncc.Mapper<T,V,E> m)
static <V,T,E> void	Map(java.lang.Iterable<T> items, Asyncc.Mapper<T,V,E> m, Asyncc.IAsyncCallback<java.util.List<V>,E> f)
static <V,T,E> Asyncc.AsyncTask<java.util.List<V>,E>	Map(java.util.List<T> items, Asyncc.Mapper<T,V,E> m)
static <V,T,E> void	MapLimit(java.lang.Integer limit, java.lang.Iterable<T> items, Asyncc.Mapper<T,V,E> m, Asyncc.IAsyncCallback<java.util.List<V>,E> f)
static <V,T,E> void	MapSeries(java.lang.Iterable<T> items, Asyncc.Mapper<T,V,E> m, Asyncc.IAsyncCallback<java.util.List<V>,E> f)
static <V,T,E> Asyncc.AsyncTask<java.util.List<V>,E>	MapSeries(java.util.List<T> items, Asyncc.Mapper<T,V,E> m)
static <T,E> Asyncc.AsyncTask<java.util.List<T>,E>	Parallel(java.util.List<Asyncc.AsyncTask<T,E>> tasks)
static <T,E> void	Parallel(java.util.List<Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> b, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> c, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> d, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> e, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> f, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> g, Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> cb)
static <T,E> void	Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> b, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> c, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> d, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> e, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> f, Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> cb)
static <T,E> void	Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> b, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> c, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> d, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> e, Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)
static <T,E> void	Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> b, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> c, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> d, Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)
static <T,E> void	Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> b, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> c, Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)
static <T,E> void	Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a, java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> b, Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)
static <T,E> void	Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a, Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)
static <T,E> Asyncc.AsyncTask<java.util.Map<java.lang.String,T>,E>	Parallel(java.util.Map<java.lang.String,Asyncc.AsyncTask<T,E>> tasks)
static <T,E> void	Parallel(java.util.Map<java.lang.String,Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)
static <T,E> Asyncc.AsyncTask<java.util.List<T>,E>	Parallel(Asyncc.AsyncTask<T,E>... tasks)
static <T,E> void	Parallel(Asyncc.AsyncTask<T,E> a, Asyncc.AsyncTask<T,E> b, Asyncc.AsyncTask<T,E> c, Asyncc.AsyncTask<T,E> d, Asyncc.AsyncTask<T,E> e, Asyncc.AsyncTask<T,E> f, Asyncc.AsyncTask<T,E> g, Asyncc.AsyncTask<T,E> h, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Parallel(Asyncc.AsyncTask<T,E> a, Asyncc.AsyncTask<T,E> b, Asyncc.AsyncTask<T,E> c, Asyncc.AsyncTask<T,E> d, Asyncc.AsyncTask<T,E> e, Asyncc.AsyncTask<T,E> f, Asyncc.AsyncTask<T,E> g, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Parallel(Asyncc.AsyncTask<T,E> a, Asyncc.AsyncTask<T,E> b, Asyncc.AsyncTask<T,E> c, Asyncc.AsyncTask<T,E> d, Asyncc.AsyncTask<T,E> e, Asyncc.AsyncTask<T,E> f, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Parallel(Asyncc.AsyncTask<T,E> a, Asyncc.AsyncTask<T,E> b, Asyncc.AsyncTask<T,E> c, Asyncc.AsyncTask<T,E> d, Asyncc.AsyncTask<T,E> e, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Parallel(Asyncc.AsyncTask<T,E> a, Asyncc.AsyncTask<T,E> b, Asyncc.AsyncTask<T,E> c, Asyncc.AsyncTask<T,E> d, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Parallel(Asyncc.AsyncTask<T,E> a, Asyncc.AsyncTask<T,E> b, Asyncc.AsyncTask<T,E> c, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Parallel(Asyncc.AsyncTask<T,E> a, Asyncc.AsyncTask<T,E> b, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Parallel(Asyncc.AsyncTask<T,E> a, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	ParallelLimit(int limit, java.util.List<Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)	public class JavadocTest { // indentation and line breaks are kept
static <T,E> void	ParallelLimit(int limit, java.util.Map<java.lang.String,Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)
static <I,T,V,E> void	Reduce(I initialVal, java.util.List<T> tasks, Asyncc.Reducer<V,E> m, Asyncc.IAsyncCallback<V,E> f)	new BeanTranslator.Builder() .translate( newTranslator<String, Integer>(String.class, Integer.class){ @Override public Integer translate(String instance) { return Integer.valueOf(instance); }}) .build();
static <T,V,E> void	Reduce(java.util.List<T> tasks, Asyncc.Reducer<V,E> m, Asyncc.IAsyncCallback<V,E> f)
static <I,T,V,E> void	ReduceRight(I initialVal, java.util.List<T> tasks, Asyncc.Reducer<V,E> m, Asyncc.IAsyncCallback<V,E> f)
static <T,V,E> void	ReduceRight(java.util.List<T> tasks, Asyncc.Reducer<V,E> m, Asyncc.IAsyncCallback<V,E> f)	Returns an Image object that can then be painted on the screen.
static <T,E> Asyncc.AsyncTask<java.util.List<T>,E>	Series(java.util.List<Asyncc.AsyncTask<T,E>> tasks)
static <T,E> void	Series(java.util.List<Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> Asyncc.AsyncTask<java.util.Map<java.lang.String,T>,E>	Series(java.util.Map<java.lang.String,Asyncc.AsyncTask<T,E>> tasks)
static <T,E> void	Series(java.util.Map<java.lang.String,Asyncc.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)
static <T,E> Asyncc.AsyncTask<java.util.List<T>,E>	Series(Asyncc.AsyncTask<T,E>... tasks)
static <T,E> void	Series(Asyncc.AsyncTask<T,E> a, Asyncc.AsyncTask<T,E> b, Asyncc.AsyncTask<T,E> c, Asyncc.AsyncTask<T,E> d, Asyncc.AsyncTask<T,E> e, Asyncc.AsyncTask<T,E> f, Asyncc.AsyncTask<T,E> g, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Series(Asyncc.AsyncTask<T,E> a, Asyncc.AsyncTask<T,E> b, Asyncc.AsyncTask<T,E> c, Asyncc.AsyncTask<T,E> d, Asyncc.AsyncTask<T,E> e, Asyncc.AsyncTask<T,E> f, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Series(Asyncc.AsyncTask<T,E> a, Asyncc.AsyncTask<T,E> b, Asyncc.AsyncTask<T,E> c, Asyncc.AsyncTask<T,E> d, Asyncc.AsyncTask<T,E> e, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Series(Asyncc.AsyncTask<T,E> a, Asyncc.AsyncTask<T,E> b, Asyncc.AsyncTask<T,E> c, Asyncc.AsyncTask<T,E> d, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Series(Asyncc.AsyncTask<T,E> a, Asyncc.AsyncTask<T,E> b, Asyncc.AsyncTask<T,E> c, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Series(Asyncc.AsyncTask<T,E> a, Asyncc.AsyncTask<T,E> b, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static <T,E> void	Series(Asyncc.AsyncTask<T,E> a, Asyncc.IAsyncCallback<java.util.List<T>,E> cb)
static Asyncc.IAcceptRunnable	setOnNext(Asyncc.IAcceptRunnable r)
static <T,E> void	Waterfall(java.util.List<NeoWaterfall.AsyncTask<T,E>> tasks, Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)
static <T,E> void	Waterfall(NeoWaterfall.AsyncTask<T,E> a, Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)
static <T,E> void	Waterfall(NeoWaterfall.AsyncTask<T,E> a, NeoWaterfall.AsyncTask<T,E> b, Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)
static <T,E> void	Waterfall(NeoWaterfall.AsyncTask<T,E> a, NeoWaterfall.AsyncTask<T,E> b, NeoWaterfall.AsyncTask<T,E> c, Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)
static <T,E> void	Waterfall(NeoWaterfall.AsyncTask<T,E> a, NeoWaterfall.AsyncTask<T,E> b, NeoWaterfall.AsyncTask<T,E> c, NeoWaterfall.AsyncTask<T,E> d, Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)
static <T,E> void	Waterfall(NeoWaterfall.AsyncTask<T,E> a, NeoWaterfall.AsyncTask<T,E> b, NeoWaterfall.AsyncTask<T,E> c, NeoWaterfall.AsyncTask<T,E> d, NeoWaterfall.AsyncTask<T,E> e, Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)
static <T,E> void	Waterfall(NeoWaterfall.AsyncTask<T,E> a, NeoWaterfall.AsyncTask<T,E> b, NeoWaterfall.AsyncTask<T,E> c, NeoWaterfall.AsyncTask<T,E> d, NeoWaterfall.AsyncTask<T,E> e, NeoWaterfall.AsyncTask<T,E> f, Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)

Methods inherited from class java.lang.Object

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

Field Detail

sync

public static final java.lang.Object sync

Constructor Detail

Asyncc

public Asyncc()

Method Detail

setOnNext

public static Asyncc.IAcceptRunnable setOnNext(Asyncc.IAcceptRunnable r)

Inject

public static <T,E> void Inject(java.util.Map.Entry<java.lang.String,NeoInject.Task<T,E>> a,
                                Asyncc.IAsyncCallback<java.util.Map<java.lang.String,java.lang.Object>,E> f)

Inject

public static <T,E> void Inject(java.util.Map<java.lang.String,NeoInject.Task<T,E>> tasks,
                                Asyncc.IAsyncCallback<java.util.Map<java.lang.String,java.lang.Object>,E> f)

Parallel

public static <T,E> Asyncc.AsyncTask<java.util.List<T>,E> Parallel(Asyncc.AsyncTask<T,E>... tasks)

Series

public static <T,E> Asyncc.AsyncTask<java.util.List<T>,E> Series(Asyncc.AsyncTask<T,E>... tasks)

Parallel

public static <T,E> Asyncc.AsyncTask<java.util.List<T>,E> Parallel(java.util.List<Asyncc.AsyncTask<T,E>> tasks)

Series

public static <T,E> Asyncc.AsyncTask<java.util.List<T>,E> Series(java.util.List<Asyncc.AsyncTask<T,E>> tasks)

Parallel

public static <T,E> Asyncc.AsyncTask<java.util.Map<java.lang.String,T>,E> Parallel(java.util.Map<java.lang.String,Asyncc.AsyncTask<T,E>> tasks)

Series

public static <T,E> Asyncc.AsyncTask<java.util.Map<java.lang.String,T>,E> Series(java.util.Map<java.lang.String,Asyncc.AsyncTask<T,E>> tasks)

Map

public static <V,T,E> Asyncc.AsyncTask<java.util.List<V>,E> Map(java.util.List<T> items,
                                                                Asyncc.Mapper<T,V,E> m)

MapSeries

public static <V,T,E> Asyncc.AsyncTask<java.util.List<V>,E> MapSeries(java.util.List<T> items,
                                                                      Asyncc.Mapper<T,V,E> m)

Map

public static <V,T,E> Asyncc.AsyncTask<java.util.List<V>,E> Map(java.lang.Integer lim,
                                                                java.util.List<T> items,
                                                                Asyncc.Mapper<T,V,E> m)

Map

public static <V,T,E> void Map(java.lang.Iterable<T> items,
                               Asyncc.Mapper<T,V,E> m,
                               Asyncc.IAsyncCallback<java.util.List<V>,E> f)

MapSeries

public static <V,T,E> void MapSeries(java.lang.Iterable<T> items,
                                     Asyncc.Mapper<T,V,E> m,
                                     Asyncc.IAsyncCallback<java.util.List<V>,E> f)

MapLimit

public static <V,T,E> void MapLimit(java.lang.Integer limit,
                                    java.lang.Iterable<T> items,
                                    Asyncc.Mapper<T,V,E> m,
                                    Asyncc.IAsyncCallback<java.util.List<V>,E> f)

Each

public static <T,V,E> void Each(java.lang.Iterable<T> i,
                                Asyncc.Eacher<T,E> m,
                                Asyncc.IEachCallback<E> f)

EachLimit

public static <T,V,E> void EachLimit(int limit,
                                     java.lang.Iterable<T> i,
                                     Asyncc.Eacher<T,E> m,
                                     Asyncc.IEachCallback<E> f)

EachSeries

public static <T,V,E> void EachSeries(java.lang.Iterable<T> i,
                                      Asyncc.Eacher<T,E> m,
                                      Asyncc.IEachCallback<E> f)

Series

public static <T,E> void Series(java.util.Map<java.lang.String,Asyncc.AsyncTask<T,E>> tasks,
                                Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)

Series

public static <T,E> void Series(java.util.List<Asyncc.AsyncTask<T,E>> tasks,
                                Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Series

public static <T,E> void Series(Asyncc.AsyncTask<T,E> a,
                                Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Series

public static <T,E> void Series(Asyncc.AsyncTask<T,E> a,
                                Asyncc.AsyncTask<T,E> b,
                                Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Series

public static <T,E> void Series(Asyncc.AsyncTask<T,E> a,
                                Asyncc.AsyncTask<T,E> b,
                                Asyncc.AsyncTask<T,E> c,
                                Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Series

public static <T,E> void Series(Asyncc.AsyncTask<T,E> a,
                                Asyncc.AsyncTask<T,E> b,
                                Asyncc.AsyncTask<T,E> c,
                                Asyncc.AsyncTask<T,E> d,
                                Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Series

public static <T,E> void Series(Asyncc.AsyncTask<T,E> a,
                                Asyncc.AsyncTask<T,E> b,
                                Asyncc.AsyncTask<T,E> c,
                                Asyncc.AsyncTask<T,E> d,
                                Asyncc.AsyncTask<T,E> e,
                                Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Series

public static <T,E> void Series(Asyncc.AsyncTask<T,E> a,
                                Asyncc.AsyncTask<T,E> b,
                                Asyncc.AsyncTask<T,E> c,
                                Asyncc.AsyncTask<T,E> d,
                                Asyncc.AsyncTask<T,E> e,
                                Asyncc.AsyncTask<T,E> f,
                                Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Series

public static <T,E> void Series(Asyncc.AsyncTask<T,E> a,
                                Asyncc.AsyncTask<T,E> b,
                                Asyncc.AsyncTask<T,E> c,
                                Asyncc.AsyncTask<T,E> d,
                                Asyncc.AsyncTask<T,E> e,
                                Asyncc.AsyncTask<T,E> f,
                                Asyncc.AsyncTask<T,E> g,
                                Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

ParallelLimit

public static <T,E> void ParallelLimit(int limit,
                                       java.util.Map<java.lang.String,Asyncc.AsyncTask<T,E>> tasks,
                                       Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)

Parallel

public static <T,E> void Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a,
                                  Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)

Parallel

public static <T,E> void Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> b,
                                  Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)

Parallel

public static <T,E> void Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> b,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> c,
                                  Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)

Parallel

public static <T,E> void Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> b,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> c,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> d,
                                  Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)

Parallel

public static <T,E> void Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> b,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> c,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> d,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> e,
                                  Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)

Parallel

public static <T,E> void Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> b,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> c,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> d,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> e,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> f,
                                  Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> cb)

Parallel

public static <T,E> void Parallel(java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> a,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> b,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> c,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> d,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> e,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> f,
                                  java.util.Map.Entry<java.lang.String,Asyncc.AsyncTask<T,E>> g,
                                  Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> cb)

Parallel

public static <T,E> void Parallel(java.util.Map<java.lang.String,Asyncc.AsyncTask<T,E>> tasks,
                                  Asyncc.IAsyncCallback<java.util.Map<java.lang.String,T>,E> f)

Parallel

public static <T,E> void Parallel(Asyncc.AsyncTask<T,E> a,
                                  Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Parallel

public static <T,E> void Parallel(Asyncc.AsyncTask<T,E> a,
                                  Asyncc.AsyncTask<T,E> b,
                                  Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Parallel

public static <T,E> void Parallel(Asyncc.AsyncTask<T,E> a,
                                  Asyncc.AsyncTask<T,E> b,
                                  Asyncc.AsyncTask<T,E> c,
                                  Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Parallel

public static <T,E> void Parallel(Asyncc.AsyncTask<T,E> a,
                                  Asyncc.AsyncTask<T,E> b,
                                  Asyncc.AsyncTask<T,E> c,
                                  Asyncc.AsyncTask<T,E> d,
                                  Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Parallel

public static <T,E> void Parallel(Asyncc.AsyncTask<T,E> a,
                                  Asyncc.AsyncTask<T,E> b,
                                  Asyncc.AsyncTask<T,E> c,
                                  Asyncc.AsyncTask<T,E> d,
                                  Asyncc.AsyncTask<T,E> e,
                                  Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Parallel

public static <T,E> void Parallel(Asyncc.AsyncTask<T,E> a,
                                  Asyncc.AsyncTask<T,E> b,
                                  Asyncc.AsyncTask<T,E> c,
                                  Asyncc.AsyncTask<T,E> d,
                                  Asyncc.AsyncTask<T,E> e,
                                  Asyncc.AsyncTask<T,E> f,
                                  Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Parallel

public static <T,E> void Parallel(Asyncc.AsyncTask<T,E> a,
                                  Asyncc.AsyncTask<T,E> b,
                                  Asyncc.AsyncTask<T,E> c,
                                  Asyncc.AsyncTask<T,E> d,
                                  Asyncc.AsyncTask<T,E> e,
                                  Asyncc.AsyncTask<T,E> f,
                                  Asyncc.AsyncTask<T,E> g,
                                  Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Parallel

public static <T,E> void Parallel(Asyncc.AsyncTask<T,E> a,
                                  Asyncc.AsyncTask<T,E> b,
                                  Asyncc.AsyncTask<T,E> c,
                                  Asyncc.AsyncTask<T,E> d,
                                  Asyncc.AsyncTask<T,E> e,
                                  Asyncc.AsyncTask<T,E> f,
                                  Asyncc.AsyncTask<T,E> g,
                                  Asyncc.AsyncTask<T,E> h,
                                  Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

Waterfall

public static <T,E> void Waterfall(java.util.List<NeoWaterfall.AsyncTask<T,E>> tasks,
                                   Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)

Waterfall

public static <T,E> void Waterfall(NeoWaterfall.AsyncTask<T,E> a,
                                   Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)

Waterfall

public static <T,E> void Waterfall(NeoWaterfall.AsyncTask<T,E> a,
                                   NeoWaterfall.AsyncTask<T,E> b,
                                   Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)

Waterfall

public static <T,E> void Waterfall(NeoWaterfall.AsyncTask<T,E> a,
                                   NeoWaterfall.AsyncTask<T,E> b,
                                   NeoWaterfall.AsyncTask<T,E> c,
                                   Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)

Waterfall

public static <T,E> void Waterfall(NeoWaterfall.AsyncTask<T,E> a,
                                   NeoWaterfall.AsyncTask<T,E> b,
                                   NeoWaterfall.AsyncTask<T,E> c,
                                   NeoWaterfall.AsyncTask<T,E> d,
                                   Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)

Waterfall

public static <T,E> void Waterfall(NeoWaterfall.AsyncTask<T,E> a,
                                   NeoWaterfall.AsyncTask<T,E> b,
                                   NeoWaterfall.AsyncTask<T,E> c,
                                   NeoWaterfall.AsyncTask<T,E> d,
                                   NeoWaterfall.AsyncTask<T,E> e,
                                   Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)

Waterfall

public static <T,E> void Waterfall(NeoWaterfall.AsyncTask<T,E> a,
                                   NeoWaterfall.AsyncTask<T,E> b,
                                   NeoWaterfall.AsyncTask<T,E> c,
                                   NeoWaterfall.AsyncTask<T,E> d,
                                   NeoWaterfall.AsyncTask<T,E> e,
                                   NeoWaterfall.AsyncTask<T,E> f,
                                   Asyncc.IAsyncCallback<java.util.HashMap<java.lang.String,java.lang.Object>,E> cb)

Parallel

public static <T,E> void Parallel(java.util.List<Asyncc.AsyncTask<T,E>> tasks,
                                  Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

ParallelLimit

public static <T,E> void ParallelLimit(int limit,
                                       java.util.List<Asyncc.AsyncTask<T,E>> tasks,
                                       Asyncc.IAsyncCallback<java.util.List<T>,E> cb)

 public class JavadocTest {
   // indentation and line breaks are kept

ReduceRight

public static <I,T,V,E> void ReduceRight(I initialVal,
                                         java.util.List<T> tasks,
                                         Asyncc.Reducer<V,E> m,
                                         Asyncc.IAsyncCallback<V,E> f)

ReduceRight

public static <T,V,E> void ReduceRight(java.util.List<T> tasks,
                                       Asyncc.Reducer<V,E> m,
                                       Asyncc.IAsyncCallback<V,E> f)

Returns an Image object that can then be painted on the screen.

Reduce

public static <I,T,V,E> void Reduce(I initialVal,
                                    java.util.List<T> tasks,
                                    Asyncc.Reducer<V,E> m,
                                    Asyncc.IAsyncCallback<V,E> f)

 new BeanTranslator.Builder()
   .translate(
     newTranslator<String, Integer>(String.class, Integer.class){
      @Override
       public Integer translate(String instance) {
         return Integer.valueOf(instance);
       }})
   .build();
 

Reduce

public static <T,V,E> void Reduce(java.util.List<T> tasks,
                                  Asyncc.Reducer<V,E> m,
                                  Asyncc.IAsyncCallback<V,E> f)

Concat

public static <T,V,E> void Concat(java.util.List<T> tasks,
                                  Asyncc.Mapper<T,V,E> m,
                                  Asyncc.IAsyncCallback<java.util.List<V>,E> f)

ConcatSeries

public static <T,V,E> void ConcatSeries(java.util.List<T> tasks,
                                        Asyncc.Mapper<T,V,E> m,
                                        Asyncc.IAsyncCallback<java.util.List<V>,E> f)

ConcatLimit

public static <T,V,E> void ConcatLimit(int lim,
                                       java.util.List<T> tasks,
                                       Asyncc.Mapper<T,V,E> m,
                                       Asyncc.IAsyncCallback<java.util.List<V>,E> f)

Concat

public static <T,V,E> void Concat(int depth,
                                  java.util.List<T> tasks,
                                  Asyncc.Mapper<T,V,E> m,
                                  Asyncc.IAsyncCallback<java.util.List<V>,E> f)

ConcatSeries

public static <T,V,E> void ConcatSeries(int depth,
                                        java.util.List<T> tasks,
                                        Asyncc.Mapper<T,V,E> m,
                                        Asyncc.IAsyncCallback<java.util.List<V>,E> f)

ConcatLimit

public static <T,V,E> void ConcatLimit(int depth,
                                       int lim,
                                       java.util.List<T> tasks,
                                       Asyncc.Mapper<T,V,E> m,
                                       Asyncc.IAsyncCallback<java.util.List<V>,E> f)

ConcatDeep

public static <T,V,E> void ConcatDeep(java.util.List<T> tasks,
                                      Asyncc.Mapper<T,V,E> m,
                                      Asyncc.IAsyncCallback<java.util.List<V>,E> f)

ConcatDeepSeries

public static <T,V,E> void ConcatDeepSeries(java.util.List<T> tasks,
                                            Asyncc.Mapper<T,V,E> m,
                                            Asyncc.IAsyncCallback<java.util.List<V>,E> f)

ConcatDeepLimit

public static <T,V,E> void ConcatDeepLimit(int lim,
                                           java.util.List<T> tasks,
                                           Asyncc.Mapper<T,V,E> m,
                                           Asyncc.IAsyncCallback<java.util.List<V>,E> f)

Concat

public static <T,E> void Concat(java.util.List<Asyncc.AsyncTask<T,E>> tasks,
                                Asyncc.IAsyncCallback<java.util.List<T>,E> f)

ConcatSeries

public static <T,E> void ConcatSeries(java.util.List<Asyncc.AsyncTask<T,E>> tasks,
                                      Asyncc.IAsyncCallback<java.util.List<T>,E> f)

ConcatLimit

public static <T,E> void ConcatLimit(int lim,
                                     java.util.List<Asyncc.AsyncTask<T,E>> tasks,
                                     Asyncc.IAsyncCallback<java.util.List<T>,E> f)

Concat

public static <T,E> void Concat(int depth,
                                java.util.List<Asyncc.AsyncTask<T,E>> tasks,
                                Asyncc.IAsyncCallback<java.util.List<T>,E> f)

ConcatSeries

public static <T,E> void ConcatSeries(int depth,
                                      java.util.List<Asyncc.AsyncTask<T,E>> tasks,
                                      Asyncc.IAsyncCallback<java.util.List<T>,E> f)

ConcatLimit

public static <T,E> void ConcatLimit(int depth,
                                     int lim,
                                     java.util.List<Asyncc.AsyncTask<T,E>> tasks,
                                     Asyncc.IAsyncCallback<java.util.List<T>,E> f)

ConcatDeep

public static <T,E> void ConcatDeep(java.util.List<Asyncc.AsyncTask<T,E>> tasks,
                                    Asyncc.IAsyncCallback<java.util.List<T>,E> f)

ConcatDeepSeries

public static <T,E> void ConcatDeepSeries(java.util.List<Asyncc.AsyncTask<T,E>> tasks,
                                          Asyncc.IAsyncCallback<java.util.List<T>,E> f)

ConcatDeepLimit

public static <T,E> void ConcatDeepLimit(int lim,
                                         java.util.List<Asyncc.AsyncTask<T,E>> tasks,
                                         Asyncc.IAsyncCallback<java.util.List<T>,E> f)

getLockSync

public static void getLockSync(java.lang.Runnable r)