Updated literally everything, improved TaskManager which now has dynamic side-task growing & shrinking to deal with dynamic work amounts with configuration (see README.md)

added MANY methods, added 2 new classes

added more flexibility when trying to run async vs parallel tasks

added more flexibility to events

java docced ALL publicly available methods so it should be easier to read.

Fixed up README.md a little bit, there is some risidule that i need to finish up but that wont take long, ill do that tomorrow whenever i have time, the only issue that isn't solved yet is the fact that some of the method definitions / documentations are not there.

Author: McCapy

README.md

@@ -3,6 +3,7 @@ An API that allows you to execute, parallelize, and async code dynamically, and
 
 ## WARNING**
 > If you're seeing this message the README.md isn't entirely up-to-date, it will be up-to-date shortly.
+> The main things un-updated are the definitions for methods, however the java docs **ARE** up to date, reference them if you have any question.
 
 > [!NOTE]
 > > This is a shadable project.
@@ -26,6 +27,18 @@ This is how to add this project as either a dependency, or just using it outrigh
 > This will direct you to the jitpack page, this will instruct you on how to apply 
 > this in your pom, or pom equivalent, allowing you to use the API itself. 
 > I **HIGHLY** Recommend using the latest commit. If you must, avoid **EXPERIMENTAL** code.
+## Initialization
+This is even more important than the following, as if you don't enable it; it simply won't work!
+
+```java
+import org.DynamicThread.TaskManager;
+
+void main() {
+    TaskManager.enable();
+    TaskManager.enable(Settings... args);
+    /// Reference the java-doc if you're confused about the overload of .enable(), which has arguments.
+}
+```
 
 ## Deinitialization
 This is a very important step if you're using this for any project with processes that effect persistent data.
@@ -84,9 +97,14 @@ While there are sparse features, there is a large sum of methods you can use to
 > For this method there are actually quite a few overloads, they can be seen below.
 > 
 > ```java 
-> AsyncTask.of(Runnable... runnables);
-> AsyncTask.of(Supplier<?> supplier, Runnable... runnables);
-> AsyncTask.of(Supplier<?> supplier);
+> import org.DynamicThread.Parallel; 
+> 
+> Async.of();
+> Async.of(Supplier<?> supplier);
+> AsyncTask.of(Supplier<?> supplier, Async<?> async);
+> AsyncTask.of(Supplier<?> supplier, Parallel<?> parallel);
+> AsyncTask.of(Parallel<?> parallel);
+> AsyncTask.of(Async async);
 > ```
 > For each of these respectively they all have different functionalities.
 > 1. The first, this simply executes all supplied tasks in parallel, and then calls all hooked tasks (see **Hooking Tasks**)
@@ -98,14 +116,16 @@ While there are sparse features, there is a large sum of methods you can use to
 > This specific tab is going to have A **LOT** of methods, and even more overloads.
 > Each method has slightly different function then its parent method.
 > ```java
-> AsyncTask.after(Runnable... runnables);
-> AsyncTask.after(Consumer<?>... consumers);
-> AsyncTask.after(Function<?,?> function, Consumer<?>... consumers);
+> import org.DynamicThread.Parallel;
+> 
+> AsyncTask.after(Async<?> async);
+> AsyncTask.after(Parallel<?> parallel);
 > AsyncTask.after(Supplier<?> supplier);
-> AsyncTask.after(Supplier<?> supplier, Runnable... runnables);
-> AsyncTask.after(Supplier<?> supplier, Consumer<?>... consumers);
-> AsyncTask.after(Function<?,?> function,Runnable... runnables);
+> AsyncTask.after(Supplier<?> supplier, Async<?> async);
+> AsyncTask.after(Supplier<?> supplier, Parallel<?> parallel);
 > AsyncTask.after(Function<?,?> function);
+> AsyncTask.after(Function<?,?> function, Async<?> async);
+> AsyncTask.after(Function<?,?> function, Parallel<?> parallel);
 > ```
 > Naturally these will all have to be explained,
 > 1. The first, will run all the submitted tasks in parallel after the previous task is completed
@@ -175,9 +195,6 @@ While there are sparse features, there is a large sum of methods you can use to
 > AsyncTask.cancel();
 > AsyncTask.join();
 > AsyncTask.join(long time);
