From 0f8067a628777291a67f94efb7eec8373060177b Mon Sep 17 00:00:00 2001
From: FuckYou <gabriel.tofvesson@gmail.com>
Date: Thu, 24 Nov 2016 19:17:47 +0400
Subject: [PATCH] Major update - Added support for getting current Async
 instance from Thread (thx Reflection <3 <3 <3) - Added security checks to
 await() to prevent thread freeze from calling await() from async thread -
 Added standard for all classes extending Async to follow

---
 src/com/tofvesson/async/Async.java      | 34 +++++++++++++++++++++++--
 src/com/tofvesson/async/EcoAsync$1.java |  1 +
 src/com/tofvesson/async/EcoAsync.java   |  1 +
 3 files changed, 34 insertions(+), 2 deletions(-)

diff --git a/src/com/tofvesson/async/Async.java b/src/com/tofvesson/async/Async.java
index d457cf9..36a8c07 100644
--- a/src/com/tofvesson/async/Async.java
+++ b/src/com/tofvesson/async/Async.java
@@ -1,6 +1,7 @@
 package com.tofvesson.async;
 
 import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 
 @SuppressWarnings({"WeakerAccess", "unused", "unchecked"})
@@ -37,6 +38,7 @@ public class Async<T> {
         method.setAccessible(true); // Ensure that no crash occurs
         task = new Thread(()-> { // Create a new thread
             try {
+                new ThreadLocal<Async>().set(Async.this);
                 ret = (T) method.invoke(o, params); // Invoke given method
                 complete = true;                    // Notify all threads who are checking
             } catch (Throwable t1) {                // Prepare for failure
@@ -102,13 +104,14 @@ public class Async<T> {
     /**
      * WARNING: Package-scoped because it should only be used when overriding standard construction. Should not bw used haphazardly!
      */
-    Async() {task = null;}
+    Async() { task = null; }
 
     /**
      * 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 T await(){
+        checkDangerousThreadedAction();
         //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
@@ -127,9 +130,32 @@ public class Async<T> {
      * @return Async owning current thread or null if thread isn't Async.
      */
     public static Async current(){
-        return new ThreadLocal<Async>().get();
+        try{
+            Object holder;
+            Field f = Thread.class.getDeclaredField("threadLocals");
+            f.setAccessible(true);
+            f = (holder=f.get(Thread.currentThread())).getClass().getDeclaredField("table");
+            f.setAccessible(true);
+            boolean containsData = false;
+            for(Object o : (Object[]) f.get(holder))
+                if(o != null) {
+                    if (!containsData) {
+                        f = o.getClass().getDeclaredField("value");
+                        f.setAccessible(true);
+                        containsData = true;
+                    }
+                    if((holder=f.get(o)) instanceof Async) return (Async) holder;
+                }
+        }catch(Exception e){}
+        return null;
     }
 
+    /**
+     * Method that must be called by the async thread of any class that
+     * extends this one if they want to support {@link #current()} for their class.
+     */
+    protected void setLocal(){ new ThreadLocal<Async>().set(this); }
+
     /**
      * Cancels async operation if it's still alive.
      */
@@ -143,4 +169,8 @@ public class Async<T> {
             task.stop();    // Force-stop thread
         }
     }
+
+    protected void checkDangerousThreadedAction(){
+        if(this.equals(current())) throw new RuntimeException("Calling dangerous method from inside thread is forbidden!");
+    }
 }
diff --git a/src/com/tofvesson/async/EcoAsync$1.java b/src/com/tofvesson/async/EcoAsync$1.java
index 08ad492..5ea112e 100644
--- a/src/com/tofvesson/async/EcoAsync$1.java
+++ b/src/com/tofvesson/async/EcoAsync$1.java
@@ -24,6 +24,7 @@ class EcoAsync$1 implements Runnable{
     public void run() {
         synchronized (this) {
             try {
+                this$0.setLocal();
                 this$0.ret = val$method.invoke(val$o, val$params);
                 this$0.complete = true;
             } catch (Throwable t1) {
diff --git a/src/com/tofvesson/async/EcoAsync.java b/src/com/tofvesson/async/EcoAsync.java
index 45df92d..ef46b87 100644
--- a/src/com/tofvesson/async/EcoAsync.java
+++ b/src/com/tofvesson/async/EcoAsync.java
@@ -142,6 +142,7 @@ public class EcoAsync<T> extends Async<T> {
 
     @Override
     public T await() {
+        checkDangerousThreadedAction();
         //noinspection StatementWithEmptyBody
         while(!failed && !complete);
         if(ret==null && t!=null){