Update README.txt

- Refactored package to match my site name
- Renamed "logging" package to "stream"
- Fixed various bugs
- Fixed issues with illegal reflective access
- Added proper throwable for when a dangerous threaded action happens in async
- Added more reflective tools
  - Added ability to auto-generate simple wrapper classes
  - Added tools for converting enums to a flag-like system
  - Added annotation scanning for a supplied classloader
- Properly renamed module to "libRefTools"

.idea/artifacts/libRefTools_jar.xml

@@ -2,7 +2,7 @@
   <artifact type="jar" name="libRefTools:jar">
     <output-path>$PROJECT_DIR$/out/artifacts/libRefTools_jar</output-path>
     <root id="archive" name="libRefTools.jar">
-      <element id="module-output" name="libGTools" />
+      <element id="module-output" name="libRefTools" />
       <element id="dir-copy" path="$PROJECT_DIR$/src" />
       <element id="file-copy" path="$PROJECT_DIR$/README.txt" />
       <element id="file-copy" path="$PROJECT_DIR$/COPYING.txt" />

.idea/libraries/asm_all_5_1.xml

@@ -1,13 +0,0 @@
-<component name="libraryTable">
-  <library name="asm-all-5.1">
-    <CLASSES>
-      <root url="jar://$USER_HOME$/Downloads/asm-5.1/lib/all/asm-all-5.1.jar!/" />
-    </CLASSES>
-    <JAVADOC>
-      <root url="file://$USER_HOME$/Downloads/asm-5.1/doc/javadoc/user" />
-    </JAVADOC>
-    <SOURCES>
-      <root url="jar://$USER_HOME$/Downloads/asm-5.1/src.zip!/" />
-    </SOURCES>
-  </library>
-</component>

.idea/misc.xml

@@ -1,19 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="EntryPointsManager">
-    <entry_points version="2.0" />
-  </component>
-  <component name="ProjectLevelVcsManager" settingsEditedManually="false">
-    <OptionsSetting value="true" id="Add" />
-    <OptionsSetting value="true" id="Remove" />
-    <OptionsSetting value="true" id="Checkout" />
-    <OptionsSetting value="true" id="Update" />
-    <OptionsSetting value="true" id="Status" />
-    <OptionsSetting value="true" id="Edit" />
-    <ConfirmationsSetting value="0" id="Add" />
-    <ConfirmationsSetting value="0" id="Remove" />
-  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" assert-keyword="true" jdk-15="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_5" default="false" project-jdk-name="9.0" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

.idea/modules.xml

@@ -2,7 +2,8 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/libGTools.iml" filepath="$PROJECT_DIR$/libGTools.iml" />
+      <module fileurl="file://$PROJECT_DIR$/Tests/Tests.iml" filepath="$PROJECT_DIR$/Tests/Tests.iml" />
+      <module fileurl="file://$PROJECT_DIR$/libRefTools.iml" filepath="$PROJECT_DIR$/libRefTools.iml" />
     </modules>
   </component>
 </project>

README.txt

@@ -1,20 +1,20 @@
-This file is part of Async.
+This file is part of libRefTools.
 
-libGTools is free software: you can redistribute it and/or modify
+libRefTools is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
-libGTools is distributed in the hope that it will be useful,
+libRefTools is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with libGTools.	If not, see <http://www.gnu.org/licenses/>.
+along with libRefTools.	If not, see <http://www.gnu.org/licenses/>.
 
-For further questions regarding your rights to libGTools, please contact Gabriel Tofvesson either by email at
+For further questions regarding your rights to libRefTools, please contact Gabriel Tofvesson either by email at
 gabriel.tofvesson@gmail.com
 or by mail at
 Bo Bergmans gata 9, 115 50, Stockholm, Sweden
-Contacting these addresses under false pretences and/or with malicious intent (for example sending more than two messages without response from the recipient) is not permissible.
+Contacting these addresses under false pretences and/or with malicious intent (for example sending more than two messages without response from the recipient) is not permissible.

Tests/Tests.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_9" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module" module-name="libRefTools" />
+  </component>
+</module>

Tests/src/RunTests.java

@@ -0,0 +1,89 @@
+import net.tofvesson.async.*;
+import net.tofvesson.collections.*;
+import net.tofvesson.reflection.*;
+
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+
+@SuppressWarnings("ALL")
+public class RunTests {
+    public static void main(String[] args){
+        asyncTest();
+        collectionsTest();
+        streamTest();
+        reflectionTest();
+    }
+
+    public static void asyncTest(){
+        final int batchSize = 24;
+        final Random random = ThreadLocalRandom.current();
+        final ProxiedValue<Boolean> success = new ProxiedValue<>(true);
+
+        System.out.print("Async test: ");
+        Async<Boolean> async = new Async<>(() -> Async.current().postReturn(true));
+
+        try{
+            if(async.await()!=Boolean.TRUE) throw new RuntimeException("Bad return value");
+            System.out.println("Passed");
+        }catch(Throwable t){
+            System.out.println("Failed ("+(t.getMessage().length()==0?"No reason given":t.getMessage())+")");
+        }
+
+        System.out.print("AsyncBatch test: ");
+        AsyncBatch<Integer> batch = new AsyncBatch<>(batchSize, i -> Async.current().postReturn(i));
+        Map<Integer, Integer> map = batch.awaitAll();
+        map.forEach((k, v) -> success.value |= k.equals(v));
+        System.out.println(success.value?"Passed":"Failed");
+
+        success.value = true;
+
+        System.out.print("EcoAsync test: ");
+        final String expected = "Hello Eco";
+        EcoAsync<String> eco = new EcoAsync<>(false, SafeReflection.getConstructor(String.class, String.class), expected);
+        try{
+            eco.await();
+            System.out.println("Failed (could await uninitialized async)");
+        }catch(Exception e){
+            eco.start();
+            success.value |= expected.equals(eco.await());
+
+            eco.start();
+            success.value |= expected.equals(eco.await());
+
+            System.out.println(success.value?"Passed":"Failed: (Awaited values did not match expected value)");
+        }
+
+        success.value = true;
+
+        System.out.print("Worker thread test: ");
+
+        WorkerThread thread = new WorkerThread(batchSize);
+        thread.start();
+        final Map<Long, Integer> check = new HashMap<>();
+        final Method invoke = SafeReflection.getFirstMethod(Supplier.class, "get");
+        for(int i = 0; i<batchSize; ++i){
+            final int expect = random.nextInt();
+            check.put(thread.push((Supplier<Integer>)()->expect, invoke), expect);
+        }
+        for(Long id : check.keySet()) success.value |= check.get(id).equals(thread.pop(id));
+
+        thread.stopGraceful();
+
+        System.out.println(success.value?"Passed":"Failed");
+    }
+
+    public static void collectionsTest(){
+        // TODO: Implement
+    }
+
+    public static void streamTest(){
+        // TODO: Implement
+    }
+
+    public static void reflectionTest(){
+        // TODO: Implement
+    }
+}

libRefTools.iml

@@ -7,6 +7,5 @@
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="asm-all-5.1" level="project" />
   </component>
 </module>

src/com/tofvesson/async/Async.java

@@ -1,137 +0,0 @@
-package com.tofvesson.async;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-
-@SuppressWarnings({"WeakerAccess", "unused", "unchecked"})
-public class Async<T> {
-
-    /**
-     * Thread running background task.
-     */
-    Thread task;
-
-    /**
-     * Return value/ constructed object.
-     */
-    volatile T ret;
-
-    /**
-     * Status indicators.
-     */
-    volatile boolean complete = false, failed = false; // Used by anonymous class, therefore not private
-
-    /**
-     * Exception to throw in case something goes wrong.
-     */
-    volatile Throwable t;
-
-    /**
-     * Initiates an async task that invokes the defined method. If object is null, the method must be static.
-     * Note that this is optimized for larger tasks id est tasks that take more than 5 milliseconds to process (preferably a minimum of 10 ms).
-     * @param o Object to invoke method on.
-     * @param method Method to invoke.
-     * @param params Required parameters.
-     */
-    public Async(final Object o, final Method method, final Object... params){
-        method.setAccessible(true); // Ensure that no crash occurs
-        task = new Thread(()-> { // Create a new thread
-            try {
-                ret = (T) method.invoke(o, params); // Invoke given method
-                complete = true;                    // Notify all threads who are checking
-            } catch (Throwable t1) {                // Prepare for failure
-                if(!failed) {                       // Checks if task was canceled
-                    failed = true;                  // Notifies all threads that task failed
-                    t=t1;                           // Makes error accessible to be thrown
-                }
-            }
-        });
-        task.setDaemon(true);                       // Ensure that process dies with program
-        task.start();                               // Start task
-    }
-
-    /**
-     * Dispatches an asynchronous call to supplied method on specified object with no parameters.
-     * @param o Object to call method on.
-     * @param m Method to call. Must be parameter-less!
-     */
-    public Async(Object o, Method m){ this(o, m, (Object[]) null); }
-
-    /**
-     * Dispatches an asynchronous call to supplied static method.
-     * @param m Static method to call.
-     * @param params Parameters to supply to method.
-     */
-    public Async(Method m, Object... params){ this(null, m, params); }
-
-    /**
-     * Dispatches an asynchronous, static, parameter-less method call.
-     * @param m Method to call.
-     */
-    public Async(Method m){ this(null, m, (Object[]) null); }
-
-    /**
-     * Create a new async task for instantiating an object.
-     * @param c Constructor to use when instantiating object.
-     * @param params Parameters to use when instantiaing object.
-     */
-    public Async(final Constructor<T> c, final Object... params){
-        c.setAccessible(true);                  // Ensure that constructor can be called
-        task = new Thread(() -> {               // Creates a new thread for asynchronous execution
-            try {
-                ret = c.newInstance(params);    // Create a new instance: invoke "<init>" method
-                complete = true;                // Notify all threads that async is finished
-            } catch (Throwable t1) {            // Handle crash
-                if(!failed) {                   // Ensure that crash wasn't called by cancel()
-                    failed = true;              // Notify all threads that error has been encountered
-                    t=t1;                       // Make throwable accessible to be thrown in caller thread
-                }
-            }
-        });
-        task.setDaemon(true);                   // Ensure that thread dies with program
-        task.start();                           // Start construction
-    }
-
-    /**
-     * 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); }
-
-    /**
-     * WARNING: Package-scoped because it should only be used when overriding standard construction. Should not bw used haphazardly!
-     */
-    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(){
-        //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
-        //noinspection unchecked
-        return ret; // Don't bother resetting values since this object is only intended to be recycled after value is gotten
-    }
-
-    /**
-     * Checks if async task is still running.
-     * @return True if it's still running.
-     */
-    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
-
-    /**
-     * Cancels async operation if it's still alive.
-     */
-    public void cancel(){
-        if(task.isAlive()){
-                            // Set values before interrupting to prevent InterruptedException from
-                            // being propagated and thrown in the main thread
-            t=null;
-            failed = true;  // Creates a unique and identifiable state
-                            //noinspection deprecation
-            task.stop();    // Force-stop thread
-        }
-    }
-}

src/com/tofvesson/async/WorkerThread.java

@@ -1,100 +0,0 @@
-package com.tofvesson.async;
-
-import javafx.util.Pair;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.*;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.ThreadLocalRandom;
-
-/**
- * A thread tasked with accepting multiple instructions. This is useful for people who don't want to constantly create new threads for heavy work.
- * Also good if the fields in an object instantiated in this thread aren't volatile.
- */
-public class WorkerThread extends Thread {
-
-    List<Long> ids = new ArrayList<>();
-    volatile Queue<Pair<Long, Pair<Method, Pair<Object, Object>>>> queue;
-    volatile Map<Long, Object> output = new HashMap<>();
-    volatile boolean alive=true, completed=false;
-
-    /**
-     * Create a WorkerThread.
-     * @param queueSize Maximum amount of instructions to be queued.
-     */
-    public WorkerThread(int queueSize){
-        super();
-        try{
-            Field f = Thread.class.getDeclaredField("target");
-            f.setAccessible(true);
-            f.set(this, (Runnable) ()->
-            {
-                synchronized (Thread.currentThread()) {
-                    while (alive) {
-                        if (queue.size() != 0) {
-                            Pair<Long, Pair<Method, Pair<Object, Object>>> q = queue.poll();
-                            Pair<Method, Pair<Object, Object>> instr = q.getValue();
-                            try {
-                                output.put(q.getKey(), instr.getKey().invoke(instr.getValue().getKey(), (Object[]) instr.getValue().getValue()));
-                                completed = true;
-                            } catch (IllegalAccessException | InvocationTargetException e) {
-                                e.printStackTrace();
-                            }
-                        }
-                    }
-                }
-            });
-        }catch(Exception e){}
-        queue = new ArrayBlockingQueue<>(queueSize);
-    }
-
-    /**
-     * Add a new instruction for the worker thread.
-     * @param invokeOn Object to invoke method on.
-     * @param m Method to invoke.
-     * @param params Parameters for method.
-     * @return A UID corresponding to the queued instruction.
-     */
-    public long push(Object invokeOn, Method m, Object... params){
-        m.setAccessible(true);
-        long id;
-        do{ id = ThreadLocalRandom.current().nextLong(); }while(ids.contains(id));
-        queue.add(new Pair<>(id, new Pair<>(m, new Pair<>(invokeOn, params))));
-        ids.add(id);
-        return id;
-    }
-
-    /**
-     * Waits for instruction to be processed and return value to be acquired.
-     * @param id UID of the supplied instruction.
-     * @return Return value from instruction called in worker thread.
-     */
-    public Object pop(long id){
-        if(!ids.contains(id)) return null;
-        if(Thread.currentThread() == this) throw new RuntimeException("Attempting to await result in worker thread! This causes the thread to lock.");
-        //noinspection StatementWithEmptyBody
-        while(!output.containsKey(id)) ; // Block caller thread until result is received
-        Object o = output.get(id);
-        output.remove(id);
-        ids.remove(id);
-        return o;
-    }
-
-    /**
-     * Waits for current method invocation to finish before stopping thread.
-     */
-    public void stopGraceful(){
-        alive = false;
-    }
-
-    /**
-     * Interrupts thread to kill it. NOTE: This method is unsafe and could cause issues if it is performing an I/O operation.
-     * Only call this if you are 100% sure that it won't break something or if are ready to deal with the consequences.
-     */
-    public void stopForced(){
-        alive = false;
-        //noinspection deprecation
-        stop();
-    }
-}

