diff --git a/.idea/misc.xml b/.idea/misc.xml index a83a35c..05bc84b 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,6 +1,6 @@ - + \ No newline at end of file diff --git a/src/com/tofvesson/async/Async.java b/src/com/tofvesson/async/Async.java index b8af361..1a435b3 100644 --- a/src/com/tofvesson/async/Async.java +++ b/src/com/tofvesson/async/Async.java @@ -1,8 +1,6 @@ package com.tofvesson.async; -import java.lang.reflect.Constructor; -import java.lang.reflect.Field; -import java.lang.reflect.Method; +import java.lang.reflect.*; @SuppressWarnings({"WeakerAccess", "unused", "unchecked"}) public class Async { @@ -17,6 +15,11 @@ public class Async { */ 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 { public void run(){ try { new ThreadLocal().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 { public void run(){ new ThreadLocal().set(Async.this); try { - ret = c.newInstance(params); // Create a new instance: invoke "" method + T ret = c.newInstance(params); // Create a new instance: invoke "" 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 { */ 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 Async current(){ try{ Object holder; Field f = Thread.class.getDeclaredField("threadLocals"); @@ -196,7 +202,7 @@ public class Async { f.setAccessible(true); containsData = true; } - if((holder=f.get(o)) instanceof Async) return (Async) holder; + if((holder=f.get(o)) instanceof Async) return (Async) holder; } }catch(Exception e){} return null; @@ -222,6 +228,34 @@ public class Async { } } + /** + * 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). */ diff --git a/src/com/tofvesson/reflection/SafeReflection.java b/src/com/tofvesson/reflection/SafeReflection.java index f3b3439..33f6817 100644 --- a/src/com/tofvesson/reflection/SafeReflection.java +++ b/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.Collections; -import java.util.HashMap; -import java.util.Iterator; +import java.util.*; /** * 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 Field ro; + private static final Method newInstance, aConAccess; 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; - Field f = null; + Method m = null, m1 = 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); - u.putBoolean(m, l=u.objectFieldOffset(AccessibleObject.class.getDeclaredField("override")), true); - m1 = Constructor.class.getDeclaredMethod("acquireConstructorAccessor"); - m1.setAccessible(true); - m2 = Field.class.getDeclaredMethod("getFieldAccessor", Object.class); - m2.setAccessible(true); - m3 = (c=Class.forName(ver+".UnsafeQualifiedStaticObjectFieldAccessorImpl")).getDeclaredMethod("set", Object.class, Object.class); - u.putBoolean(m3, l, true); - f = c.getSuperclass().getDeclaredField("isReadOnly"); + l=u.objectFieldOffset(AccessibleObject.class.getDeclaredField("override")); + try { + m1 = Constructor.class.getDeclaredMethod("acquireConstructorAccessor"); + m1.setAccessible(true); + m = Class.forName(ver + ".DelegatingConstructorAccessorImpl").getDeclaredMethod("newInstance", Object[].class); + u.putBoolean(m, l, true); + }catch(Exception e){ + b = false; + } 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); - unsafe.putBoolean(c, override, true); - - // Get constructor accessor since Constructor.newInstance throws an exception because Enums are "immutable" - Object access = aConAccess.invoke(c); + Constructor c = clazz.getDeclaredConstructor(paramList); + if(hasAConAccess) unsafe.putBoolean(c, override, true); + else c.setAccessible(true); 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 - // 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); + unsafe.putObject(clazz, unsafe.staticFieldOffset(f), $VALUES); } catch (Exception wrongParams) { throw new RuntimeException(wrongParams); } return u; }