Major update

- Added ability to "post" a return value to the Async object before completion
- Added ability to poll the return value of Async without awaiting completion
- Simplified SafeReflection "customEnum" method using Unsafe.
- Modified SafeReflection.<clinit> to support android

.idea/misc.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_5" default="false" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_5" default="false" project-jdk-name="1.8 (1)" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

src/com/tofvesson/async/Async.java

@@ -1,8 +1,6 @@
 package com.tofvesson.async;
 
-import java.lang.reflect.Constructor;
+import java.lang.reflect.*;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
 
 @SuppressWarnings({"WeakerAccess", "unused", "unchecked"})
 public class Async<T> {
@@ -17,6 +15,11 @@ public class Async<T> {
      */
     volatile T ret;
 
+    /**
+     * Whether or not a posted value can be overwritten.
+     */
+    volatile boolean ovw = true;
+
     /**
      * Status indicators.
      */
@@ -88,7 +91,8 @@ public class Async<T> {
             public void run(){
                 try {
                     new ThreadLocal<Async>().set(Async.this);
-                    ret = (T) method.invoke(o, params); // Invoke given method
+                    T ret = (T)method.invoke(o, params);// Invoke given method
+                    if(ovw) Async.this.ret = ret;       // Checks if a sticky value already has been posted
                     complete = true;                    // Notify all threads who are checking
                 } catch (Throwable t1) {                // Prepare for failure
                     if(!failed) {                       // Checks if task was canceled
@@ -133,7 +137,8 @@ public class Async<T> {
             public void run(){
                 new ThreadLocal<Async>().set(Async.this);
                 try {
-                    ret = c.newInstance(params);    // Create a new instance: invoke "<init>" method
+                    T ret = c.newInstance(params);  // Create a new instance: invoke "<init>" method
+                    if(ovw) Async.this.ret = ret;   // Checks if a sticky value already has been posted
                     complete = true;                // Notify all threads that async is finished
                 } catch (Throwable t1) {            // Handle crash
                     if(!failed) {                   // Ensure that crash wasn't called by cancel()
@@ -177,11 +182,12 @@ public class Async<T> {
      */
     public boolean isAlive(){ return task.isAlive(); } // Check if thread is still alive which directly determines if process is alive since Async is a wrapper of Thread
 
+
     /**
      * Get async instance pertaining to current thread.
      * @return Async owning current thread or null if thread isn't Async.
      */
-    public static Async current(){
+    public static <T> Async<T> current(){
         try{
             Object holder;
             Field f = Thread.class.getDeclaredField("threadLocals");
@@ -196,7 +202,7 @@ public class Async<T> {
                         f.setAccessible(true);
                         containsData = true;
                     }
-                    if((holder=f.get(o)) instanceof Async) return (Async) holder;
+                    if((holder=f.get(o)) instanceof Async) return (Async<T>) holder;
                 }
         }catch(Exception e){}
         return null;
@@ -222,6 +228,34 @@ public class Async<T> {
         }
     }
 
+    /**
+     * Post a return value to Async object.
+     * Meant to be used from inside an instance of Async as a way to prematurely provide a return value without stopping said async process.
+     * Posting a value does not inform the Async object that it has completed operations.
+     * @param value Value to post.
+     * @param allowOverwrite If the return type of the async process should be overwritten when said process is completed. Calling postReturn overrides this.
+     */
+    public void postReturn(T value, boolean allowOverwrite){
+        ret = value;
+        ovw = allowOverwrite;
+    }
+
+    /**
+     * Post a return value to Async object.
+     * Meant to be used from inside an instance of Async as a way to prematurely provide a return value without stopping said async process.
+     * Posting a value does not inform the Async object that it has completed operations.
+     * @param value Value to post.
+     */
+    public void postReturn(T value){ postReturn(value, false); }
+
+    /**
+     * Get return type posted by object.
+     * Meant to be used after a value has been posted, not when it has been returned.
+     */
+    public T getReturn(){
+        return ret;
+    }
+
     /**
      * Checks for dangerous calls to Async methods such as awaiting oneself (which would cause a freeze in that thread).
      */

src/com/tofvesson/reflection/SafeReflection.java

@@ -3,60 +3,54 @@ package com.tofvesson.reflection;
 import sun.misc.Unsafe;
 
 import java.lang.reflect.*;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
 
 /**
  * Safe tools to help simplify code when dealing with reflection.
  */
-@SuppressWarnings("ALL")
 public final class SafeReflection {
 
 
     private static final Unsafe unsafe;
-    private static final Method newInstance, aConAccess, gFieldAccess, fieldAccess;
+    private static final Method newInstance, aConAccess;
-    private static final Field ro;
     private static final String version;
     private static final long override;
+    private static final boolean hasAConAccess;
 
     static{
         Unsafe u = null;
-        Method m = null, m1 = null, m2 = null, m3 = null;
+        Method m = null, m1 = null;
-        Field f = null;
+        Field f;
         long l = 0;
-        String ver = "sun.reflect";
+        String ver = "";
+        boolean b = true;
         //Get package based on java version (Java 9+ use "jdk.internal.reflect" while "sun.reflect" is used by earlier versions)
         try{
-            Class.forName("sun.reflect.DelegatingConstructorAccessorImpl");
+            ClassLoader.getSystemClassLoader().loadClass("jdk.internal.reflect.DelegatingConstructorAccessorImpl");
         }catch(Throwable ignored){
-            ver="jdk.internal.reflect"; // If class can't be found in sun.reflect; we know that user is running Java 9+
+            ver="sun.reflect"; // If class can't be found in sun.reflect; we know that user is running Java 9+
         }
         try{
-            Class<?> c;
             f = Unsafe.class.getDeclaredField("theUnsafe");
             f.setAccessible(true);
             u = (Unsafe) f.get(null);
-            m = Class.forName(ver+".DelegatingConstructorAccessorImpl").getDeclaredMethod("newInstance", Object[].class);
+            l=u.objectFieldOffset(AccessibleObject.class.getDeclaredField("override"));
-            u.putBoolean(m, l=u.objectFieldOffset(AccessibleObject.class.getDeclaredField("override")), true);
+            try {
-            m1 = Constructor.class.getDeclaredMethod("acquireConstructorAccessor");
+                m1 = Constructor.class.getDeclaredMethod("acquireConstructorAccessor");
-            m1.setAccessible(true);
+                m1.setAccessible(true);
-            m2 = Field.class.getDeclaredMethod("getFieldAccessor", Object.class);
+                m = Class.forName(ver + ".DelegatingConstructorAccessorImpl").getDeclaredMethod("newInstance", Object[].class);
-            m2.setAccessible(true);
+                u.putBoolean(m, l, true);
-            m3 = (c=Class.forName(ver+".UnsafeQualifiedStaticObjectFieldAccessorImpl")).getDeclaredMethod("set", Object.class, Object.class);
+            }catch(Exception e){
-            u.putBoolean(m3, l, true);
+                b = false;
-            f = c.getSuperclass().getDeclaredField("isReadOnly");
+            }
             u.putBoolean(f, l, true);
         }catch(Exception ignored){ ignored.printStackTrace(); }                                                                                     // Exception is never thrown
         unsafe = u;
         newInstance = m;
         aConAccess = m1;
-        gFieldAccess = m2;
-        fieldAccess = m3;
-        ro = f;
         override = l;
         version = ver;
+        hasAConAccess = b;
     }
 
     /**
@@ -239,14 +233,12 @@ public final class SafeReflection {
             paramList[0] = String.class; // Name
             paramList[1] = int.class; // Ordinal
             int iterator = paramList.length;
-            for(Class c : def.params.values()) paramList[--iterator] = c; // Shit's fucking reversed
+            for(Class c : def.params.values()) paramList[--iterator] = c; // The stuff is reversed
 
             // Get enum constructor (inherited from Enum.class)
-            Constructor c = clazz.getDeclaredConstructor(paramList);
+            Constructor<T> c = clazz.getDeclaredConstructor(paramList);
-            unsafe.putBoolean(c, override, true);
+            if(hasAConAccess) unsafe.putBoolean(c, override, true);
-
+            else c.setAccessible(true);
-            // Get constructor accessor since Constructor.newInstance throws an exception because Enums are "immutable"
-            Object access = aConAccess.invoke(c);
 
             Object[] parameters = new Object[def.params.size()+2];
             parameters[0] = name;
@@ -255,7 +247,8 @@ public final class SafeReflection {
             for(Object o : def.params.keySet()) parameters[--iterator] = o;
 
             // Create new instance of enum with valid name and ordinal
-            u = (T) newInstance.invoke(access, (Object) parameters);
+            if(hasAConAccess) u = (T) newInstance.invoke(aConAccess.invoke(c), (Object) parameters);
+            else u = c.newInstance(parameters);
 
             // Get the final name field from Enum.class and make it temporarily modifiable
             Field f = Enum.class.getDeclaredField("name");
@@ -266,26 +259,14 @@ public final class SafeReflection {
 
             if(!addToValuesArray) return u; // Stops here if
 
-            // Get the current values field from Enum (a bitch to modify)
+            // Get the current values field from Enum (a female dog to modify)
             f = clazz.getDeclaredField("$VALUES");
             f.setAccessible(true);
             T[] $VALUES = (T[]) Array.newInstance(clazz, values.length+1);
             System.arraycopy(values, 0, $VALUES, 0, values.length); // Copy over values from old array
             $VALUES[values.length] = u; // Add out custom enum to our local array
 
-            // Start doing magic by getting an instance of sun.reflect.UnsafeQualifiedStaticObjectFieldAccessorImpl.class
+            unsafe.putObject(clazz, unsafe.staticFieldOffset(f), $VALUES);
-            // Class is package-local so we can't reference it by anything other than Object
-            Object UQSOFAImpl = gFieldAccess.invoke(f, u);
-
-            // Get "isReadOnly" flag ($VALUES is always read-only even if Field.setAccessible(true) is called)
-            // Flag is located in superclass (sun.reflect.UnsafeQualifiedStaticFieldAccessorImpl.class (also fucking package-local))
-            // Set flag to 'false' to allow for modification against Java's will
-            ro.setBoolean(UQSOFAImpl, false);
-
-            // Invoke set() method on UnsafeQualifiedStaticObjectFieldAccessorImpl object which sets the
-            // private field $VALUES to our new array
-            System.out.println(UQSOFAImpl.getClass());
-            fieldAccess.invoke(UQSOFAImpl, f, $VALUES);
         } catch (Exception wrongParams) { throw new RuntimeException(wrongParams); }
         return u;
     }