src/com/tofvesson/collections/Empty.java

@@ -1,3 +0,0 @@
-package com.tofvesson.collections;
-
-final class Empty {}

src/com/tofvesson/collections/ShiftingList.java

@@ -1,316 +0,0 @@
-package com.tofvesson.collections;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import java.util.stream.Collectors;
-
-@SuppressWarnings({"unchecked", "ReturnOfInnerClass", "unused"})
-public class ShiftingList<E> implements List<E> {
-    /**
-     * Holder for entries. Dur to reasons, the array holds objects.
-     */
-    Object[] entries;
-
-    /**
-     * Populated entries.
-     */
-    int pop = 0;
-
-    /**
-     * Maximum size of set.
-     */
-    final int maxSize;
-
-    /**
-     * Load factor used when calculating how to resize array.
-     */
-    double load;
-
-    /**
-     * Internal reference to reserved, unpopulated entries.
-     */
-    static final Empty empty = new Empty();
-
-    public ShiftingList(int maxSize, double load){
-        this.maxSize = maxSize<1?20:maxSize;
-        this.load = load>0.99||load<0.1?0.75:load;
-        entries = new Object[1];
-    }
-
-    public ShiftingList(int maxSize){
-        this(maxSize, 0.75);
-    }
-
-    @Override
-    public int size() {
-        return pop;
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return pop==0;
-    }
-
-    @Override
-    public boolean contains(Object o) {
-        if(o==empty) return false;
-        for(int i = 0; i<pop; ++i) if((o!=null && o.equals(entries[i])) || (o==null && entries[i]==empty)) return true;
-        return false;
-    }
-
-    @Override
-    public Object[] toArray() {
-        Object[] o = new Object[pop];
-        System.arraycopy(entries, 0, o, 0, pop);
-        for(int i = 0; i<o.length; ++i) if(o[i]==empty) o[i] = null;
-        return o;
-    }
-
-    @Override
-    public <T> T[] toArray(T[] a) {
-        for(int i = 0; i<Math.min(pop, a.length); ++i) a[i] = (T) entries[i];
-        return a;
-    }
-
-    @Override
-    public boolean add(E e) {
-        if(contains(e)) return false;
-        preparePopulate(1);
-        entries[0] = e!=null?e:empty;
-        pop=pop!=maxSize?pop+1:pop;
-        return true;
-    }
-
-    @Override
-    public boolean remove(Object o) {
-        for(int i = 0; i<pop; ++i)
-            if(entries[i]==o){
-                entries[i]=null;
-                if(pop<entries.length*load) {
-                    shift();
-                    adaptLoad(-1);
-                }
-                return true;
-            }
-        return false;
-    }
-
-    @Override
-    public boolean containsAll(Collection<?> c) {
-        boolean b = true;
-        for(Object o : c) b &= contains(o);
-        return b;
-    }
-
-    @Override
-    public boolean addAll(Collection<? extends E> c) {
-        ArrayList<? super E> l = c.stream().filter(e -> !contains(e)).collect(Collectors.toCollection(ArrayList::new));
-        if(l.size()>maxSize) for(int i = maxSize; i<l.size(); ++i) l.remove(i);
-        preparePopulate(l.size());
-        for(int i = 0; i<l.size(); ++i) entries[i] = l.get(i);
-        pop=Math.min(pop+l.size(), maxSize);
-        return true;
-    }
-
-    @Override
-    public boolean addAll(int index, Collection<? extends E> c) {
-        if(index>=maxSize) return false;
-        if(index>=entries.length || index<0 || c.size()==0) return false;
-        ArrayList<? super E> l = c.stream().filter(e -> !contains(e)).collect(Collectors.toCollection(ArrayList::new));
-        if(index+l.size()>maxSize) for(int i = maxSize-index; i<l.size(); ++i) l.remove(i);
-        adaptLoad(l.size());
-        pop = pop+l.size() >= maxSize ? pop : pop+l.size();
-        if(l.size()+index<entries.length) System.arraycopy(entries, index, entries, l.size()+1, entries.length-l.size()-1);
-        for(int i = 0; i<l.size(); ++i) entries[i+index] = l.get(i);
-        shift();                                                                                                        // Ensure no misalignment happens
-        return true;
-    }
-
-    @Override
-    public boolean retainAll(Collection<?> c) {
-        int removed = 0;
-        for(int i = 0; i<pop; ++i)
-            if(!c.contains(entries[i])) {
-                entries[i] = null;
-                ++removed;
-            }
-        if(removed==0) return false;
-        shift();
-        if((pop-=removed)<entries.length*load) adaptLoad();
-        return true;
-    }
-
-    @Override
-    public boolean removeAll(Collection<?> c) {
-        int removed = 0;
-        for(int i = 0; i<pop; ++i)
-            if(c.contains(entries[i])) {
-                entries[i] = null;
-                ++removed;
-            }
-        if(removed==0) return false;
-        shift();
-        if((pop-=removed)<entries.length*load) adaptLoad();
-        return true;
-    }
-
-    @Override
-    public void clear() {
-        pop = 0;
-        entries = new Object[1];
-    }
-
-    public int indexOf(Object o){
-        for(int i = 0; i<pop; ++i)
-            if(entries[i].equals(o)) return i;
-        return -1;
-    }
-
-    /**
-     * Adapts array size according to currently populated entries.
-     * Meant to be used when populated entries variable has already been updated.
-     * Same as invoking {@link #adaptLoad(int)} with parameter 0.
-     */
-    protected void adaptLoad(){
-        adaptLoad(0);
-    }
-
-    /**
-     * Changes size of array to account for new entries.
-     * @param accountFor The amount new elements to be accounted for.
-     */
-    protected void adaptLoad(int accountFor){
-        if(pop+accountFor<=0){
-            entries = new Object[1];
-            return;
-        }
-        Object[] o = new Object[(int) Math.max(1, Math.min((pop+accountFor)/load, maxSize))];                           // Load adaptation algorithm capping at maxSize or 0
-        System.arraycopy(entries, 0, o, 0, Math.min(o.length, entries.length));                                         // Move as many entries as possible
-        entries = o;
-    }
-
-    /**
-     * Shift all elements towards the start of the arrays.
-     */
-    protected void shift(){
-        for(int i = 0; i<entries.length; ++i)
-            if(entries[i]==null && i!=pop)
-                for(int j = i; j<entries.length; ++j)
-                    if(entries[j]!=null){
-                        entries[i] = entries[j];
-                        entries[j] = null;
-                        break;
-                    }else if(j+1==entries.length) return;                                                               // Found all populated entries
-    }
-
-    protected void preparePopulate(int accountFor){
-        if(accountFor+pop>entries.length) adaptLoad(accountFor);                                                        // If new elements exceed limit, adapt load
-        if(accountFor>entries.length) return;                                                                           // No need to delete elements if new values exceed limit
-        System.arraycopy(entries, 0, entries, accountFor, entries.length-accountFor);                                   // Shift array elements to account for new elements
-    }
-
-    @Override
-    public E get(int i){
-        if(i>pop) return null;
-        return entries[i]==empty?null:(E)entries[i];
-    }
-
-    @Override
-    public E set(int index, E element) {
-        if(index > pop) return null;
-        E e = get(index);
-        entries[index] = element;
-        return e;
-    }
-
-    @Override
-    public void add(int index, E element) {
-        if(index>=entries.length || index<0 || contains(element)) return;
-        Object o = element==null?empty:element;
-        pop = pop==maxSize?pop:pop+1;
-        if(pop==entries.length) adaptLoad();
-        if(index==entries.length-1){
-            entries[index] = o;
-            return;
-        }
-        System.arraycopy(entries, index, entries, index+1, entries.length-(index+1));
-        entries[index] = o;
-    }
-
-    @Override
-    public E remove(int index) {
-        if(index>pop || index<0) return null;
-        E e = entries[index]==empty?null:(E)entries[index];
-        entries[index] = null;
-        shift();
-        if(--pop<entries.length*load) adaptLoad();
-        return e;
-    }
-
-    @Override
-    public int lastIndexOf(Object o) {
-        for(int i = pop; i>0; --i)
-            if(o.equals(entries[i]))
-                return i;
-        return -1;
-    }
-
-    @Override
-    public Iterator<E> iterator(){ return new Iterator<>(pop, entries); }
-
-    @Override
-    public ListIterator<E> listIterator(){ return new ListIterator<>(this); }
-
-    @Override
-    public ListIterator<E> listIterator(int index) {
-        if(index<0) throw new RuntimeException("Invalid starting point for iterator defined: "+index);
-        return new ListIterator<>(this, index);
-    }
-
-    @Override
-    public List<E> subList(int fromIndex, int toIndex) {
-        if(fromIndex<0 || fromIndex>=toIndex || fromIndex>pop || toIndex>pop) return new ArrayList<>();
-        ShiftingList<E> l = new ShiftingList<>(maxSize);
-        for(int i = toIndex-1; i>fromIndex; --i) l.add(entries[i]==empty?null:(E)entries[i]);
-        return l;
-    }
-
-    /**
-     * Standard iterator. For observing list.
-     * @param <V> Type of object stored in list.
-     */
-    public static class Iterator<V> implements java.util.Iterator<V>{
-        protected int counter = 0;
-        private final int pop;
-        private final Object[] entries;
-        public Iterator(int pop, Object[] entries){  this.pop = pop; this.entries = entries; }
-        @Override public boolean hasNext() { return counter<pop; }
-        @Override public V next() { return entries[counter++]==empty?null:(V)entries[counter-1]; }
-    }
-
-    /**
-     * List iterator. For making modifications on-the-go while going through list.
-     * @param <V> Type of object stored in list.
-     */
-    public static class ListIterator<V> implements java.util.ListIterator<V>{
-        protected int counter = 0;
-        protected boolean opNxt = false;
-        private Object pEl = null;
-        private final int pop;
-        private final Object[] entries;
-        private final ShiftingList list;
-        public ListIterator(ShiftingList list){ this.pop = list.pop; this.entries = list.entries; this.list = list;}
-        public ListIterator(ShiftingList list, int start){ this(list); counter = start; }
-        @Override public boolean hasNext() { return counter<pop; }
-        @Override public V next() { opNxt = true; return (V)(pEl=entries[counter++]==empty?null:entries[counter-1]); }
-        @Override public boolean hasPrevious() { return counter>0&&pop!=0; }
-        @Override public V previous() { opNxt = false; return (V)(pEl=entries[--counter]==empty?null:entries[counter]); }
-        @Override public int nextIndex() { return counter+1<pop?counter+1:pop; }
-        @Override public int previousIndex() { return counter!=0?counter-1:0; }
-        @Override public void remove() { list.remove(counter-(opNxt?0:1)); }
-        @Override public void set(V v) { if(pEl==entries[counter-(opNxt?0:1)]) entries[counter-(opNxt?0:1)] = v==null?empty:v; }
-        @Override public void add(V v) { list.add(counter, v); }
-    }
-}

src/com/tofvesson/reflection/SafeReflection.java

