DoubleAsyncBuilder (Primitive-Collections 0.8.0 API)

java.lang.Object
- speiger.src.collections.doubles.utils.DoubleAsyncBuilder

```
public class DoubleAsyncBuilder
extends java.lang.Object
```
The Async API allows you to process collections on a different thread without having to deal with the Multithreading complexity.
It uses the Lightweight Stream Replace API to do its work, which can make it faster then sequential streams.
This feature isn't designed to do Multithreading work, but to allow moving work off the main thread into a worker thread.
So anything executed on this is still Singlethreaded.

How it works is you create the AsyncBuilder using a Iterable of the Type.
Then select things you want to use on the Iterable.
- For example: map/filter/peek/limit/etc

After that you select your action the Iterable should be applied on.
- For Example: forEach/findFirst/matchAny/etc

Then optionally a custom Executor or callback can be applied
At the end either execute or join can be called to start the task.
- execute will return the Task reference so that the task can be traced back.
- join will await the completion of the task and return the return value

During Construction a couple Disposable Builder Objects will be created.
These will be only used during construction.

The Task Object is also pause-able/Interruptable at any moment during the Processing.
A small example
```
 public void processFiles(ObjectCollection<String> potentialFiles) {
        potentialFiles.asAsync()
                .map(Paths::get).filter(Files::exists) //Modifies the collection (Optional)
                .forEach(Files::delete) //Creates the action (Required)
                .onCompletion(T -> {}} //Callback on completion (Optional)
                .execute() //Starts the task. (Required)
 }
 
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class DoubleAsyncBuilder.BaseDoubleTask
Base Task of the Actions that can be performed.

Nested Classes
Modifier and Type	Class and Description
`static class`	`DoubleAsyncBuilder.BaseDoubleTask` Base Task of the Actions that can be performed.

Constructor Summary

Constructors
Constructor and Description
`DoubleAsyncBuilder(DoubleAsyncBuilder.BaseDoubleTask task)` Helper constructor.
`DoubleAsyncBuilder(DoubleIterable iterable)` Main Constructor that uses a Iterable to build a Offthread Task.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<E> ObjectAsyncBuilder<E>`	`arrayflatMap(DoubleFunction<E[]> mapper)` Maps the elements to something else
`IntAsyncBuilder`	`count(DoublePredicate filter)` Counts all desired elements inside the Iterable
`DoubleAsyncBuilder`	`distinct()` Removes duplicated elements out of the Iterable
`DoubleTask`	`execute()` Starts the Execution of the task without awaiting its result
`DoubleAsyncBuilder`	`executor(java.util.concurrent.Executor executor)` Optional way to add a custom executor that runs this offthread task.
`DoubleAsyncBuilder`	`filter(DoublePredicate filter)` Filters out the unwanted elements out of the Iterable
`DoubleAsyncBuilder`	`findFirst(DoublePredicate filter)` Searches through the elements of the Iterable to find if the desired element.
`<E,V extends java.lang.Iterable<E>> ObjectAsyncBuilder<E>`	`flatMap(DoubleFunction<V> mapper)` Maps the elements to something else
`ObjectAsyncBuilder<java.lang.Void>`	`forEach(DoubleConsumer action)` Iterates over the Iterable with a desired action
`double`	`join()` Starts the Execution of the task and will await its completion, returning the result.
`double`	`join(long timeout, java.util.concurrent.TimeUnit unit)` Starts the Execution of the task and will await its completion with a timeout, returning the result.
`DoubleAsyncBuilder`	`limit(long limit)` Limits how many elements are inside of the Iterable
`<E> ObjectAsyncBuilder<E>`	`map(DoubleFunction<E> mapper)` Maps the elements to something else
`BooleanAsyncBuilder`	`matchAll(DoublePredicate filter)` Searches through the elements of the Iterable to find if all the desired elements are present.
`BooleanAsyncBuilder`	`matchAny(DoublePredicate filter)` Searches through the elements of the Iterable to find if the desired element is present.
`BooleanAsyncBuilder`	`matchNone(DoublePredicate filter)` Searches through the elements of the Iterable to find if unwanted elements are present.
`static DoubleAsyncBuilder`	`of(double... values)` Helper function that automatically wraps a array into a AsyncBuilder since it forces this collections Iterable.
`static DoubleAsyncBuilder`	`of(java.lang.Iterable<java.lang.Double> iterable)` Helper function that automatically wraps a Iterable into a AsyncBuilder since it forces this collections Iterable.
`DoubleAsyncBuilder`	`onCompletion(java.util.function.Consumer<DoubleTask> callback)` Optional way to set a callback that allows to compute actions after the task was completed.
`DoubleAsyncBuilder`	`peek(DoubleConsumer action)` Allows to preview elements before they are processed
`<E extends DoubleCollection> ObjectAsyncBuilder<E>`	`pour(E collection)` Pours all elements into a collection that can be later
`ObjectAsyncBuilder<DoubleList>`	`pourAsList()` Pours all elements into a List that can be later
`ObjectAsyncBuilder<DoubleSet>`	`pourAsSet()` Pours all elements into a Set that can be later
`DoubleAsyncBuilder`	`reduce(double identity, DoubleDoubleUnaryOperator operator)` Reduces the elements inside of the Iterable down to one element using a identity element.
`DoubleAsyncBuilder`	`reduce(DoubleDoubleUnaryOperator operator)` Reduces the elements inside of the Iterable down to one element
`DoubleAsyncBuilder`	`repeat(int repeats)` Repeats the elements inside of the Iterable
`DoubleAsyncBuilder`	`sorted(DoubleComparator sorter)` Sorts the elements inside of the Iterable.
`ObjectAsyncBuilder<double[]>`	`toDoubleArray()` Pours all elements of the Iterable down into a Array.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DoubleAsyncBuilder
```
public DoubleAsyncBuilder(DoubleIterable iterable)
```
    Main Constructor that uses a Iterable to build a Offthread Task.
    
    Parameters:
    
    iterable - that should be processed
  - DoubleAsyncBuilder