-> AsyncTask.collect();
-> AsyncTask.collet(long time);
-> AsyncTask.cancel(long time);
 > ```
 > 1. The first, returns true if the task is completed.
 > 2. The second, returns true if the task is cancelled.
@@ -192,60 +209,41 @@ While there are sparse features, there is a large sum of methods you can use to
 
 ## Examples
 > ```java
+> import org.DynamicThread.AsyncTask;
+> import org.DynamicThread.TaskManager;
+> 
+> static int fib(int n) {
+>   if (n <= 1) return n;
+>   return fib(n - 1) + fib(n - 2);
+> }
+> 
+> @SuppressWarnings("CodeBlock2Expr")
 > void main() throws InterruptedException {
->   AsyncTask<String> task = AsyncTask.of(
->       () -> 10,
->       () -> System.out.println("Task 1"), // shows that the tasks are parallelized
->       () -> System.out.println("Task 2"),
->       () -> System.out.println("Task 3"),
->       () -> System.out.println("Task 4"),
->       () -> System.out.println("Task 5")
->   ) // creates a returnable of type integer
-> 
->   .onStart(() -> {
->       System.out.println("Started main task");
->   }) // shows when the task starts
-> 
->   .after((item) -> {
->       return item + 3;
->   }) // returns 13 (doesn't change return type)
-> 
->   .after((item) -> {
->       System.out.println("Resulted in " + item);
->       System.out.println("Changed type to a runnable");
->   }) // converts to runnable
-> 
->   .after(() -> {
->       System.out.println("Changed type back to returnable, its type is String");
->       return "capybara";
->   }) // converts to returnable of type string
-> 
->   .onComplete((item) -> {
->       System.out.println("Entire task completed with result " + item);
->   }) // calls after the entire task is completed
->   .start();
-> 
->   System.out.println("Sleep Started");
->   Thread.sleep(1500); // proves it's actually asynced
->   System.out.println("Sleep Ended");
->   System.out.println("Collecting results of the task back into main thread with result: "  + task.collect());
+>   Thread.sleep(2000); // jvm warmup
+>   final long time = System.currentTimeMillis();
+>   TaskManager.enable();
+>   System.out.println("=== Test Started ===");
+>   for (int i = 0; i < 5_000; i++) {
+>       AsyncTask.of(() -> fib(20))
+>           .onComplete((item) -> {
+>           System.out.println("Result of " + item + " Process took, " + (time - System.currentTimeMillis()) + "ms");
+>       })
+>       .start();
+>   }
+>   System.out.println("=== Sleeping to allow async work ===");
+>   Thread.sleep(5000);
+>   System.out.println("=== Test Complete ===");
+>   TaskManager.disable();
 > }
+> 
 > ```
 > ## Console Output
 > The console output can be seen below, this naturally proves all I've depicted in the code.
 > ```.shell
-> Started main task
-> Sleep Started
-> Task 1
-> Task 5
-> Task 3
-> Task 2
-> Task 4
-> Resulted in 13
-> Changed type to a runnable
-> Changed type back to returnable, its type is String
-> Entire task completed with result capybara
-> Sleep Ended
-> Collecting results of the task back into main thread with result: capybara
+> Result of 6765 Process took, -16ms
+> ....
+> (there was alot of output)
+> ....
+> Result of 6765 Process took, -327ms
 > ```
-
+> It is not to be ignored that this is relative to an epoch, so over 5000 fib(20) operations, it executed in under a single second.

src/main/java/org/DynamicThread/AsyncTask.java

@@ -43,7 +43,7 @@ private static final class Context {
         volatile boolean timedOut;
     }
 
-    private <N> AsyncTask<N> afterSync(AsyncTask<N> next) {
+    <N> AsyncTask<N> afterSync(AsyncTask<N> next) {
         synchronized (this) {
             if (completed) {
                 if (!context.cancelled && !context.timedOut) next.startInternal();
@@ -174,7 +174,7 @@ public <N> AsyncTask<N> after(Supplier<N> supplier) {
     }
 
     /**
-     * @param supplier Transforms the asynctask to a different return type,
+     * @param supplier Transforms the async-task to a different return type,
      * @param async The task to be executed during the tasks main execution (supplier)
      * @param <N> The tasks type
      * @return The task as a result of the call to a method