io.rouz.task.dsl.TaskBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of flo-workflow Show documentation
The newest version!
package io.rouz.task.dsl;

import java.io.Serializable;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

import io.rouz.task.Task;
import io.rouz.task.TaskContext;
import io.rouz.task.TaskContext.Value;

/**
 * Types for the fluent task setup API
 *
 * The entry point for this api is {@link Task#named(String, Object...)}}.
 *
 * Note, the inner types should never have to explicitly be mentioned or imported. The API is
 * supposed to be used through fluent calls that eventually lead to a {@link Task} instance.
 */
public interface TaskBuilder {

  Task process(F0 code);
  Task processWithContext(F1> code);
   TaskBuilder1 in(F0> task);
   TaskBuilder1, Z> ins(F0>> tasks);

  TaskBuilderC0 curried();
  TaskBuilderCV0 curriedWithContext();

  interface TaskBuilderC0 {
     TaskBuilderC in(F0> task);
     TaskBuilderC, Z, Z> ins(F0>> tasks);
  }

  interface TaskBuilderCV0 {
     TaskBuilderCV, Z> in(F0> task);
     TaskBuilderCV, Value, Z> ins(F0>> tasks);
  }

  interface TaskBuilderC {
    Task process(F1 code);
     TaskBuilderC, Z> in(F0> task);
     TaskBuilderC, F1, Z> ins(F0>> tasks);
  }

  interface TaskBuilderCV {
    Task process(F1> code);
     TaskBuilderCV, Z> in(F0> task);
     TaskBuilderCV, F1, Z> ins(F0>> tasks);
  }

  interface TaskBuilder1 {
    Task process(F1 code);
    Task processWithContext(F2> code);
     TaskBuilder2 in(F0> task);
     TaskBuilder2, Z> ins(F0>> tasks);
  }

  interface TaskBuilder2 {
    Task process(F2 code);
    Task processWithContext(F3> code);
     TaskBuilder3 in(F0> task);
     TaskBuilder3, Z> ins(F0>> tasks);
  }

  interface TaskBuilder3 {
    Task process(F3 code);
    Task processWithContext(F4> code);
  }

  @FunctionalInterface
  interface F0 extends Supplier, Serializable {
    R get();
  }

  @FunctionalInterface
  interface F1 extends Function, Serializable {
    R apply(A a);
  }

  @FunctionalInterface
  interface F2 extends BiFunction, Serializable {
    R apply(A a, B b);
  }

  @FunctionalInterface
  interface F3 extends Serializable {
    R apply(A a, B b, C c);
  }

  @FunctionalInterface
  interface F4 extends Serializable {
    R apply(A a, B b, C c, D d);
  }
}