```
public DoubleAsyncBuilder(DoubleAsyncBuilder.BaseDoubleTask task)
```
    Helper constructor.
    
    Parameters:
    
    task - that had been build
- Method Detail
  - of
```
public static DoubleAsyncBuilder of(java.lang.Iterable<java.lang.Double> iterable)
```
    Helper function that automatically wraps a Iterable into a AsyncBuilder since it forces this collections Iterable.
    
    Parameters:
    
    iterable - that should be wrapped
    
    Returns:
    
    a AsyncBuilder with the iterable wrapped
  - of
```
public static DoubleAsyncBuilder of(double... values)
```
    Helper function that automatically wraps a array into a AsyncBuilder since it forces this collections Iterable.
    
    Parameters:
    
    values - that should be wrapped
    
    Returns:
    
    a AsyncBuilder with the values wrapped
  - map
```
public <E> ObjectAsyncBuilder<E> map(DoubleFunction<E> mapper)
```
    Maps the elements to something else
    
    Type Parameters:
    
    E - The return type.
    
    Parameters:
    
    mapper - the mapping function
    
    Returns:
    
    a new Builder Object with the mapped Iterable
  - flatMap
```
public <E,V extends java.lang.Iterable<E>> ObjectAsyncBuilder<E> flatMap(DoubleFunction<V> mapper)
```
    Maps the elements to something else
    
    Type Parameters:
    
    V - The return type supplier.
    
    E - The return type.
    
    Parameters:
    
    mapper - the flatMapping function
    
    Returns:
    
    a new Builder Object with the mapped Iterable
  - arrayflatMap
```
public <E> ObjectAsyncBuilder<E> arrayflatMap(DoubleFunction<E[]> mapper)
```
    Maps the elements to something else
    
    Type Parameters:
    
    E - The return type.
    
    Parameters:
    
    mapper - the flatMapping function
    
    Returns:
    
    a new Builder Object with the mapped Iterable
  - filter
```
public DoubleAsyncBuilder filter(DoublePredicate filter)
```
    Filters out the unwanted elements out of the Iterable
    
    Parameters:
    
    filter - the elements that should be kept
    
    Returns:
    
    Self with a filter applied
  - distinct
```
public DoubleAsyncBuilder distinct()
```
    Removes duplicated elements out of the Iterable
    
    Returns:
    
    Self with a deduplicator applied
  - repeat
```
public DoubleAsyncBuilder repeat(int repeats)
```
    Repeats the elements inside of the Iterable
    
    Parameters:
    
    repeats - the amount of times the elements should be repeated
    
    Returns:
    
    self with a repeater applied
  - limit
```
public DoubleAsyncBuilder limit(long limit)
```
    Limits how many elements are inside of the Iterable
    
    Parameters:
    
    limit - how many elements should max be iterated through
    
    Returns:
    
    self with a limiter applied
  - sorted
```
public DoubleAsyncBuilder sorted(DoubleComparator sorter)
```
    Sorts the elements inside of the Iterable. This operation is heavily hurting performance because it rebuilds the entire iterator and then sorts it, and this will affect the pausing feature.
    
    Parameters:
    
    sorter - that sorts the elements.
    
    Returns:
    
    self with a sorter applied
  - peek
```
public DoubleAsyncBuilder peek(DoubleConsumer action)
```
    Allows to preview elements before they are processed
    
    Parameters:
    
    action - the action that should be applied
    
    Returns:
    
    self with a preview applied
  - forEach
```
public ObjectAsyncBuilder<java.lang.Void> forEach(DoubleConsumer action)
```
    Iterates over the Iterable with a desired action
    
    Parameters:
    
    action - that should be applied
    
    Returns:
    
    a new Builder with the forEach action applied.
  - reduce
```
public DoubleAsyncBuilder reduce(DoubleDoubleUnaryOperator operator)
```
    Reduces the elements inside of the Iterable down to one element
    
    Parameters:
    
    operator - that reduces the elements.
    
    Returns:
    
    self with the reduce action applied
  - reduce