@@ -1,391 +0,0 @@
-package com.tofvesson.reflection;
-
-import java.lang.reflect.Constructor;
-import sun.misc.Unsafe;
-import sun.reflect.ConstructorAccessor;
-import java.lang.reflect.Array;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.HashMap;
-
-/**
- * Safe tools to help simplify code when dealing with reflection.
- */
-@SuppressWarnings("unused")
-public class SafeReflection {
-
-
-    private static final Unsafe unsafe;
-
-    static{
-        Unsafe u = null;
-        try{
-            Field f = Unsafe.class.getDeclaredField("theUnsafe");
-            f.setAccessible(true);
-            u = (Unsafe) f.get(null);
-        }catch(Exception ignored){}                                                                                     // Exception is never thrown
-        unsafe = u;
-    }
-
-    /**
-     * Gets the constructor from the defined class with the specified parameters.
-     * @param c Class to get constructor from.
-     * @param params Definition of parameters that the constructor requires.
-     * @param <T> Return-type of constructor.
-     * @return Constructor with specified parameter requirements or null if constructor doesn't exist.
-     */
-    public static <T> Constructor<T> getConstructor(Class<T> c, Class<?>... params){
-        try{
-            Constructor<T> c1 = c.getConstructor(params);
-            c1.setAccessible(true);
-            return c1;
-        }catch(Exception e){}
-        return null;
-    }
-
-    /**
-     * Gets the first constructor available from the given class.
-     * @param c Class to get constructor from.
-     * @param <T> Return-type of constructor.
-     * @return Constructor or null if something goes horribly wrong.
-     */
-    public static <T> Constructor<T> getFirstConstructor(Class<T> c){
-        try {
-            @SuppressWarnings("unchecked")
-            Constructor<T> c1 = (Constructor<T>) c.getDeclaredConstructors()[0];
-            c1.setAccessible(true);
-            return c1;
-        }catch (Exception e){}
-        return null;
-    }
-
-    /**
-     * Gets the method from the defined class by name and parameters.
-     * Method is accessible.
-     * @param c Class to find method in.
-     * @param name Name of method.
-     * @param params Parameters of method.
-     * @return Method or null if specified method wasn't found.
-     */
-    public static Method getMethod(Class<?> c, String name, Class<?>... params){
-        try{
-            Method m = c.getDeclaredMethod(name, params);
-            m.setAccessible(true);
-            return m;
-        }catch(Exception e){}
-        return null;
-    }
-
-    /**
-     * Attempts to invoke a supplied static method with the given parameters.
-     * @param m Method to invoke.
-     * @param params Parameters to supply to method.
-     * @return Return value of method or null if method is null.
-     */
-    public static Object invokeStaticMethod(Method m, Object... params){
-        try{ return invokeMethod(null, m, params); }catch(Exception e){}
-        return null;
-    }
-
-    /**
-     * Attempts to invoke a supplied method with the given parameters on the supplied object.
-     * @param inst Object to invoke method in.
-     * @param m Method to invoke.
-     * @param params Parameters to supply to method.
-     * @return Return value of method or null if method is null.
-     */
-    public static Object invokeMethod(Object inst, Method m, Object... params){
-        if(m!=null) m.setAccessible(true);
-        try{ return m!=null?m.invoke(inst, params):null; }catch(Exception e){}
-        return null;
-    }
-
-    /**
-     * Finds the first method available with the specified name from the class.
-     * Meant to be used in cases where a class only has one version of a method.
-     * Method is accessible.
-     * @param c Class to find method in.
-     * @param name Name of method.
-     * @return Method or null if no method with given name exists.
-     */
-    public static Method getFirstMethod(Class<?> c, String name){
-        try{
-            Method[] m = c.getDeclaredMethods();
-            for (Method aM : m) if(aM.getName().equals(name)){ aM.setAccessible(true); return aM;}
-        }catch(Exception e){}
-        return null;
-    }
-
-    /**
-     * Gets field object referring to field with specified name in defined class.
-     * @param c Class to find field in.
-     * @param name Name of field.
-     * @return Field or null if no field with specified name exists.
-     */
-    public static Field getField(Class<?> c, String name){
-        try{
-            Field f = c.getDeclaredField(name);
-            f.setAccessible(true);
-            return f;
-        }catch(Exception e){}
-        return null;
-    }
-
-    /**
-     * Gets the static object stored in the field with the specified name in the defined class.
-     * @param c Class to find object in.
-     * @param name Name of field.
-     * @return Object or null if object is null or field doesn't exist.
-     */
-    public static Object getStaticFieldObject(Class<?> c, String name){
-        Field f = getField(c, name);
-        try { return f!=null?f.get(null):null; } catch (Exception e) { }
-        return null;
-    }
-
-    /**
-     * Gets the object stored in the field with the specified name in the class of the defined object.
-     * @param o Object to find object in.
-     * @param name Name of field.
-     * @return Object or null if object is null or field doesn't exist.
-     */
-    public static Object getFieldObject(Object o, String name){
-        Field f = getField(o.getClass(), name);
-        try{ return f!=null?f.get(o):null; }catch(Exception e){}
-        return null;
-    }
-
-    /**
-     * Gets a reference to the enclosing class from a defined inner (nested) object.
-     * @param nested Object instance of a nested class.
-     * @return "this" reference to the outer class or null if class of object instance is static or isn't nested.
-     */
-    public static Object getEnclosingClassObjectRef(Object nested){
-        try{
-            Field f = nested.getClass().getDeclaredField("this$0");
-            f.setAccessible(true);
-            return f.get(nested);
-        }catch(Exception e){}
-        return null;
-    }
-
-    /**
-     * Checks whether a given class is an inner (nested) class.
-     * @param c Class to check.
-     * @return True if class is nested otherwise false.
-     */
-    public static boolean isNestedClass(Class<?> c){ return c.getEnclosingClass()!=null; }
-
-    /**
-     * Get class file based on class name.
-     * @param c Class to find file of.
-     * @return File if class file exists.
-     */
-    public static java.io.File getClassFile(Class c){ return new java.io.File(c.getResource(c.getSimpleName()+".class").getFile()); }
-
-    /**
-     * Allows you to create a completely custom Enum value. If the supplied value already exists, it will be returned.
-     * will not be created; the value of the existing one will be updated.
-     * @param clazz The class to attribute the new enum to.
-     * @param addToValuesArray Whether or not to update the internal, "immutable" values array with the new value (ignored if value already exists).
-     * @return A new/existing enum.
-     */
-    @SuppressWarnings("unchecked")
-    public static <T extends Enum<T>> T customEnum(Class<T> clazz, boolean addToValuesArray, String name, EnumDefinition def){
-        T u;
-        try {
-            // Get a reference to the static method values() and get values
-            Method v = clazz.getDeclaredMethod("values");
-            v.setAccessible(true);
-            T[] values = (T[]) v.invoke(null);
-
-            // Return object if it already exists
-            for(T u2 : values) if(u2.name().equals(name)) return u2;
-
-            // Generate enum parameter definition
-            Class[] paramList = new Class[def.params.size()+2];
-            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
-
-            // Get enum constructor (inherited from Enum.class)
-            Constructor c = clazz.getDeclaredConstructor(paramList);
-            c.setAccessible(true);
-            Method m = Constructor.class.getDeclaredMethod("acquireConstructorAccessor");
-            m.setAccessible(true);
-
-            // Get constructor accessor since Constructor.newInstance throws an exception because Enums are "immutable"
-            ConstructorAccessor access = (ConstructorAccessor) m.invoke(c);
-
-            Object[] parameters = new Object[def.params.size()+2];
-            parameters[0] = name;
-            parameters[1] = values.length;
-            iterator = parameters.length;
-            for(Object o : def.params.keySet()) parameters[--iterator] = o;
-
-            // Create new instance of enum with valid name and ordinal
-            u = (T) access.newInstance(parameters);
-
-            // Get the final name field from Enum.class and make it temporarily modifiable
-            Field f = Enum.class.getDeclaredField("name");
-            f.setAccessible(true);
-
-            // Rename the newly created enum to the requested name
-            f.set(u, name);
-
-            if(!addToValuesArray) return u; // Stops here if
-
-            // Get the current values field from Enum (a bitch 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
-            m = Field.class.getDeclaredMethod("getFieldAccessor", Object.class);
-            m.setAccessible(true);
-            Object UQSOFAImpl = m.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
-            Field f1 = UQSOFAImpl.getClass().getSuperclass().getDeclaredField("isReadOnly");
-            f1.setAccessible(true);
-            f1.setBoolean(UQSOFAImpl, false);
-
-            // Invoke set() method on UnsafeQualifiedStaticObjectFieldAccessorImpl object which sets the
-            // private field $VALUES to our new array
-            m = UQSOFAImpl.getClass().getDeclaredMethod("set", Object.class, Object.class);
-            m.setAccessible(true);
-            m.invoke(UQSOFAImpl, f, $VALUES);
-        } catch (Exception wrongParams) { throw new RuntimeException(wrongParams); }
-        return u;
-    }
-
-    /**
-     * Create a new object without the hassle of having to construct it. WARNING: Not usually a good idea.
-     * @param clazz Class to instantiate.
-     * @return An object instance of the supplied class that hasn't been constructed.
-     * @throws InstantiationException Thrown if instantiating the object fails for some reason.
-     */
-    public static <T> T createNewObject(Class<T> clazz) throws InstantiationException{
-        //noinspection unchecked
-        return (T) unsafe.allocateInstance(clazz);
-    }
-
-
-    /**
-     * A definition for custom enum creation.
-     */
-    public static class EnumDefinition {
-        HashMap<Object, Class> params = new HashMap<>(); // Assign a specific type to each parameter
-
-        /**
-         * Put an object in the parameter list.
-         * @param value The parameter to supply. (Type is derived automatically)
-         * @return A reference to the EnumDefinition object this method was called on (for chaining).
-         */
-        public EnumDefinition putObject(Object value){
-            params.put(value, value.getClass());
-            return this;
-        }
-
-        /**
-         * Put a primitive value in the parameter list.
-         * @param autoBoxed An autoboxed version of the parameter. (For example putPrimitive(5) will automatically become Integer)
-         * @return A reference to the EnumDefinition object this method was called on (for chaining).
-         * @throws NotAutoBoxedException Thrown if a value expected to be autoboxed isn't autoboxed.
-         */
-        public EnumDefinition putPrimitive(Object autoBoxed) throws NotAutoBoxedException{
-            // All autoboxed versions of primitives have a reference to their boxed primitive
-            try {
-                params.put(autoBoxed, autoBoxed.getClass().getDeclaredField("value").getType());
-            }catch(Exception e){ throw new NotAutoBoxedException(); }
-            return this;
-        }
-
-        /**
-         * Safe wrapper of {@link #putPrimitive(Object)} for boolean.
-         * @param b Boolean parameter.
-         * @return A reference to the EnumDefinition object this method was called on (for chaining).
-         */
-        public EnumDefinition putBoolean(boolean b){
-            try { return putPrimitive(b);  } catch (NotAutoBoxedException e) { }
-            return this;
-        }
-
-        /**
-         * Safe wrapper of {@link #putPrimitive(Object)} for byte.
-         * @param b Byte parameter.
-         * @return A reference to the EnumDefinition object this method was called on (for chaining).
-         */
-        public EnumDefinition putByte(byte b){
-            try { return putPrimitive(b); } catch (NotAutoBoxedException e) { }
-            return this;
-        }
-
-        /**
-         * Safe wrapper of {@link #putPrimitive(Object)} for char.
-         * @param c Character parameter.
-         * @return A reference to the EnumDefinition object this method was called on (for chaining).
-         */
-        public EnumDefinition putChar(char c){
-            try { return putPrimitive(c); } catch (NotAutoBoxedException e) { }
-            return this;
-        }
-
-        /**
-         * Safe wrapper of {@link #putPrimitive(Object)} for short.
-         * @param s Short parameter.
-         * @return A reference to the EnumDefinition object this method was called on (for chaining).
-         */
-        public EnumDefinition putShort(short s){
-            try { return putPrimitive(s); } catch (NotAutoBoxedException e) { }
-            return this;
-        }
-
-        /**
-         * Safe wrapper of {@link #putPrimitive(Object)} for int.
-         * @param i Integer parameter.
-         * @return A reference to the EnumDefinition object this method was called on (for chaining).
-         */
-        public EnumDefinition putInt(int i){
-            try { return putPrimitive(i); } catch (NotAutoBoxedException e) { }
-            return this;
-        }
-
-        /**
-         * Safe wrapper of {@link #putPrimitive(Object)} for long.
-         * @param l Long parameter.
-         * @return A reference to the EnumDefinition object this method was called on (for chaining).
-         */
-        public EnumDefinition putLong(long l){
-            try { return putPrimitive(l); } catch (NotAutoBoxedException e) { }
-            return this;
-        }
-
-        /**
-         * Safe wrapper of {@link #putPrimitive(Object)} for float.
-         * @param f Floating point parameter.
-         * @return A reference to the EnumDefinition object this method was called on (for chaining).
-         */
-        public EnumDefinition putFloat(float f){
-            try { return putPrimitive(f); } catch (NotAutoBoxedException e) { }
-            return this;
-        }
-
-        /**
-         * Safe wrapper of {@link #putPrimitive(Object)} for double.
-         * @param d Double parameter.
-         * @return A reference to the EnumDefinition object this method was called on (for chaining).
-         */
-        public EnumDefinition putDouble(double d){
-            try { return putPrimitive(d); } catch (NotAutoBoxedException e) { }
-            return this;
-        }
-    }
-
-}

