Major patch

Fixed major bug in Eco Async class causing infinite loop when await() is called
Added multiple variants of EcoAsync constructor to simplify and untangle code of future developers
EcoAsync is now generic and so is it's return type!
Added comments to every constructor so as not to confuse developers

src/com/tofvesson/async/EcoAsync$1.java

@@ -25,6 +25,7 @@ class EcoAsync$1 implements Runnable{
         synchronized (this) {
             try {
                 this$0.ret = val$method.invoke(val$o, val$params);
+                this$0.complete = true;
             } catch (Throwable t1) {
                 if(!this$0.failed)
                 {

src/com/tofvesson/async/EcoAsync.java

@@ -6,7 +6,12 @@ import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
-public class EcoAsync extends Async {
+/**
+ * Economic asynchronous calls. After a result has been returned to the caller, the object resets and is ready to dispatch another operation.
+ * @param <T> Return type.
+ */
+@SuppressWarnings("unused")
+public class EcoAsync<T> extends Async<T> {
 
     private static final Field threadTarget, runnableObjToCall, runnableMethod, runnableParams;
     private Thread previousThread;
@@ -49,6 +54,70 @@ public class EcoAsync extends Async {
         if(runOnConstruction) try{ task.start(); }catch(Exception ignored){}
     }
 
+    /**
+     * Initiates an economic, asynchronous call to the supplied method on the supplied object or if runOnConstruction == false, just prepares for it.
+     * @param runOnConstruction Whether or not to dispatch asynchronous call after construction.
+     * @param o Object to call method on.
+     * @param m Method to invoke.
+     */
+    public EcoAsync(boolean runOnConstruction, Object o, Method m){ this(runOnConstruction, o, m, (Object[]) null); }
+
+    /**
+     * Initiates an economic, asynchronous call to the supplied method on the supplied object.
+     * @param params Parameters to supply to method.
+     * @param o Object to call method on.
+     * @param m Method to invoke.
+     */
+    public EcoAsync(Object o, Method m, Object... params){ this(true, o, m, params); }
+
+    /**
+     * Prepares to invoke the passed static method with given parameters and invokes if runOnConstruction == true;
+     * @param runOnConstruction Whether or not to invoke the given method after EcoAsync object is constructed.
+     * @param m Static method to invoke.
+     * @param params Parameters to pass to method.
+     */
+    public EcoAsync(boolean runOnConstruction, Method m, Object... params){ this(runOnConstruction, null, m, params); }
+
+    /**
+     * Invokes the passed static method with given parameters.
+     * @param m Static method to invoke.
+     * @param params Parameters to pass to method.
+     */
+    public EcoAsync(Method m, Object... params){ this(true, null, m, params); }
+
+    /**
+     * Invokes the passed static method if runOnConstruction == true, otherwise it just prepares to invoke.
+     * @param m Static method to invoke.
+     * @param runOnConstruction Whether or not to invoke the given method after EcoAsync object is constructed.
+     */
+    public EcoAsync(boolean runOnConstruction, Method m){ this(runOnConstruction, null, m, (Object[]) null); }
+
+    /**
+     * Invokes the passed static method asynchronously.
+     * @param m Static method to invoke.
+     */
+    public EcoAsync(Method m){ this(true, null, m, (Object[]) null); }
+
+    /**
+     * Asynchronously constructs a new object with the given parameters.
+     * @param c Constructor ti call.
+     * @param params Parameters to pass.
+     */
+    public EcoAsync(Constructor<T> c, Object... params){ this(true, c, params); }
+
+    /**
+     * Prepares for asynchronous invocation of given constructor.
+     * @param runOnConstruction Whether or not to construct object after EcoAsync object is constructed.
+     * @param c Constructor to invoke.
+     */
+    public EcoAsync(boolean runOnConstruction, Constructor<T> c){ this(runOnConstruction, c, (Object[]) null); }
+
+    /**
+     * Asynchronously constructs a new object using the given constructor.
+     * @param c Constructor to call.
+     */
+    public EcoAsync(Constructor<T> c){ this(true, c); }
+
     /**
      * Initiates an economic version of async task that constructs an object using the supplied constructor.
      * Note that though this is optimized for larger tasks id est tasks that take more than 5 milliseconds to process, this class was designed with
@@ -60,18 +129,19 @@ public class EcoAsync extends Async {
      * @param c Constructor to use when constructing.
      * @param params Parameter to use when constructing.
      */
-    public EcoAsync(boolean runOnConstruction, Constructor c, Object... params){
+    public EcoAsync(boolean runOnConstruction, Constructor<T> c, Object... params){
         super();
         c.setAccessible(true);
         try {
-            Method m = EcoAsync.class.getMethod("constructObject", Constructor.class, Object[].class);
+            Method m = EcoAsync.class.getDeclaredMethod("constructObject", Constructor.class, Object[].class);
+            m.setAccessible(true);
             newThread(null, m, c, params);
-        } catch (NoSuchMethodException e) { }
+        } catch (NoSuchMethodException e) { e.printStackTrace(); }
         if(runOnConstruction) try{ task.start(); }catch(Exception ignored){}
     }
 
     @Override
-    public Object await() {
+    public T await() {
         //noinspection StatementWithEmptyBody
         while(!failed && !complete);
         if(ret==null && t!=null){
@@ -79,6 +149,7 @@ public class EcoAsync extends Async {
             super.t = null; // Added for re-usability
             throw new RuntimeException(t);
         }
+        complete = false;
         return ret;
     }
 
@@ -91,6 +162,7 @@ public class EcoAsync extends Async {
     public void cancel() {
         previousThread = task;// Store a reference to the previous thread
         super.cancel();
+        //noinspection StatementWithEmptyBody
         while(previousThread.isAlive()) ;
         complete = false;
         failed = false;