```
public DoubleAsyncBuilder reduce(double identity,
                                 DoubleDoubleUnaryOperator operator)
```
    Reduces the elements inside of the Iterable down to one element using a identity element.
    
    Parameters:
    
    identity - the element the reduce function should start with
    
    operator - that reduces the elements.
    
    Returns:
    
    a new Builder with the reduce function applied
  - toDoubleArray
```
public ObjectAsyncBuilder<double[]> toDoubleArray()
```
    Pours all elements of the Iterable down into a Array.
    
    Returns:
    
    a new Builder with the ToArray function applied
  - pourAsList
```
public ObjectAsyncBuilder<DoubleList> pourAsList()
```
    Pours all elements into a List that can be later
    
    Returns:
    
    a new Builder with the pour function applied
  - pourAsSet
```
public ObjectAsyncBuilder<DoubleSet> pourAsSet()
```
    Pours all elements into a Set that can be later
    
    Returns:
    
    a new Builder with the pour function applied
  - pour
```
public <E extends DoubleCollection> ObjectAsyncBuilder<E> pour(E collection)
```
    Pours all elements into a collection that can be later
    
    Type Parameters:
    
    E - the return type
    
    Parameters:
    
    collection - the collection the elements
    
    Returns:
    
    a new Builder with the pour function applied
  - matchAny
```
public BooleanAsyncBuilder matchAny(DoublePredicate filter)
```
    Searches through the elements of the Iterable to find if the desired element is present.
    
    Parameters:
    
    filter - that decides the desired elements
    
    Returns:
    
    a new Builder with the matchAny function applied
  - matchNone
```
public BooleanAsyncBuilder matchNone(DoublePredicate filter)
```
    Searches through the elements of the Iterable to find if unwanted elements are present.
    
    Parameters:
    
    filter - that decides the unwanted elements
    
    Returns:
    
    a new Builder with the matchNone function applied
  - matchAll
```
public BooleanAsyncBuilder matchAll(DoublePredicate filter)
```
    Searches through the elements of the Iterable to find if all the desired elements are present.
    
    Parameters:
    
    filter - that decides the desired elements
    
    Returns:
    
    a new Builder with the matchAll function applied
  - findFirst
```
public DoubleAsyncBuilder findFirst(DoublePredicate filter)
```
    Searches through the elements of the Iterable to find if the desired element. If not present it will return the default value of the type
    
    Parameters:
    
    filter - that decides the desired elements
    
    Returns:
    
    self with the findFirst function applied
  - count
```
public IntAsyncBuilder count(DoublePredicate filter)
```
    Counts all desired elements inside the Iterable
    
    Parameters:
    
    filter - that decides the desired elements
    
    Returns:
    
    a new Builder with the count function applied
  - executor
```
public DoubleAsyncBuilder executor(java.util.concurrent.Executor executor)
```
    Optional way to add a custom executor that runs this offthread task. Can only be set after the action was decided on.
    
    Parameters:
    
    executor - that executes the task, defaults to SanityChecks.invokeAsyncTask(Runnable)
    
    Returns:
    
    self with the executor set
    
    Note:
    
    has to be NonNull
  - onCompletion
```
public DoubleAsyncBuilder onCompletion(java.util.function.Consumer<DoubleTask> callback)
```
    Optional way to set a callback that allows to compute actions after the task was completed. The state of the task has to be validated by the callback.
    
    Parameters:
    
    callback - that should be notified after completion of the task
    
    Returns:
    
    self with the callback set
    
    Note:
    
    can be null
  - execute
```
public DoubleTask execute()
```
    Starts the Execution of the task without awaiting its result
    
    Returns:
    
    the task object that allow to trace it.
  - join
```
public double join()
            throws java.util.concurrent.ExecutionException,
                   java.lang.InterruptedException
```
    Starts the Execution of the task and will await its completion, returning the result.
    
    Returns:
    
    the result of the task provided.
    
    Throws:
    
    java.util.concurrent.ExecutionException - if the task threw a exception
    
    java.lang.InterruptedException - if the caller thread was interrupted
  - join
```
public double join(long timeout,
                   java.util.concurrent.TimeUnit unit)
            throws java.lang.InterruptedException,
                   java.util.concurrent.ExecutionException,
                   java.util.concurrent.TimeoutException
```
    Starts the Execution of the task and will await its completion with a timeout, returning the result.
    
    Parameters:
    
    timeout - of how long the thread should wait the task to be completed
    
    unit - of the desired waiting time.
    
    Returns:
    
    the result of the provided task
    
    Throws:
    
    java.lang.InterruptedException - if the caller thread was interrupted
    
    java.util.concurrent.ExecutionException - if the task threw a exception
    
    java.util.concurrent.TimeoutException - if the timeout was reached before the task was finished

Class DoubleAsyncBuilder

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DoubleAsyncBuilder

DoubleAsyncBuilder

Method Detail

of

of

map

flatMap

arrayflatMap

filter

distinct

repeat

limit

sorted

peek

forEach

reduce

reduce

toDoubleArray

pourAsList

pourAsSet

pour

matchAny

matchNone

matchAll

findFirst

count

executor

onCompletion

execute

join

join