Modul speiger.src.collections
Package speiger.src.collections.floats.utils

Klasse FloatAsyncBuilder

java.lang.Object
speiger.src.collections.floats.utils.FloatAsyncBuilder
public class FloatAsyncBuilder extends 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)
 }

  • Konstruktordetails

    • FloatAsyncBuilder

      public FloatAsyncBuilder(FloatIterable iterable)
      Main Constructor that uses a Iterable to build a Offthread Task.
      Parameter:
      iterable - that should be processed

    • FloatAsyncBuilder

      public FloatAsyncBuilder(FloatAsyncBuilder.BaseFloatTask task)
      Helper constructor.
      Parameter:
      task - that had been build

  • Methodendetails

    • of

      public static FloatAsyncBuilder of(Iterable<Float> iterable)
      Helper function that automatically wraps a Iterable into a AsyncBuilder since it forces this collections Iterable.
      Parameter:
      iterable - that should be wrapped
      Gibt zurück:
      a AsyncBuilder with the iterable wrapped

    • of

      public static FloatAsyncBuilder of(float... values)
      Helper function that automatically wraps a array into a AsyncBuilder since it forces this collections Iterable.
      Parameter:
      values - that should be wrapped
      Gibt zurück:
      a AsyncBuilder with the values wrapped

    • map

      public <E> ObjectAsyncBuilder<E> map(FloatFunction<E> mapper)
      Maps the elements to something else
      Typparameter:
      E - The return type.
      Parameter:
      mapper - the mapping function
      Gibt zurück:
      a new Builder Object with the mapped Iterable

    • flatMap

      public <E, V extends Iterable<E>> ObjectAsyncBuilder<E> flatMap(FloatFunction<V> mapper)
      Maps the elements to something else
      Typparameter:
      E - The return type.
      V - The return type supplier.
      Parameter:
      mapper - the flatMapping function
      Gibt zurück:
      a new Builder Object with the mapped Iterable

    • arrayflatMap

      public <E> ObjectAsyncBuilder<E> arrayflatMap(FloatFunction<E[]> mapper)
      Maps the elements to something else
      Typparameter:
      E - The return type.
      Parameter:
      mapper - the flatMapping function
      Gibt zurück:
      a new Builder Object with the mapped Iterable

    • filter

      public FloatAsyncBuilder filter(FloatPredicate filter)
      Filters out the unwanted elements out of the Iterable
      Parameter:
      filter - the elements that should be kept
      Gibt zurück:
      Self with a filter applied

    • distinct

      public FloatAsyncBuilder distinct()
      Removes duplicated elements out of the Iterable
      Gibt zurück:
      Self with a deduplicator applied

    • repeat

      public FloatAsyncBuilder repeat(int repeats)
      Repeats the elements inside of the Iterable
      Parameter:
      repeats - the amount of times the elements should be repeated
      Gibt zurück:
      self with a repeater applied

    • limit

      public FloatAsyncBuilder limit(long limit)
      Limits how many elements are inside of the Iterable
      Parameter:
      limit - how many elements should max be iterated through
      Gibt zurück:
      self with a limiter applied

    • sorted

      public FloatAsyncBuilder sorted(FloatComparator 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.
      Parameter:
      sorter - that sorts the elements.
      Gibt zurück:
      self with a sorter applied

    • peek

      public FloatAsyncBuilder peek(FloatConsumer action)
      Allows to preview elements before they are processed
      Parameter:
      action - the action that should be applied
      Gibt zurück:
      self with a preview applied

    • forEach

      public ObjectAsyncBuilder<Void> forEach(FloatConsumer action)
      Iterates over the Iterable with a desired action
      Parameter:
      action - that should be applied
      Gibt zurück:
      a new Builder with the forEach action applied.

    • reduce

      public FloatAsyncBuilder reduce(FloatFloatUnaryOperator operator)
      Reduces the elements inside of the Iterable down to one element
      Parameter:
      operator - that reduces the elements.
      Gibt zurück:
      self with the reduce action applied

    • reduce

      public FloatAsyncBuilder reduce(float identity, FloatFloatUnaryOperator operator)
      Reduces the elements inside of the Iterable down to one element using a identity element.
      Parameter:
      identity - the element the reduce function should start with
      operator - that reduces the elements.
      Gibt zurück:
      a new Builder with the reduce function applied

    • toFloatArray

      public ObjectAsyncBuilder<float[]> toFloatArray()
      Pours all elements of the Iterable down into a Array.
      Gibt zurück:
      a new Builder with the ToArray function applied

    • pourAsList

      public ObjectAsyncBuilder<FloatList> pourAsList()
      Pours all elements into a List that can be later
      Gibt zurück:
      a new Builder with the pour function applied

    • pourAsSet

      public ObjectAsyncBuilder<FloatSet> pourAsSet()
      Pours all elements into a Set that can be later
      Gibt zurück:
      a new Builder with the pour function applied

    • pour

      public <E extends FloatCollection> ObjectAsyncBuilder<E> pour(E collection)
      Pours all elements into a collection that can be later
      Typparameter:
      E - the return type
      Parameter:
      collection - the collection the elements
      Gibt zurück:
      a new Builder with the pour function applied

    • matchAny

      public BooleanAsyncBuilder matchAny(FloatPredicate filter)
      Searches through the elements of the Iterable to find if the desired element is present.
      Parameter:
      filter - that decides the desired elements
      Gibt zurück:
      a new Builder with the matchAny function applied

    • matchNone

      public BooleanAsyncBuilder matchNone(FloatPredicate filter)
      Searches through the elements of the Iterable to find if unwanted elements are present.
      Parameter:
      filter - that decides the unwanted elements
      Gibt zurück:
      a new Builder with the matchNone function applied

    • matchAll

      public BooleanAsyncBuilder matchAll(FloatPredicate filter)
      Searches through the elements of the Iterable to find if all the desired elements are present.
      Parameter:
      filter - that decides the desired elements
      Gibt zurück:
      a new Builder with the matchAll function applied

    • findFirst

      public FloatAsyncBuilder findFirst(FloatPredicate 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
      Parameter:
      filter - that decides the desired elements
      Gibt zurück:
      self with the findFirst function applied

    • count

      public IntAsyncBuilder count(FloatPredicate filter)
      Counts all desired elements inside the Iterable
      Parameter:
      filter - that decides the desired elements
      Gibt zurück:
      a new Builder with the count function applied

    • executor

      public FloatAsyncBuilder executor(Executor executor)
      Optional way to add a custom executor that runs this offthread task. Can only be set after the action was decided on.
      Parameter:
      executor - that executes the task, defaults to SanityChecks.invokeAsyncTask(Runnable)
      Gibt zurück:
      self with the executor set
      Note:
      has to be NonNull

    • onCompletion

      public FloatAsyncBuilder onCompletion(Consumer<FloatTask> 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.
      Parameter:
      callback - that should be notified after completion of the task
      Gibt zurück:
      self with the callback set
      Note:
      can be null

    • execute

      public FloatTask execute()
      Starts the Execution of the task without awaiting its result
      Gibt zurück:
      the task object that allow to trace it.

    • join

      public float join() throws ExecutionException, InterruptedException
      Starts the Execution of the task and will await its completion, returning the result.
      Gibt zurück:
      the result of the task provided.
      Löst aus:
      ExecutionException - if the task threw a exception
      InterruptedException - if the caller thread was interrupted

    • join

      public float join(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException
      Starts the Execution of the task and will await its completion with a timeout, returning the result.
      Parameter:
      timeout - of how long the thread should wait the task to be completed
      unit - of the desired waiting time.
      Gibt zurück:
      the result of the provided task
      Löst aus:
      InterruptedException - if the caller thread was interrupted
      ExecutionException - if the task threw a exception
      TimeoutException - if the timeout was reached before the task was finished