src/net/tofvesson/async/Async.java

@@ -0,0 +1,320 @@
+package net.tofvesson.async;
+
+import net.tofvesson.collections.Pair;
+import net.tofvesson.reflection.Classes;
+import net.tofvesson.reflection.SafeReflection;
+import jdk.internal.org.objectweb.asm.ClassWriter;
+import jdk.internal.org.objectweb.asm.MethodVisitor;
+import jdk.internal.org.objectweb.asm.Opcodes;
+
+import java.lang.reflect.*;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Vector;
+
+@SuppressWarnings({"WeakerAccess", "unused", "unchecked", "SameParameterValue", "JavaReflectionMemberAccess"})
+public class Async<T> implements Awaitable{
+
+    private static final Field threadLocals;
+    private static final boolean android;
+
+    static{
+        Field f = null;
+        boolean $android = false;
+        try{
+            try{
+                f = Thread.class.getDeclaredField("threadLocals");
+            }catch(Exception ignored){ f = Thread.class.getDeclaredField("localValues"); $android = true; }
+        }catch(Exception e){ e.printStackTrace(); }
+        threadLocals = f;
+        android = $android;
+    }
+
+
+    /**
+     * Thread running background task.
+     */
+    Thread task;
+
+    /**
+     * Return value/ constructed object.
+     */
+    volatile T ret;
+
+    /**
+     * Whether or not a posted value can be overwritten.
+     */
+    volatile boolean ovw = true;
+
+    /**
+     * Status indicators.
+     */
+    volatile boolean complete = false, failed = false; // Used by anonymous class, therefore not private
+
+    /**
+     * Exception to throw in case something goes wrong.
+     */
+    volatile Throwable t;
+
+    private final LinkedHashMap<String, Object> asyncLocals = new LinkedHashMap<String, Object>();
+
+    /**
+     * Create Async object for sleeping for a while.
+     * @param millis Milliseconds to wait.
+     * @param micros Microseconds to wait.
+     */
+    private Async(final long millis, final int micros){
+        task = new Thread(new Runnable(){
+            public void run(){
+                new ThreadLocal<Async>().set(Async.this);
+                try {
+                    Thread.sleep(millis, micros);
+                    Async.this.complete = true;
+                } catch (InterruptedException t1) {
+                    if(!Async.this.failed) {
+                        Async.this.failed = true;
+                        Async.this.t=t1;
+                    }
+                }
+            }
+        });
+        task.setDaemon(true);
+        task.start();
+    }
+
+    /**
+     * Create Async process with runnable.
+     * @param r Runnable to execute as new task.
+     */
+    public Async(final Runnable r){
+        task = new Thread(new Runnable(){
+            public void run(){
+                try {
+                    new ThreadLocal<Async>()
+                            .set(Async.this);           // Store ThreadLocal reference to Async object
+                    r.run();                            // Execute runnable
+                    complete = true;                    // Notify all threads who are checking
+                } catch (Throwable t1) {                // Prepare for failure
+                    if(!failed) {                       // Checks if task was canceled
+                        failed = true;                  // Notifies all threads that task failed
+                        t=t1;                           // Makes error accessible to be thrown
+                    }
+                }
+            }
+        });                                         // Execute thread with runnable
+        task.setDaemon(true);                       // Ensure that process dies with program
+        task.start();                               // Start task
+    }
+
+    /**
+     * Initiates an async task that invokes the defined method. If object is null, the method must be static.
+     * Note that this is optimized for larger tasks id est tasks that take more than 5 milliseconds to process (preferably a minimum of 10 ms).
+     * @param o Object to invoke method on.
+     * @param method Method to invoke.
+     * @param params Required parameters.
+     */
+    public Async(final Object o, final Method method, final Object... params){
+        method.setAccessible(true); // Ensure that no crash occurs
+        task = new Thread(new Runnable(){ // Create a new thread
+            public void run(){
+                try {
+                    new ThreadLocal<Async>().set(Async.this);
+                    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
+                        failed = true;                  // Notifies all threads that task failed
+                        t=t1;                           // Makes error accessible to be thrown
+                    }
+                }
+            }
+        });
+        task.setDaemon(true);                       // Ensure that process dies with program
+        task.start();                               // Start task
+    }
+
+    /**
+     * Dispatches an asynchronous call to supplied method on specified object with no parameters.
+     * @param o Object to call method on.
+     * @param m Method to call. Must be parameter-less!
+     */
+    public Async(Object o, Method m){ this(o, m, (Object[]) null); }
+
+    /**
+     * Dispatches an asynchronous call to supplied static method.
+     * @param m Static method to call.
+     * @param params Parameters to supply to method.
+     */
+    public Async(Method m, Object... params){ this(null, m, params); }
+
+    /**
+     * Dispatches an asynchronous, static, parameter-less method call.
+     * @param m Method to call.
+     */
+    public Async(Method m){ this(null, m, (Object[]) null); }
+
+    /**
+     * Create a new async task for instantiating an object.
+     * @param c Constructor to use when instantiating object.
+     * @param params Parameters to use when instantiaing object.
+     */
+    public Async(final Constructor<T> c, final Object... params){
+        c.setAccessible(true);                  // Ensure that constructor can be called
+        task = new Thread(new Runnable() {               // Creates a new thread for asynchronous execution
+            public void run(){
+                new ThreadLocal<Async>().set(Async.this);
+                try {
+                    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()
+                        failed = true;              // Notify all threads that error has been encountered
+                        t=t1;                       // Make throwable accessible to be thrown in caller thread
+                    }
+                }
+            }
+        });
+        task.setDaemon(true);                   // Ensure that thread dies with program
+        task.start();                           // Start construction
+    }
+
+    /**
+     * 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); }
+
+    /**
+     * Should probably only be used in debugging applications when a preset return value should be given and there is no need to start a new thread.
+     * This won't even start a new thread. All it does is set it's current state to "finished" and allow for the return value to be read.
+     * @param o Return value.
+     */
+    public Async(T o){ complete = true; ret = o; }
+    /**
+     * WARNING: Package-scoped because it should only be used when overriding standard construction. Should not bw used haphazardly!
+     */
+    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
+        //noinspection unchecked
+        return ret; // Don't bother resetting values since this object is only intended to be recycled after value is gotten
+    }
+
+    /**
+     * Checks if async task is still running.
+     * @return True if it's still running.
+     */
+    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 <T> Async<T> current(){
+        try{
+            Object holder;
+            Field f = threadLocals;
+            f = (holder= SafeReflection.getFieldValue(f, Thread.currentThread())).getClass().getDeclaredField("table");
+            for(Object o : (Object[]) SafeReflection.getFieldValue(f, holder))
+                if(o != null) {
+                    if(android) holder = o;
+                    else f = o.getClass().getDeclaredField("value");
+                    if((android?holder:(holder=SafeReflection.getFieldValue(f, o))) instanceof Async) return (Async<T>) 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.
+     */
+    public void cancel(){
+        if(task.isAlive()){
+                            // Set values before interrupting to prevent InterruptedException from
+                            // being propagated and thrown in the main thread
+            t=null;
+            failed = true;  // Creates a unique and identifiable state
+                            //noinspection deprecation
+            task.stop();    // Force-stop thread
+        }
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Get a map of values local to this async object.
+     * @return Map of values if called from this async task, otherwise throw exception
+     */
+    public Map<String, Object> getLocals(){
+        if(!this.equals(Async.<T>current())) throw new IllegalCallerThreadException("Cannot get locals from another thread!");
+        return asyncLocals;
+    }
+
+    /**
+     * Checks for dangerous calls to Async methods such as awaiting oneself (which would cause a freeze in that thread).
+     */
+    protected final void checkDangerousThreadedAction(){
+        if(this.equals(current())) throw new IllegalCallerThreadException("Calling dangerous method from inside thread is forbidden!");
+    }
+
+    /**
+     * Safe method for delaying the current thread.
+     * @param millis Milliseconds to delay.
+     * @param micros Microseconds to delay.
+     */
+    public static void sleep(long millis, int micros){ new Async(millis, micros).await(); }
+
+    /**
+     * Safe method for delaying the current thread.
+     * @param millis Milliseconds to delay.
+     */
+    public static void sleep(long millis){ sleep(millis, 0); }
+
+    public static void iSleep(long millis, int micros){ try{ Thread.sleep(millis, micros); } catch(Exception ignored) {} }
+
+    public static void iSleep(long millis){ iSleep(millis, 0); }
+}

src/net/tofvesson/async/AsyncBatch.java

@@ -0,0 +1,27 @@
+package net.tofvesson.async;
+
+import java.util.HashMap;
+
+/**
+ * Creates a batch of similar async instructions.
+ */
+@SuppressWarnings("unused")
+public class AsyncBatch<T> {
+
+    private final HashMap<Integer, Async<T>> all = new HashMap<Integer, Async<T>>();
+
+    public AsyncBatch(int count, final BatchRunnable r) { for(int i = 0; i<count; ++i) add(r, i); }
+
+    private void add(final BatchRunnable r, final int idx){ all.put(idx, new Async<T>(new Runnable() { public void run() { r.run(idx); } })); }
+    public HashMap<Integer, Async<T>> getAll(){ return all; }
+    public HashMap<Integer, T> awaitAll(){
+        HashMap<Integer, T> al = new HashMap<Integer, T>();
+        for(Integer a : all.keySet())
+            al.put(a, all.get(a).await());
+        return al;
+    }
+    public int getFinished(){ int i = 0; for(Async<T> a : all.values()) if(!a.isAlive()) ++i; return i; }
+    public int size(){ return all.size(); }
+    public boolean allFinished(){ return getFinished()==all.size(); }
+    public void cancelAll(){ for(Async<T> a : all.values()) a.cancel(); }
+}

src/net/tofvesson/async/Awaitable.java

@@ -0,0 +1,6 @@
+package net.tofvesson.async;
+
+public interface Awaitable<T> {
+    T await();
+    boolean isAlive();
+}

src/net/tofvesson/async/BatchRunnable.java

@@ -0,0 +1,5 @@
+package net.tofvesson.async;
+
+public interface BatchRunnable {
+    void run(int index);
+}

src/net/tofvesson/async/EcoAsync.java

@@ -1,6 +1,8 @@
-package com.tofvesson.async;
+package net.tofvesson.async;
 
 
+import net.tofvesson.reflection.SafeReflection;
+
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
@@ -13,27 +15,13 @@ import java.lang.reflect.Method;
 @SuppressWarnings("unused")
 public class EcoAsync<T> extends Async<T> {
 
-    private static final Field threadTarget, runnableObjToCall, runnableMethod, runnableParams;
+    private static final Field
+            threadTarget = SafeReflection.getField(Thread.class, "target"),
+            runnableObjToCall = SafeReflection.getField(EcoRunnable.class, "val$o"),
+            runnableMethod = SafeReflection.getField(EcoRunnable.class, "val$method"),
+            runnableParams = SafeReflection.getField(EcoRunnable.class, "val$params");
     private Thread previousThread;
 
-    static{
-        Field f4 = null, f3 = null, f2 = null, f1 = null;
-        try{
-            f1 = Thread.class.getDeclaredField("target");
-            f1.setAccessible(true);
-            f2 = EcoAsync$1.class.getDeclaredField("val$o");
-            f2.setAccessible(true);
-            f3 = EcoAsync$1.class.getDeclaredField("val$method");
-            f3.setAccessible(true);
-            f4 = EcoAsync$1.class.getDeclaredField("val$params");
-            f4.setAccessible(true);
-        }catch(Exception ignored){}
-        threadTarget = f1;
-        runnableObjToCall = f2;
-        runnableMethod = f3;
-        runnableParams = f4;
-    }
-
     /**
      * Initiates an economic version of async task that invokes the defined method. If object is null, the method must be static.
      * 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 re-usability in mind and, as such, doesn't have to be re-instantiated
@@ -142,6 +130,8 @@ public class EcoAsync<T> extends Async<T> {
 
     @Override
     public T await() {
+        checkDangerousThreadedAction();
+        if(!isAlive()) throw new IllegalStateException("Cannot await async that isn't alive!");
         //noinspection StatementWithEmptyBody
         while(!failed && !complete);
         if(ret==null && t!=null){
@@ -155,7 +145,7 @@ public class EcoAsync<T> extends Async<T> {
 
     @Override
     public boolean isAlive() {
-        return !super.failed && !complete && previousThread!=null; // Due to the overridden operation, we need another way of checking if worker is alive.
+        return !super.failed && !complete && task!=null && task.isAlive(); // Due to the overridden operation, we need another way of checking if worker is alive.
     }
 
     @Override
@@ -176,7 +166,7 @@ public class EcoAsync<T> extends Async<T> {
         if(isAlive()) cancel();
         // Dig parameters out from memory rather than wasting space with our own copy
         try {
-            EcoAsync$1 t_run = (EcoAsync$1) threadTarget.get(task);
+            EcoRunnable t_run = (EcoRunnable) threadTarget.get(task);
             newThread(runnableObjToCall.get(t_run),
                     (Method) runnableMethod.get(t_run),
                     (Object[]) runnableParams.get(t_run));
@@ -187,7 +177,7 @@ public class EcoAsync<T> extends Async<T> {
     void newThread(Object o, Method method, Object... params){
         previousThread = null;
         try {
-            task = new Thread(new EcoAsync$1(this, o, method, params), "Worker_"+method.getDeclaringClass().getName()+"_"+method.getName());
+            task = new Thread(new EcoRunnable(this, o, method, params), "Worker_"+method.getDeclaringClass().getName()+"_"+method.getName());
             task.setDaemon(true);
         } catch (Exception ignored) { }
     }

src/net/tofvesson/async/EcoRunnable.java

@@ -1,4 +1,4 @@
-package com.tofvesson.async;
+package net.tofvesson.async;
 
 import java.lang.reflect.Method;
 
@@ -6,24 +6,24 @@ import java.lang.reflect.Method;
  * Pre-written anonymous class. Follows all naming conventions of an anonymous class, acts like an anonymous class and handles data like an anonymous class.
  * It just isn't an anonymous class technically speaking...
  */
-class EcoAsync$1 implements Runnable{
+class EcoRunnable implements Runnable{
 
     private final EcoAsync this$0;
     private final Object val$o;
     private final Method val$method;
     private final Object[] val$params;
 
-    EcoAsync$1(EcoAsync this$0, Object val$o, Method val$method, Object[] val$params){
+    EcoRunnable(EcoAsync this$0, Object val$o, Method val$method, Object[] val$params){
         this.this$0 = this$0;
         this.val$o = val$o;
         this.val$method = val$method;
         this.val$params = val$params;
     }
 
-    @Override
     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) {

src/net/tofvesson/async/IgnorantRunnable.java

@@ -0,0 +1,9 @@
+package net.tofvesson.async;
+
+/**
+ * A Runnable-esque interface that allows for running code without try-catch blocks.
+ */
+public abstract class IgnorantRunnable implements Runnable{
+    public void run(){ try { irun(); } catch (Throwable throwable) { throw new RuntimeException(throwable); } }
+    public abstract void irun() throws Throwable;
+}

src/net/tofvesson/async/IllegalCallerThreadException.java

@@ -0,0 +1,18 @@
+package net.tofvesson.async;
+
+public class IllegalCallerThreadException extends RuntimeException {
+    public IllegalCallerThreadException() {
+    }
+
+    public IllegalCallerThreadException(String message) {
+        super(message);
+    }
+
+    public IllegalCallerThreadException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public IllegalCallerThreadException(Throwable cause) {
+        super(cause);
+    }
+}

src/net/tofvesson/async/WorkerThread.java

@@ -0,0 +1,120 @@
+package net.tofvesson.async;
+
+import net.tofvesson.collections.Pair;
+import net.tofvesson.reflection.SafeReflection;
+import java.lang.reflect.Method;
+import java.util.*;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * A thread tasked with accepting multiple instructions. This is useful for people who don't want to constantly create new threads for heavy work.
+ * Also good if the fields in an object instantiated in this thread aren't volatile.
+ */
+public class WorkerThread extends Thread {
+
+    protected final List<Long> ids = new ArrayList<Long>();
+    protected final Queue<Pair<Long, Pair<Method, Pair<Object, Object>>>> queue;
+    protected final Map<Long, Object> output = new HashMap<Long, Object>();
+    protected final AtomicBoolean alive = new AtomicBoolean(true);
+
+    /**
+     * Create a WorkerThread.
+     * @param queueSize Maximum amount of instructions to be queued.
+     */
+    public WorkerThread(int queueSize){
+        super();
+        SafeReflection.setValue(this, Thread.class, "target", new Runnable()
+        {
+            public void run(){
+                while (getAlive()) {
+                    if (queue.size() != 0) {
+                        final Pair<Long, Pair<Method, Pair<Object, Object>>> q;
+                        synchronized (queue){
+                            q = queue.poll();
+                        }
+                        final Pair<Method, Pair<Object, Object>> instr = q.getValue();
+                        try {
+                            synchronized (output) {
+                                output.put(q.getKey(), instr.getKey().invoke(instr.getValue().getKey(), (Object[]) instr.getValue().getValue()));
+                            }
+                        } catch (Exception e) {
+                            e.printStackTrace();
+                        }
+                    }else
+                        try {
+                            Thread.sleep(5);
+                        } catch (InterruptedException e) { }
+                }
+            }
+        });
+        queue = new ArrayBlockingQueue<Pair<Long, Pair<Method, Pair<Object, Object>>>>(queueSize);
+    }
+
+    /**
+     * Add a new instruction for the worker thread.
+     * @param invokeOn Object to invoke method on.
+     * @param m Method to invoke.
+     * @param params Parameters for method.
+     * @return A UID corresponding to the queued instruction.
+     */
+    public long push(Object invokeOn, Method m, Object... params){
+        m.setAccessible(true);
+        long id;
+        Random r = new Random();
+        do{ id = r.nextLong(); }while(ids.contains(id));
+        synchronized (queue) {
+            queue.add(new Pair<Long, Pair<Method, Pair<Object, Object>>>(id, new Pair<Method, Pair<Object, Object>>(m, new Pair<Object, Object>(invokeOn, params))));
+        }
+        ids.add(id);
+        return id;
+    }
+
+    /**
+     * Waits for instruction to be processed and return value to be acquired.
+     * @param id UID of the supplied instruction.
+     * @return Return value from instruction called in worker thread.
+     */
+    public Object pop(long id){
+        if(!isAlive()) throw new IllegalStateException("Cannot pop value from inactive thread");
+        if(!ids.contains(id)) return null;
+        if(Thread.currentThread() == this) throw new RuntimeException("Attempting to await result in worker thread! This causes the thread to lock.");
+        //noinspection StatementWithEmptyBody
+        while(!output.containsKey(id)) // Block caller thread until result is received
+            try {
+                Thread.sleep(5);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        Object o;
+        synchronized (output) {
+            o = output.get(id);
+            output.remove(id);
+        }
+        ids.remove(id);
+        return o;
+    }
+
+    /**
+     * Waits for current method invocation to finish before stopping thread.
+     */
+    public void stopGraceful(){
+        synchronized (alive) { alive.set(false); }
+    }
+
+    protected final boolean getAlive(){
+        boolean b;
+        synchronized (alive) { b = alive.get(); }
+        return b;
+    }
+
+    /**
+     * Interrupts thread to kill it. NOTE: This method is unsafe and could cause issues if it is performing an I/O operation.
+     * Only call this if you are 100% sure that it won't break something or if are ready to deal with the consequences.
+     */
+    public void stopForced(){
+        stopGraceful();
+        //noinspection deprecation
+        stop();
+    }
+}

src/net/tofvesson/collections/Collections.java

@@ -0,0 +1,109 @@
+package net.tofvesson.collections;
+
+import net.tofvesson.reflection.SafeReflection;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Collection;
+
+@SuppressWarnings("unchecked")
+public final class Collections {
+
+    private static final Field arrayListElements;
+    private static final Field arrayListSize;
+
+    static{
+        arrayListElements = SafeReflection.getField(ArrayList.class, "elementData");
+        arrayListSize = SafeReflection.getField(ArrayList.class, "size");
+    }
+
+
+    /**
+     * Flip a collection and return the given collection with it's contents flipped.
+     * @param c Collection to flip/reverse.
+     * @param <T> Type of elements in collection.
+     * @param <V> Type of collection to flip
+     * @return The given collection.
+     */
+    public static <T, V extends Collection<T>> V flip(V c){
+        ArrayList<T> a = flipNew(c);
+        c.clear();
+        c.addAll(a);
+        return c;
+    }
+
+    /**
+     * Reverse a collection and store the result in a new {@link ArrayList}.
+     * @param c Collection to reverse.
+     * @param <T> Type of the elements contained in the collection
+     * @return ArrayList containing a reversed set of the collection.
+     */
+    public static <T> ArrayList<T> flipNew(Collection<T> c){
+        ArrayList<T> a = new ArrayList<T>();
+        T[] t = (T[]) c.toArray();
+        for(int i = c.size(); i>0; --i) a.add(t[i-1]);
+        return a;
+    }
+
+    /**
+     * Check if a given array contains a value that fulfills the predicate.
+     * @param o Values to check
+     * @param p Predicate to use for checks.
+     * @return True of any of the values matched.
+     */
+    public static <T> boolean arrayContains(T[] o, PredicateCompat<T> p){ for(T o1 : o) if(p.apply(o1)) return true; return false; }
+
+    /**
+     * Create an {@link ArrayList} from a given set of values.
+     * @param t Values to create ArrayList from.
+     * @param <T> Type of the values to insert.
+     * @return An ArrayList containing the given set of values.
+     */
+    public static <T> ArrayList<T> fromArray(T[] t){ return setValues(new ArrayList<T>(), t); }
+
+    /**
+     * Overwrite values in {@link ArrayList} with the given value set.
+     * @param a ArrayList to replace values in
+     * @param t Values to insert
+     * @param <T> Type of the values being inserted
+     * @return The given ArrayList.
+     */
+    public static <T> ArrayList<T> setValues(ArrayList<T> a, T[] t){
+        try{
+            arrayListElements.set(a, t);
+            arrayListSize.setInt(a, t.length);
+        }
+        catch(NoSuchFieldError e){}
+        catch (IllegalAccessException e){}
+        return a;
+    }
+
+    /**
+     * Add an array to an {@link ArrayList} without having to loop.
+     * @param a ArrayList to add elements to
+     * @param values Elements to add
+     * @param <T> Type of the elements to add
+     * @return The given ArrayList
+     */
+    public static <T> ArrayList<T> addAll(ArrayList<T> a, T[] values){
+        try{
+            int size = arrayListSize.getInt(a);
+            T[] t = (T[]) arrayListElements.get(a);
+            T[] t1 = (T[]) Array.newInstance(values.getClass().getComponentType(), size+values.length);
+            System.arraycopy(t, 0, t1, 0, size);
+            System.arraycopy(values, 0, t1, t.length, values.length);
+            arrayListElements.set(a, t1);
+            arrayListSize.setInt(a, t1.length);
+        }
+        catch(NoSuchFieldError e){}
+        catch (IllegalAccessException e){}
+        return a;
+    }
+
+    /**
+     * Predicate interface to add compatibility with older versions of Java that don't include it
+     * @param <T> The type to evaluate
+     */
+    public interface PredicateCompat<T>{ boolean apply(T t); }
+}

src/net/tofvesson/collections/Optional.java

@@ -0,0 +1,52 @@
+package net.tofvesson.collections;
+
+/**
+ * Compat version of java.util.Optional
+ * @param <T>
+ */
+@SuppressWarnings("unchecked")
+public class Optional<T> {
+
+    private final T value;
+    private final boolean hasValue;
+
+    private Optional(T t){
+        value = nonNull(t);
+        hasValue = true;
+    }
+    private Optional(){
+        value = null;
+        hasValue = false;
+    }
+
+    protected T getValue(){ return value; }
+    public boolean isPresent(){ return hasValue; }
+    public T get(){ return valueOrThrow(getValue(), isPresent()); }
+
+    public T or(Supplier<? extends Optional<? extends T>> s){
+        nonNull(s);
+        if(isPresent()) return getValue();
+        Optional<? extends T> o = s.get();
+        return valueOrThrow(o.getValue(), o.isPresent());
+    }
+    public Optional<T> filter(Collections.PredicateCompat<T> p){
+        nonNull(p);
+        if(!isPresent()) return this;
+        return p.apply(getValue())?this:(Optional<T>) empty();
+    }
+
+
+    public static <T> Optional<T> empty(){ return new Optional<T>(); }
+    public static <T> Optional<T> of(T value){ return new Optional<T>(value); }
+    public static <T> Optional<T> ofNullable(T value){ return value==null?(Optional<T>) empty() : of(value); }
+
+    private static <T> T nonNull(T o){
+        if(o==null) throw new NullPointerException();
+        return o;
+    }
+
+    private static <T> T valueOrThrow(T t, boolean thr){
+        if(thr) throw new NullPointerException();
+        return nonNull(t);
+    }
+}

src/net/tofvesson/collections/Pair.java

@@ -0,0 +1,17 @@
+package net.tofvesson.collections;
+
+public final class Pair<K, V> {
+
+    private K key;
+    private V value;
+
+    public Pair(K key, V value){
+        this.key = key;
+        this.value = value;
+    }
+
+    public K getKey(){ return key; }
+    public V getValue(){ return value; }
+    public void setKey(K key){ this.key = key; }
+    public void setValue(V value){ this.value = value; }
+}

src/net/tofvesson/collections/ProxiedValue.java

@@ -0,0 +1,6 @@
+package net.tofvesson.collections;
+
+public final class ProxiedValue<T> {
+    public T value;
+    public ProxiedValue(T value){ this.value = value; }
+}

src/net/tofvesson/collections/Supplier.java

@@ -0,0 +1,9 @@
+package net.tofvesson.collections;
+
+/**
+ * Compat version of Java 8 java.util.function.Supplier
+ * @param <T>
+ */
+public interface Supplier<T> {
+    T get();
+}

src/net/tofvesson/reflection/Annotations.java

@@ -0,0 +1,19 @@
+package net.tofvesson.reflection;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Vector;
+
+public class Annotations {
+    public static List<Class<?>> getAllAnnotatedClasses(Class<? extends Annotation> annotation){
+        @SuppressWarnings("unchecked")
+        Vector<Class<?>> classes = (Vector<Class<?>>) SafeReflection.getValue(annotation.getClassLoader(), ClassLoader.class, "classes");
+        ArrayList<Class<?>> a = new ArrayList<Class<?>>();
+        if(classes==null) return a;
+        for(Class<?> c : classes)
+            if(c.isAnnotationPresent(annotation))
+                a.add(c);
+        return a;
+    }
+}

src/net/tofvesson/reflection/Classes.java

@@ -0,0 +1,98 @@
+package net.tofvesson.reflection;
+
+import jdk.internal.org.objectweb.asm.ClassWriter;
+import jdk.internal.org.objectweb.asm.MethodVisitor;
+import jdk.internal.org.objectweb.asm.Opcodes;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.security.ProtectionDomain;
+import java.util.Collection;
+import java.util.Random;
+import java.util.Vector;
+
+@SuppressWarnings("unchecked")
+public class Classes {
+    private static final Field classLoader_loadedClasses = SafeReflection.getField(ClassLoader.class, "classes");
+    private static final char[] randomSet =
+            {
+                    '1', '2', '3', '4', '5',
+                    '6', '7', '8', '9', '0',
+                    '$', '_', '£', '¤', 'a',
+                    'b', 'c', 'd', 'e', 'f',
+                    'g', 'h', 'i', 'j', 'k',
+                    'l', 'm', 'o', 'o', 'p',
+                    'q', 'r', 's', 't', 'u',
+                    'v', 'w', 'x', 'y', 'z',
+            };
+
+
+    public static String generateNewRandomClassName(ClassLoader loader, String prefix, String suffix, int minLength, int maxLength){
+        final StringBuilder rand = new StringBuilder();
+        final int range = maxLength-minLength;
+        if(range<=0) throw new IndexOutOfBoundsException("Range must be a positive, non-zero value!");
+
+        // Select an appropriate randomizer
+        Random r;
+        try{
+            r = (Random) SafeReflection.invokeStaticMethod(SafeReflection.getMethod(Class.forName("java.util.concurrent.ThreadLocalRandom"), "current"));
+        }catch (ClassNotFoundException e){
+            r = new Random(System.currentTimeMillis());
+        }
+        assert r != null;
+
+        // Generate name
+        do{
+            // Reset builder
+            rand.setLength(0);
+
+            // Generate a target length
+            int targetLength = (r.nextInt()%range) + minLength;
+            for(int i = 0; i<targetLength; ++i){
+                // Select and appropriate index
+                int rIdx = r.nextInt();
+                rand.append(randomSet[rand.length()==0?(rIdx%(randomSet.length-10))+10:rIdx%randomSet.length]);
+            }
+
+            // Continue until an appropriate name has been found
+        }while(classExists(loader, prefix+rand.toString()+suffix));
+
+        return prefix+rand.toString()+suffix;
+    }
+
+    public static boolean classExists(ClassLoader loader, String name){
+        if(
+                containsClassWithSignature(
+                        (Vector<Class<?>>) SafeReflection.getFieldValue(classLoader_loadedClasses, loader),
+                        name.replace('/', '.')
+                )) return true;
+        try {
+            loader.loadClass(name);
+            return true;
+        } catch (ClassNotFoundException e) { }
+        return false;
+    }
+
+    public static boolean containsClassWithSignature(Collection<Class<?>> collection, String signature){
+        for(Class<?> c : collection) if(c.getName().equals(signature)) return true;
+        return false;
+    }
+
+    public static Field reference(ClassLoader loader, Object value){
+        Class<?> synthetic = createClassWithStaticField(loader, generateNewRandomClassName(loader, "", "", 1, 64), "synth$value", Object.class);
+        SafeReflection.setValue(synthetic, "synth$value", value);
+        return SafeReflection.getField(synthetic, "synth$value");
+    }
+
+    public static Class<?> createClassWithStaticField(ClassLoader loader, String className, String fieldName, Class<?> classType){
+        ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
+        writer.visit(Opcodes.V1_5, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, className.replace('.', '/'), null, null, null);
+        writer.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, fieldName, classType.getName().replace('.', '/'), null, null).visitEnd();
+        writer.visitEnd();
+        byte[] bytecode = writer.toByteArray();
+        return (Class<?>) SafeReflection.invokeMethod(
+                loader,
+                SafeReflection.getMethod(ClassLoader.class, "defineClass", String.class, byte[].class, int.class, int.class, ProtectionDomain.class),
+                className.replace('.', '/'), bytecode, 0, bytecode.length, null
+        );
+    }
+}

src/net/tofvesson/reflection/Enums.java

@@ -0,0 +1,32 @@
+package net.tofvesson.reflection;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+public class Enums {
+    public static <T extends Enum<T>> boolean isFlagSet(int flags, T flag){
+        return (flags&flag.ordinal())!=0;
+    }
+    public static void asFlags(){
+        Class<?> c = SafeReflection.getCallerClass();
+        if(c==null || !c.isEnum()) return;
+        //noinspection unchecked
+        asFlags((Class<? extends Enum<?>>)c);
+    }
+    public static void asFlags(Class<? extends Enum<?>> type){
+        int increment = -1;
+        for(Field f : type.getDeclaredFields())
+            if(Modifier.isStatic(f.getModifiers()) && f.getType().equals(type))
+                try {
+                    SafeReflection.setValue(f.get(null), Enum.class, "ordinal", (int) Math.pow(2, ++increment));
+                }catch(Exception e){ e.printStackTrace(); }
+    }
+    public static void asOrdinals(Class<? extends Enum<?>> type){
+        int increment = -1;
+        for(Field f : type.getDeclaredFields())
+            if(Modifier.isStatic(f.getModifiers()) && f.getType().equals(type))
+                try {
+                    SafeReflection.setValue(f.get(null), Enum.class, "ordinal", ++increment);
+                }catch(Exception e){ e.printStackTrace(); }
+    }
+}

src/net/tofvesson/reflection/NotAutoBoxedException.java

@@ -1,4 +1,4 @@
-package com.tofvesson.reflection;
+package net.tofvesson.reflection;
 
 public class NotAutoBoxedException extends Exception {
     public NotAutoBoxedException(){ super(); }

src/net/tofvesson/reflection/SafeReflection.java

@@ -0,0 +1,726 @@
+package net.tofvesson.reflection;
+
+import net.tofvesson.collections.Optional;
+import sun.misc.Unsafe;
+import java.lang.reflect.*;
+import java.util.*;
+
+/**
+ * Safe tools to help simplify code when dealing with reflection.
+ */
+@SuppressWarnings({"unused", "SameParameterValue", "UnusedReturnValue", "ConstantConditions", "unchecked", "JavaReflectionMemberAccess"})
+public final class SafeReflection {
+
+    public static final ClassLoader rootClassLoader;
+    public static final Unsafe unsafe;
+    private static final Method newInstance, aConAccess;
+    private static final Field modifiers;
+    private static final String version;
+    private static final long override;
+    private static final boolean hasAConAccess;
+
+    static{
+        Unsafe u = null;
+        Method m = null, m1 = null;
+        Field f = null;
+        long l = 0;
+        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{
+            ClassLoader.getSystemClassLoader().loadClass("jdk.internal.reflect.DelegatingConstructorAccessorImpl");
+            ver="jdk.internal.reflect";
+        }catch(Throwable ignored){
+            ver="sun.reflect"; // If class can't be found in sun.reflect; we know that user is running Java 9+
+        }
+        try{
+            f = Unsafe.class.getDeclaredField("theUnsafe");
+            f.setAccessible(true);
+            u = (Unsafe) f.get(null);
+            try {
+                f = Field.class.getDeclaredField("modifiers");
+            }catch(Exception e){
+                try { f = Field.class.getDeclaredField("artField").getType().getDeclaredField("accessFlags"); }
+                catch(Exception ignored){ f = Field.class.getDeclaredField("accessFlags"); }
+            }
+            try {
+                l = u.objectFieldOffset(AccessibleObject.class.getDeclaredField("override")); // Most desktop versions of Java
+            }catch(Exception e){
+                l = u.objectFieldOffset(AccessibleObject.class.getDeclaredField("flag")); // God-damned Android
+            }
+            try {
+                m1 = Constructor.class.getDeclaredMethod("acquireConstructorAccessor");
+                u.putInt(m1, l, 1);
+                m = Class.forName(ver + ".DelegatingConstructorAccessorImpl").getDeclaredMethod("newInstance", Object[].class);
+                u.putInt(m, l, 1);
+            }catch(Exception e){
+                b = false;
+            }
+            u.putInt(f, l, 1);
+        }catch(Exception ignored){ ignored.printStackTrace(); }                                                         // Exception should never be thrown
+        unsafe = u;
+        newInstance = m;
+        aConAccess = m1;
+        override = l;
+        version = ver;
+        hasAConAccess = b;
+        modifiers = f;
+
+        ClassLoader cl = ClassLoader.getSystemClassLoader();
+        while(cl.getParent()!=null) cl = cl.getParent();
+        rootClassLoader = cl;
+    }
+
+    public static Object getFieldValue(Field f, Object o){
+        try{
+            return o==null?unsafe.getObject(f.getDeclaringClass(), unsafe.staticFieldOffset(f)):unsafe.getObject(o, unsafe.objectFieldOffset(f));
+        }catch(Exception e){ throw new RuntimeException(e); } // Fatal and unexpected error
+    }
+
+    /**
+     * Java 9-safe version of {@link Field#setAccessible(boolean)}
+     * @param f Field to set accessible
+     */
+    private static void setAccessible(AccessibleObject f){
+        unsafe.putInt(f, override, 1);
+    }
+
+    /**
+     * Gets the constructor from the defined class with the specified parameters.
+     * @param c Class to get constructor from.
+     * @param params Definition of parameters that the constructor requires.
+     * @param <T> Return-type of constructor.
+     * @return Constructor with specified parameter requirements or null if constructor doesn't exist.
+     */
+    public static <T> Constructor<T> getConstructor(Class<T> c, Class<?>... params){
+        try{
+            Constructor<T> c1 = c.getConstructor(params);
+            unsafe.putInt(c1, override, 1);
+            return c1;
+        }catch(Exception e){}
+        return null;
+    }
+
+    /**
+     * Gets the first constructor available from the given class.
+     * @param c Class to get constructor from.
+     * @param <T> Return-type of constructor.
+     * @return Constructor or null if something goes horribly wrong.
+     */
+    public static <T> Constructor<T> getFirstConstructor(Class<T> c){
+        try {
+            @SuppressWarnings("unchecked")
+            Constructor<T> c1 = (Constructor<T>) c.getDeclaredConstructors()[0];
+            unsafe.putInt(c1, override, 1);
+            return c1;
+        }catch (Exception e){}
+        return null;
+    }
+
+    /**
+     * Gets the method from the defined class by name and parameters.
+     * Method is accessible.
+     * @param c Class to find method in.
+     * @param name Name of method.
+     * @param params Parameters of method.
+     * @return Method or null if specified method wasn't found.
+     */
+    public static Method getMethod(Class<?> c, String name, Class<?>... params){
+        try{
+            Method m = c.getDeclaredMethod(name, params);
+            unsafe.putInt(m, override, 1);
+            return m;
+        }catch(Exception e){}
+        return null;
+    }
+
+    /**
+     * Attempts to invoke a supplied static method with the given parameters.
+     * @param m Method to invoke.
+     * @param params Parameters to supply to method.
+     * @return Return value of method or null if method is null.
+     */
+    public static Object invokeStaticMethod(Method m, Object... params){
+        try{ return invokeMethod(null, m, params); }catch(Exception e){}
+        return null;
+    }
+
+    /**
+     * Attempts to invoke a supplied method with the given parameters on the supplied object.
+     * @param inst Object to invoke method in.
+     * @param m Method to invoke.
+     * @param params Parameters to supply to method.
+     * @return Return value of method or null if method is null.
+     */
+    public static Object invokeMethod(Object inst, Method m, Object... params){
+        if(m!=null) unsafe.putInt(m, override, 1);
+        try{ return m!=null?m.invoke(inst, params):null; }catch(Exception e){}
+        return null;
+    }
+
+    /**
+     * Finds first available class with name given by array elements. (Useful when dealing with backward-compatibility and cross-version support).
+     * @param possibleNames Classes to look for (fully qualified class names).
+     * @return First existing class or null if no class was found.
+     */
+    public static Class<?> forNames(String... possibleNames){
+        for(String s : possibleNames) try{ return Class.forName(s); }catch(Exception e){}
+        return null;
+    }
+
+    /**
+     * Gets the first existing instance of a class with a given fully qualified name.
+     * @param possibleNames Names to search through.
+     * @return Position in the array referring to the first existing class.
+     */
+    public static int forNamesPos(String... possibleNames){
+        for(int i = 0; i<possibleNames.length; ++i) try{ Class.forName(possibleNames[i]); return i; }catch(Exception e){}
+        return -1;
+    }
+
+    /**
+     * Finds the first method available with the specified name from the class.
+     * Meant to be used in cases where a class only has one version of a method.
+     * Method is accessible.
+     * @param c Class to find method in.
+     * @param name Name of method.
+     * @return Method or null if no method with given name exists.
+     */
+    public static Method getFirstMethod(Class<?> c, String name){
+        try{
+            Method[] m = c.getDeclaredMethods();
+            for (Method aM : m) if(aM.getName().equals(name)){ unsafe.putInt(aM, override, 1); return aM;}
+        }catch(Exception e){}
+        return null;
+    }
+
+    /**
+     * Gets field object referring to field with specified name in defined class.
+     * @param c Class to find field in.
+     * @param name Name of field.
+     * @return Field or null if no field with specified name exists.
+     */
+    public static Field getField(Class<?> c, String name){
+        try{
+            Field f = c.getDeclaredField(name);
+            unsafe.putInt(f, override, 1);
+            return f;
+        }catch(Exception e){}
+        return null;
+    }
+
+    /**
+     * Gets the object stored in the field with the specified name in the class of the defined object.
+     * @param from Object to find object in.
+     * @param c Class to get field from (if <b>from</b> is null). This is used for static fields.
+     * @param name Name of field.
+     * @return Object or null if object is null or field doesn't exist.
+     */
+    public static Object getValue(Object from, Class<?> c, String name){
+        try{ return getFieldValue(getField(from!=null?from.getClass():c, name), from); }catch(Throwable ignored){}
+        for(Class<?> c1 : getSupers(from!=null?from.getClass():c)) try{ return getFieldValue(getField(c1, name), from); }catch(Exception e){} // Find first field with the given value
+        return null;
+    }
+
+    /**
+     * Gets the object stored in the field with the specified name in the class of the defined object.
+     * @param from Object to find object in.
+     * @param name Name of field.
+     * @return Object or null if object is null or field doesn't exist.
+     */
+    public static Object getValue(Object from, String name){ return getValue(from, null, name); }
+
+    /**
+     * Gets the object stored in the static field with the specified name in the class of the defined object.
+     * @param c Class to get field from (if <b>from</b> is null). This is used for static fields.
+     * @param name Name of field.
+     * @return Object or null if object is null or field doesn't exist.
+     */
+    public static Object getValue(Class<?> c, String name){ return getValue(null, c, name); }
+
+    /**
+     * Gets the object stored in the field with the specified name in the specified class.
+     * @param supr Superclass of object to find field in.
+     * @param o Object field is associated with.
+     * @param name Name of field
+     * @return Object or null if anything goes wrong.
+     */
+    public static Object getFieldObject(Class<?> supr, Object o, String name){ try{ return getFieldValue(getField(o.getClass(), name), o); }catch(Exception e){ return null; } }
+
+    /**
+     * Get a collection of all superclasses of supplied class.
+     * @param c Class to get superclasses of.
+     * @return List containing all superclasses.
+     */
+    public static List<Class<?>> getSupers(Class<?> c){
+        List<Class<?>> l = new ArrayList<Class<?>>();
+        insertSupers(l, c);
+        return l;
+    }
+
+    /**
+     * Internal method for inserting the immediate superclass of a supplied class in the supplied list.
+     * Only exists to reduce memory overhead when collecting supers without using a loop.
+     * @param l List of supers.
+     * @param c Class to get superclass of.
+     */
+    private static void insertSupers(List<Class<?>> l, Class<?> c){
+        if(c!=Object.class && !c.isPrimitive()){
+            l.add(c=c.getSuperclass());
+            insertSupers(l, c);
+        }
+    }
+
+    public static Optional<Object> lazyCall(Class<?> in, Object on, String name, Object... params){
+        for(Method m : in.getDeclaredMethods())
+            if(m.getName().equals(name))
+                try{
+                    SafeReflection.setAccessible(m);
+                    return Optional.ofNullable(m.invoke(on, (Object[]) params));
+                }
+                catch (IllegalArgumentException e){ }
+                catch (IllegalAccessException e) { throw new RuntimeException(e); }
+                catch (InvocationTargetException e) { throw new RuntimeException(e.getCause()); }
+        return Optional.empty();
+    }
+
+    /**
+     * Set field to specified value.
+     * <br><h1 style="text-align: center; color: red;">Please note:</h1>A JIT compiler may inline private final fields in methods which will prevent the actual value
+     * from changing at runtime.<br>This means that the value stored in the field <i>will</i> be changed, but any methods referring directly
+     * (not by java.lang.reflect.Field or sun.misc.Unsafe) to the field in the source will not be affected.
+     * This should only happen, though, if the field isn't set during runtime i.e. in a static block or constructor. This means that only fields that are truly constant
+     * like<br>"<i>public static final boolean b = false;</i>"<br>might be problematic.
+     * @param inv Object whose field to set the value of. Can be null.
+     * @param in Class to find field in
+     * @param name Name of field to modify.
+     * @param value Value to set the field to.
+     * @param vol Whether or not the operation should be volatile.
+     * @return True if setting value succeeded.
+     */
+    public static boolean setValue(Object inv, Class<?> in, String name, Object value, boolean vol){
+        try{
+            Field f = getField(in, name); // Search defined class first
+            getPutMethod(f.getType(), vol).invoke(unsafe, createUnsafePutParams(inv, f, value));
+            return true;
+        }catch(Exception e){ e.printStackTrace(); }
+        for(Class<?> c : getSupers(inv==null?in:inv.getClass())) // Hierarchical upward search
+            try{
+                Field f = getField(c, name);
+                getPutMethod(f.getType(), vol).invoke(unsafe, createUnsafePutParams(inv, f, value));
+                return true;
+            }catch(Exception e){ e.printStackTrace(); }
+        return false;
+    }
+
+    /**
+     * Set field to specified value.
+     * <br><h1 style="text-align: center; color: red;">Please note:</h1>A JIT compiler may inline private final fields in methods which will prevent the actual value
+     * from changing at runtime.<br>This means that the value stored in the field <i>will</i> be changed, but any methods referring directly
+     * (not by java.lang.reflect.Field or sun.misc.Unsafe) to the field in the source will not be affected.
+     * This should only happen, though, if the field isn't set during runtime i.e. in a static block or constructor. This means that only fields that are truly constant
+     * like<br>"<i>public static final boolean b = false;</i>"<br>might be problematic.
+     * @param inv Object whose field to set the value of. Can be null.
+     * @param in Class to find field in. (If inv is null)
+     * @param name Name of field to modify.
+     * @param value Value to set the field to.
+     * @return True if setting value succeeded.
+     */
+    public static boolean setValue(Object inv, Class<?> in, String name, Object value){ return setValue(inv, in, name, value, false); }
+
+    /**
+     * Set field to specified value as a volatile operation.
+     * <br><h1 style="text-align: center; color: red;">Please note:</h1>A JIT compiler may inline private final fields in methods which will prevent the actual value
+     * from changing at runtime.<br>This means that the value stored in the field <i>will</i> be changed, but any methods referring directly
+     * (not by java.lang.reflect.Field or sun.misc.Unsafe) to the field in the source will not be affected.
+     * This should only happen, though, if the field isn't set during runtime i.e. in a static block or constructor. This means that only fields that are truly constant
+     * like<br>"<i>public static final boolean b = false;</i>"<br>might be problematic.
+     * @param inv Object whose field to set the value of. Can be null.
+     * @param in Class to find field in. (If inv is null)
+     * @param name Name of field to modify.
+     * @param value Value to set the field to.
+     * @return True if setting value succeeded.
+     */
+    public static boolean setValueVolatile(Object inv, Class<?> in, String name, Object value){ return setValue(inv, in, name, value, true); }
+
+    /**
+     * Set field to specified value.
+     * <br><h1 style="text-align: center; color: red;">Please note:</h1>A JIT compiler may inline private final fields in methods which will prevent the actual value
+     * from changing at runtime.<br>This means that the value stored in the field <i>will</i> be changed, but any methods referring directly
+     * (not by java.lang.reflect.Field or sun.misc.Unsafe) to the field in the source will not be affected.
+     * This should only happen, though, if the field isn't set during runtime i.e. in a static block or constructor. This means that only fields that are truly constant
+     * like<br>"<i>public static final boolean b = false;</i>"<br>might be problematic.
+     * @param inv Object whose field to set the value of. Can be null.
+     * @param name Name of field to modify.
+     * @param value Value to set the field to.
+     * @return True if setting value succeeded.
+     */
+    public static boolean setValue(Object inv, String name, Object value){ return setValue(inv, inv.getClass(), name, value, false); }
+
+    /**
+     * Set field to specified value as a volatile operation.
+     * <br><h1 style="text-align: center; color: red;">Please note:</h1>A JIT compiler may inline private final fields in methods which will prevent the actual value
+     * from changing at runtime.<br>This means that the value stored in the field <i>will</i> be changed, but any methods referring directly
+     * (not by java.lang.reflect.Field or sun.misc.Unsafe) to the field in the source will not be affected.
+     * This should only happen, though, if the field isn't set during runtime i.e. in a static block or constructor. This means that only fields that are truly constant
+     * like<br>"<i>public static final boolean b = false;</i>"<br>might be problematic.
+     * @param inv Object whose field to set the value of. Can be null.
+     * @param name Name of field to modify.
+     * @param value Value to set the field to.
+     * @return True if setting value succeeded.
+     */
+    public static boolean setValueVolatile(Object inv, String name, Object value){ return setValue(inv, inv.getClass(), name, value, true); }
+
+    /**
+     * Set static field to specified value.
+     * <br><h1 style="text-align: center; color: red;">Please note:</h1>A JIT compiler may inline private final fields in methods which will prevent the actual value
+     * from changing at runtime.<br>This means that the value stored in the field <i>will</i> be changed, but any methods referring directly
+     * (not by java.lang.reflect.Field or sun.misc.Unsafe) to the field in the source will not be affected.
+     * This should only happen, though, if the field isn't set during runtime i.e. in a static block or constructor. This means that only fields that are truly constant
+     * like<br>"<i>public static final boolean b = false;</i>"<br>might be problematic.
+     * @param in Class to find field in.
+     * @param name Name of field to modify.
+     * @param value Value to set the field to.
+     * @return True if setting value succeeded.
+     */
+    public static boolean setValue(Class<?> in, String name, Object value){ return setValue(null, in, name, value, false); }
+
+    /**
+     * Set static field to specified value as a volatile operation.
+     * <br><h1 style="text-align: center; color: red;">Please note:</h1>A JIT compiler may inline private final fields in methods which will prevent the actual value
+     * from changing at runtime.<br>This means that the value stored in the field <i>will</i> be changed, but any methods referring directly
+     * (not by java.lang.reflect.Field or sun.misc.Unsafe) to the field in the source will not be affected.
+     * This should only happen, though, if the field isn't set during runtime i.e. in a static block or constructor. This means that only fields that are truly constant
+     * like<br>"<i>public static final boolean b = false;</i>"<br>might be problematic.
+     * @param in Class to find field in.
+     * @param name Name of field to modify.
+     * @param value Value to set the field to.
+     * @return True if setting value succeeded.
+     */
+    public static boolean setValueVolatile(Class<?> in, String name, Object value){ return setValue(null, in, name, value, true); }
+
+    /**
+     * Gets a reference to the enclosing class from a defined inner (nested) object.
+     * @param nested Object instance of a nested class.
+     * @return "this" reference to the outer class or null if class of object instance is static or isn't nested.
+     */
+    public static Object getEnclosingClassObjectRef(Object nested){
+        try{
+            Field f = nested.getClass().getDeclaredField("this$0");
+            //unsafe.putInt(f, override, 1);
+            return getFieldValue(f, nested);
+        }catch(Exception e){}
+        return null;
+    }
+
+    /**
+     * Checks whether a given class is an inner (nested) class.
+     * @param c Class to check.
+     * @return True if class is nested otherwise false.
+     */
+    public static boolean isNestedClass(Class<?> c){ return c.getEnclosingClass()!=null; }
+
+    /**
+     * Get class file based on class name.
+     * @param c Class to find file of.
+     * @return File if class file exists.
+     */
+    public static java.io.File getClassFile(Class c){ return new java.io.File(c.getResource(c.getSimpleName()+".class").getFile()); }
+
+    /**
+     * Allows you to create a completely custom Enum value. If the supplied value already exists, it will be returned.
+     * will not be created; the value of the existing one will be updated.
+     * @param clazz The class to attribute the new enum to.
+     * @param addToValuesArray Whether or not to update the internal, "immutable" values array with the new value (ignored if value already exists).
+     * @return A new/existing enum.
+     */
+    @SuppressWarnings("unchecked")
+    public static <T extends Enum<T>> T customEnum(Class<T> clazz, boolean addToValuesArray, String name, EnumDefinition def){
+        T u;
+        try {
+            if(def==null) def = new EnumDefinition();
+            // Get a reference to the static method values() and get values
+            Method v = clazz.getDeclaredMethod("values");
+            unsafe.putInt(v, override, 1);
+            T[] values = (T[]) v.invoke(null);
+
+            // Return object if it already exists
+            for(T u2 : values) if(u2.name().equals(name)) return u2;
+
+            // Generate enum parameter definition
+            Class[] paramList = new Class[def.params.size()+2];
+            paramList[0] = String.class; // Name
+            paramList[1] = int.class; // Ordinal
+            int iterator = paramList.length;
+            for(Class c : def.params.values()) paramList[--iterator] = c; // The stuff is reversed
+
+            // Get enum constructor (inherited from Enum.class)
+            Constructor<T> c = clazz.getDeclaredConstructor(paramList);
+            if(hasAConAccess) unsafe.putInt(c, override, 1);
+            else setAccessible(c);
+
+            Object[] parameters = new Object[def.params.size()+2];
+            parameters[0] = name;
+            parameters[1] = values.length;
+            iterator = parameters.length;
+            for(Object o : def.params.keySet()) parameters[--iterator] = o;
+
+            // Create new instance of enum with valid name and ordinal
+            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");
+            setAccessible(f);
+
+            // Rename the newly created enum to the requested name
+            f.set(u, name);
+
+            if(!addToValuesArray) return u; // Stops here if
+
+            // Get the current values field from Enum (a female dog to modify)
+            f = clazz.getDeclaredField("$VALUES");
+            setAccessible(f);
+            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
+
+            unsafe.putObject(clazz, unsafe.staticFieldOffset(f), $VALUES);
+        } catch (Exception wrongParams) { throw new RuntimeException(wrongParams); }
+        return u;
+    }
+
+    /**
+     * Create a new object without the hassle of having to construct it. WARNING: Not usually a good idea.
+     * @param clazz Class to instantiate.
+     * @return An object instance of the supplied class that hasn't been constructed.
+     * @throws InstantiationException Thrown if instantiating the object fails for some reason.
+     */
+    public static <T> T createNewObject(Class<T> clazz) throws InstantiationException{
+        //noinspection unchecked
+        return (T) unsafe.allocateInstance(clazz);
+    }
+
+
+    /**
+     * A definition for custom enum creation.
+     */
+    @SuppressWarnings("UnusedReturnValue")
+    public static final class EnumDefinition {
+        HashMap<Object, Class> params = new HashMap<Object, Class>(); // Assign a specific type to each parameter
+
+        public EnumDefinition(){}
+        public EnumDefinition(Object... params){ for(Object o : params) putObject(o); }
+
+        /**
+         * Put an object in the parameter list.
+         * @param value The parameter to supply. (Type is derived automatically)
+         * @return A reference to the EnumDefinition object this method was called on (for chaining).
+         */
+        public EnumDefinition putObject(Object value){
+            params.put(value, value.getClass());
+            return this;
+        }
+
+        /**
+         * Put a primitive value in the parameter list.
+         * @param autoBoxed An autoboxed version of the parameter. (For example putPrimitive(5) will automatically become Integer)
+         * @return A reference to the EnumDefinition object this method was called on (for chaining).
+         * @throws NotAutoBoxedException Thrown if a value expected to be autoboxed isn't autoboxed.
+         */
+        public EnumDefinition putPrimitive(Object autoBoxed) throws NotAutoBoxedException{
+            // All autoboxed versions of primitives have a reference to their boxed primitive
+            try {
+                params.put(autoBoxed, autoBoxed.getClass().getDeclaredField("value").getType());
+            }catch(Exception e){ throw new NotAutoBoxedException(); }
+            return this;
+        }
+
+        /**
+         * Safe wrapper of {@link #putPrimitive(Object)} for boolean.
+         * @param b Boolean parameter.
+         * @return A reference to the EnumDefinition object this method was called on (for chaining).
+         */
+        public EnumDefinition putInt(boolean b){
+            try { return putPrimitive(b);  } catch (NotAutoBoxedException e) { }
+            return this;
+        }
+
+        /**
+         * Safe wrapper of {@link #putPrimitive(Object)} for byte.
+         * @param b Byte parameter.
+         * @return A reference to the EnumDefinition object this method was called on (for chaining).
+         */
+        public EnumDefinition putByte(byte b){
+            try { return putPrimitive(b); } catch (NotAutoBoxedException e) { }
+            return this;
+        }
+
+        /**
+         * Safe wrapper of {@link #putPrimitive(Object)} for char.
+         * @param c Character parameter.
+         * @return A reference to the EnumDefinition object this method was called on (for chaining).
+         */
+        public EnumDefinition putChar(char c){
+            try { return putPrimitive(c); } catch (NotAutoBoxedException e) { }
+            return this;
+        }
+
+        /**
+         * Safe wrapper of {@link #putPrimitive(Object)} for short.
+         * @param s Short parameter.
+         * @return A reference to the EnumDefinition object this method was called on (for chaining).
+         */
+        public EnumDefinition putShort(short s){
+            try { return putPrimitive(s); } catch (NotAutoBoxedException e) { }
+            return this;
+        }
+
+        /**
+         * Safe wrapper of {@link #putPrimitive(Object)} for int.
+         * @param i Integer parameter.
+         * @return A reference to the EnumDefinition object this method was called on (for chaining).
+         */
+        public EnumDefinition putInt(int i){
+            try { return putPrimitive(i); } catch (NotAutoBoxedException e) { }
+            return this;
+        }
+
+        /**
+         * Safe wrapper of {@link #putPrimitive(Object)} for long.
+         * @param l Long parameter.
+         * @return A reference to the EnumDefinition object this method was called on (for chaining).
+         */
+        public EnumDefinition putLong(long l){
+            try { return putPrimitive(l); } catch (NotAutoBoxedException e) { }
+            return this;
+        }
+
+        /**
+         * Safe wrapper of {@link #putPrimitive(Object)} for float.
+         * @param f Floating point parameter.
+         * @return A reference to the EnumDefinition object this method was called on (for chaining).
+         */
+        public EnumDefinition putFloat(float f){
+            try { return putPrimitive(f); } catch (NotAutoBoxedException e) { }
+            return this;
+        }
+
+        /**
+         * Safe wrapper of {@link #putPrimitive(Object)} for double.
+         * @param d Double parameter.
+         * @return A reference to the EnumDefinition object this method was called on (for chaining).
+         */
+        public EnumDefinition putDouble(double d){
+            try { return putPrimitive(d); } catch (NotAutoBoxedException e) { }
+            return this;
+        }
+    }
+
+    /**
+     * Gets the class that called the method where this is called from.
+     * @return Class from which your method was called.
+     */
+    public static Class<?> getCallerClass(){
+        ArrayList<StackTraceElement> s = getStacktraceWithoutReflection();
+        try { return Class.forName(s.get(s.size()>3?3:s.size()-1).getClassName()); } catch (ClassNotFoundException e) { }
+        assert false:"Unreachable code reached";
+        return null;
+    }
+
+    /**
+     * Get a stacktrace without listing reflection methods.
+     * @return Ordered list of stacktrace without method reflections steps.
+     */
+    public static ArrayList<StackTraceElement> getStacktraceWithoutReflection(){
+        ArrayList<StackTraceElement> s = new ArrayList<StackTraceElement>();
+        StackTraceElement[] s1 = Thread.currentThread().getStackTrace();
+        Collections.addAll(s, s1);
+        s.remove(0);
+        Iterator<StackTraceElement> i = s.iterator();
+        String s2;
+        while(i.hasNext()){
+            if((s2=i.next().toString()).contains("java.lang.reflect.Method.invoke")
+                    || s2.contains(version+".NativeMethodAccessorImpl.invoke")
+                    || s2.contains(version+".DelegatingMethodAccessorImpl.invoke"))
+                i.remove();
+        }
+        return s;
+    }
+
+    private static Method getSetMethod(Class<?> c){
+        try {
+            Method m = Field.class.getDeclaredMethod(getSetMethodName(c), Object.class, isAutoBoxedClass(c)?unbox(c):c.isPrimitive()?c:Object.class);
+            setAccessible(m);
+            return m;
+        } catch (Exception e) { e.printStackTrace(); }
+        return null; // Not object version of primitive
+    }
+
+    public static String getSetMethodName(Class<?> c){
+        try {
+            String s;
+            boolean b;
+            Field f = null;
+            try{
+                f = c.getDeclaredField("value");
+            }catch(Exception e){}
+            if(f!=null) setAccessible(f);
+            return"set"+
+                    (f!=null && Number.class.isAssignableFrom(f.getType()) && f.getType().isPrimitive()?
+                            (s=f.getType().getSimpleName()).replaceFirst(s.charAt(0)+"", Character.toUpperCase(s.charAt(0))+""):
+                            c.isPrimitive()?(s=c.getSimpleName()).replaceFirst(s.charAt(0)+"", Character.toUpperCase(s.charAt(0))+"")
+                                    :"");
+        } catch (Exception e) { e.printStackTrace(); }
+        return null; // Not object version of primitive
+    }
+
+    public static boolean isAutoBoxedClass(final Class<?> c){
+        return Number.class.isAssignableFrom(c) && net.tofvesson.collections.Collections.arrayContains(c.getDeclaredFields(),
+                new net.tofvesson.collections.Collections.PredicateCompat() {
+                    public boolean apply(Object o) {
+                        return ((Field) o).getName().equals("value") && box(((Field) o).getType())==c;
+                    }
+                });
+    }
+
+    public static Method getPutMethod(Class<?> c, boolean vol){
+        try{
+            Method m = Unsafe.class.getDeclaredMethod(
+                    getSetMethodName(c).replaceFirst("set", "put") + (isAutoBoxedClass(c)||c.isPrimitive()?"":"Object")+(vol?"Volatile":""),
+                    Object.class,
+                    long.class,
+                    c.isPrimitive()?c:Object.class
+            );
+            setAccessible(m);
+            return m;
+        }catch(Exception ignored){ ignored.printStackTrace(); }
+        return null; // Something went wrong...
+    }
+
+    public static Object[] createUnsafePutParams(Object invokee, Field field, Object value){
+        return new Object[]{ invokee==null?field.getDeclaringClass():invokee, invokee==null?unsafe.staticFieldOffset(field):unsafe.objectFieldOffset(field), value };
+    }
+
+    public static Class<?> box(Class<?> c){
+        if(!c.isPrimitive()) return c;
+        if(c==int.class) return Integer.class;
+        if(c==char.class) return Character.class;
+        if(c==byte.class) return Byte.class;
+        if(c==float.class) return Float.class;
+        if(c==long.class) return Long.class;
+        if(c==boolean.class) return Boolean.class;
+        return Double.class;
+    }
+
+    public static Class<?> unbox(Class<?> c){
+        if(c.isPrimitive()) return c;
+        if(c==Integer.class) return int.class;
+        if(c==Character.class) return char.class;
+        if(c==Byte.class) return byte.class;
+        if(c==Float.class) return float.class;
+        if(c==Long.class) return long.class;
+        if(c==Boolean.class) return boolean.class;
+        return double.class;
+    }
+}

src/net/tofvesson/stream/Tag.java

@@ -1,4 +1,4 @@
-package com.tofvesson.logging;
+package net.tofvesson.stream;
 
 public interface Tag {
     String apply(String output);

src/net/tofvesson/stream/TagStream.java

@@ -1,4 +1,4 @@
-package com.tofvesson.logging;
+package net.tofvesson.stream;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -9,7 +9,7 @@ import java.util.List;
 public class TagStream extends PrintStream {
 
     private final OutputStream node;
-    private List<Tag> tags = new ArrayList<>();
+    private List<Tag> tags = new ArrayList<Tag>();
 
     public TagStream(PrintStream node){
         super(node);