From 9c014689a199e1ea0c021dc05784de7a532d65bc Mon Sep 17 00:00:00 2001
From: Gabriel Tofvesson <gabriel.tofvesson@hotmail.com>
Date: Thu, 3 Nov 2016 22:45:01 +0100
Subject: [PATCH] Major update Fixed major bug in Async when constructing a new
 object causing an infinite loop Added an Async constructor for constructing a
 new object without parameters Async is now generic and return type of await()
 is also generic!

---
 src/com/tofvesson/async/Async.java | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/src/com/tofvesson/async/Async.java b/src/com/tofvesson/async/Async.java
index 7e1c299..5cc3ac5 100644
--- a/src/com/tofvesson/async/Async.java
+++ b/src/com/tofvesson/async/Async.java
@@ -3,11 +3,11 @@ package com.tofvesson.async;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
 
-@SuppressWarnings({"WeakerAccess", "unused"})
-public class Async {
+@SuppressWarnings({"WeakerAccess", "unused", "unchecked"})
+public class Async<T> {
 
     Thread task;
-    volatile Object ret; // Assigned using native method
+    volatile T ret; // Assigned using native method
     volatile boolean complete = false, failed = false; // Used by anonymous class, therefore not private
     volatile Throwable t;
 
@@ -21,7 +21,7 @@ public class Async {
     public Async(final Object o, final Method method, final Object... params){
         method.setAccessible(true);
         task = new Thread(()-> {
-            synchronized (this) { try { ret = method.invoke(o, params); complete = true; } catch (Throwable t1) { if(!failed) { failed = true; t=t1; } } }
+            synchronized (this) { try { ret = (T) method.invoke(o, params); complete = true; } catch (Throwable t1) { if(!failed) { failed = true; t=t1; } } }
         });
         task.setDaemon(true);
         task.start();
@@ -52,27 +52,28 @@ public class Async {
      * @param c Constructor to use when instantiating object.
      * @param params Parameters to use when instantiaing object.
      */
-    public Async(final Constructor c, final Object... params){
+    public Async(final Constructor<T> c, final Object... params){
         c.setAccessible(true);
-        //Lambdas are compiled into more methods than anonymous class and don't decrease overhead
-        //noinspection Convert2Lambda
-        task = new Thread(new Runnable() {
-            @Override
-            public void run() {
-                synchronized (this) { try { ret = c.newInstance(params); } catch (Throwable t1) { if(!failed) { failed = true; t=t1; } } }
-            }
+        task = new Thread(() -> {
+            synchronized (this) { try { ret = c.newInstance(params); complete = true; } catch (Throwable t1) { if(!failed) { failed = true; t=t1; } } }
         });
         task.setDaemon(true);
         task.start();
     }
 
+    /**
+     * Dispatch an asynchronous construction of the object corresponding to the passed constructor with no parameters.
+     * @param c Constructor to call.
+     */
+    public Async(Constructor<T> c){ this(c, (Object[]) null); }
+
     Async() {task = null;} // Only package-scoped because it should only be used when overriding standard construction
 
     /**
      * Await completion of async task. Blocks thread if task isn't complete.
      * @return Return value from async method call. Return is null if {@link #cancel()} is called before this method and async task wan't finished.
      */
-    public Object await(){
+    public T await(){
         //noinspection StatementWithEmptyBody
         while(!failed && !complete); // Check using variables rather than checking if worker thread is alive since method calls are more computationally expensive
         if(ret==null && t!=null) throw new RuntimeException(t); // Detect a unique error state, get error and throw in caller thread