Major Update

- Fixed Iterator and added remove()
- Added support for dispatching batch Async operations
- Rewrote lots of code to support lower language levels (java 5+)

.idea/misc.xml

@@ -13,7 +13,7 @@
     <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" assert-keyword="true" jdk-15="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

src/com/tofvesson/async/Async.java

@@ -32,16 +32,18 @@ public class Async<T> {
      * @param millis Milliseconds to wait.
      * @param micros Microseconds to wait.
      */
-    private Async(long millis, int micros){
+    private Async(final long millis, final int micros){
-        task = new Thread(()->{
+        task = new Thread(new Runnable(){
-            new ThreadLocal<Async>().set(Async.this);
+            public void run(){
-            try {
+                new ThreadLocal<Async>().set(Async.this);
-                Thread.sleep(millis, micros);
+                try {
-                this.complete = true;
+                    Thread.sleep(millis, micros);
-            } catch (InterruptedException t1) {
+                    Async.this.complete = true;
-                if(!this.failed) {
+                } catch (InterruptedException t1) {
-                    this.failed = true;
+                    if(!Async.this.failed) {
-                    this.t=t1;
+                        Async.this.failed = true;
+                        Async.this.t=t1;
+                    }
                 }
             }
         });
@@ -53,17 +55,19 @@ public class Async<T> {
      * Create Async process with runnable.
      * @param r Runnable to execute as new task.
      */
-    public Async(Runnable r){
+    public Async(final Runnable r){
-        task = new Thread(()->{
+        task = new Thread(new Runnable(){
-            try {
+            public void run(){
-                new ThreadLocal<Async>()
+                try {
-                        .set(Async.this);           // Store ThreadLocal reference to Async object
+                    new ThreadLocal<Async>()
-                r.run();                            // Execute runnable
+                            .set(Async.this);           // Store ThreadLocal reference to Async object
-                complete = true;                    // Notify all threads who are checking
+                    r.run();                            // Execute runnable
-            } catch (Throwable t1) {                // Prepare for failure
+                    complete = true;                    // Notify all threads who are checking
-                if(!failed) {                       // Checks if task was canceled
+                } catch (Throwable t1) {                // Prepare for failure
-                    failed = true;                  // Notifies all threads that task failed
+                    if(!failed) {                       // Checks if task was canceled
-                    t=t1;                           // Makes error accessible to be thrown
+                        failed = true;                  // Notifies all threads that task failed
+                        t=t1;                           // Makes error accessible to be thrown
+                    }
                 }
             }
         });                                         // Execute thread with runnable
@@ -80,15 +84,17 @@ public class Async<T> {
      */
     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
+        task = new Thread(new Runnable(){ // Create a new thread
-            try {
+            public void run(){
-                new ThreadLocal<Async>().set(Async.this);
+                try {
-                ret = (T) method.invoke(o, params); // Invoke given method
+                    new ThreadLocal<Async>().set(Async.this);
-                complete = true;                    // Notify all threads who are checking
+                    ret = (T) method.invoke(o, params); // Invoke given method
-            } catch (Throwable t1) {                // Prepare for failure
+                    complete = true;                    // Notify all threads who are checking
-                if(!failed) {                       // Checks if task was canceled
+                } catch (Throwable t1) {                // Prepare for failure
-                    failed = true;                  // Notifies all threads that task failed
+                    if(!failed) {                       // Checks if task was canceled
-                    t=t1;                           // Makes error accessible to be thrown
+                        failed = true;                  // Notifies all threads that task failed
+                        t=t1;                           // Makes error accessible to be thrown
+                    }
                 }
             }
         });
@@ -123,15 +129,17 @@ public class Async<T> {
      */
     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
+        task = new Thread(new Runnable() {               // Creates a new thread for asynchronous execution
-            new ThreadLocal<Async>().set(Async.this);
+            public void run(){
-            try {
+                new ThreadLocal<Async>().set(Async.this);
-                ret = c.newInstance(params);    // Create a new instance: invoke "<init>" method
+                try {
-                complete = true;                // Notify all threads that async is finished
+                    ret = c.newInstance(params);    // Create a new instance: invoke "<init>" method
-            } catch (Throwable t1) {            // Handle crash
+                    complete = true;                // Notify all threads that async is finished
-                if(!failed) {                   // Ensure that crash wasn't called by cancel()
+                } catch (Throwable t1) {            // Handle crash
-                    failed = true;              // Notify all threads that error has been encountered
+                    if(!failed) {                   // Ensure that crash wasn't called by cancel()
-                    t=t1;                       // Make throwable accessible to be thrown in caller thread
+                        failed = true;              // Notify all threads that error has been encountered
+                        t=t1;                       // Make throwable accessible to be thrown in caller thread
+                    }
                 }
             }
         });

src/com/tofvesson/async/AsyncBatch.java

@@ -0,0 +1,27 @@
+package com.tofvesson.async;
+
+import java.util.HashMap;
+
+/**
+ * Creates a batch of similar async instructions.
+ */
+@SuppressWarnings("unused")
+public class AsyncBatch {
+
+    private final HashMap<Integer, Async> all = new HashMap<Integer, Async>();
+
+    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(new Runnable() { public void run() { r.run(idx); } })); }
+    public HashMap<Integer, Async> getAll(){ return all; }
+    public HashMap<Integer, Object> awaitAll(){
+        HashMap<Integer, Object> al = new HashMap<Integer, Object>();
+        for(Integer a : all.keySet())
+            al.put(a, all.get(a).await());
+        return al;
+    }
+    public int getFinished(){ int i = 0; for(Async 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 a : all.values()) a.cancel(); }
+}

src/com/tofvesson/async/BatchRunnable.java

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

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

@@ -20,7 +20,6 @@ class EcoAsync$1 implements Runnable{
         this.val$params = val$params;
     }
 
-    @Override
     public void run() {
         synchronized (this) {
             try {

src/com/tofvesson/async/WorkerThread.java

@@ -1,12 +1,11 @@
 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.
@@ -14,9 +13,9 @@ import java.util.concurrent.ThreadLocalRandom;
  */
 public class WorkerThread extends Thread {
 
-    List<Long> ids = new ArrayList<>();
+    List<Long> ids = new ArrayList<Long>();
     volatile Queue<Pair<Long, Pair<Method, Pair<Object, Object>>>> queue;
-    volatile Map<Long, Object> output = new HashMap<>();
+    volatile Map<Long, Object> output = new HashMap<Long, Object>();
     volatile boolean alive=true, completed=false;
 
     /**
@@ -28,25 +27,27 @@ public class WorkerThread extends Thread {
         try{
             Field f = Thread.class.getDeclaredField("target");
             f.setAccessible(true);
-            f.set(this, (Runnable) ()->
+            f.set(this, new Runnable()
             {
-                synchronized (Thread.currentThread()) {
+                public void run(){
-                    while (alive) {
+                    synchronized (Thread.currentThread()) {
-                        if (queue.size() != 0) {
+                        while (alive) {
-                            Pair<Long, Pair<Method, Pair<Object, Object>>> q = queue.poll();
+                            if (queue.size() != 0) {
-                            Pair<Method, Pair<Object, Object>> instr = q.getValue();
+                                Pair<Long, Pair<Method, Pair<Object, Object>>> q = queue.poll();
-                            try {
+                                Pair<Method, Pair<Object, Object>> instr = q.getValue();
-                                output.put(q.getKey(), instr.getKey().invoke(instr.getValue().getKey(), (Object[]) instr.getValue().getValue()));
+                                try {
-                                completed = true;
+                                    output.put(q.getKey(), instr.getKey().invoke(instr.getValue().getKey(), (Object[]) instr.getValue().getValue()));
-                            } catch (IllegalAccessException | InvocationTargetException e) {
+                                    completed = true;
-                                e.printStackTrace();
+                                } catch (Exception e) {
+                                    e.printStackTrace();
+                                }
                             }
                         }
                     }
                 }
             });
         }catch(Exception e){}
-        queue = new ArrayBlockingQueue<>(queueSize);
+        queue = new ArrayBlockingQueue<Pair<Long, Pair<Method, Pair<Object, Object>>>>(queueSize);
     }
 
     /**
@@ -59,8 +60,9 @@ public class WorkerThread extends Thread {
     public long push(Object invokeOn, Method m, Object... params){
         m.setAccessible(true);
         long id;
-        do{ id = ThreadLocalRandom.current().nextLong(); }while(ids.contains(id));
+        Random r = new Random();
-        queue.add(new Pair<>(id, new Pair<>(m, new Pair<>(invokeOn, params))));
+        do{ id = r.nextLong(); }while(ids.contains(id));
+        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;
     }

src/com/tofvesson/collections/ShiftingList.java

@@ -3,7 +3,6 @@ package com.tofvesson.collections;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
-import java.util.stream.Collectors;
 
 @SuppressWarnings({"unchecked", "ReturnOfInnerClass", "unused"})
 public class ShiftingList<E> implements List<E> {
@@ -42,24 +41,20 @@ public class ShiftingList<E> implements List<E> {
         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);
@@ -67,13 +62,11 @@ public class ShiftingList<E> implements List<E> {
         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);
@@ -82,30 +75,27 @@ public class ShiftingList<E> implements List<E> {
         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) {
+                --pop;
-                    shift();
+                shift();
-                    adaptLoad(-1);
+                if(pop<entries.length*load) adaptLoad();
-                }
                 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));
+        ArrayList<? super E> l = new ArrayList<E>();
+        for(E e : c) if(!contains(e)) l.add(e);
         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);
@@ -113,11 +103,11 @@ public class ShiftingList<E> implements List<E> {
         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));
+        ArrayList<? super E> l = new ArrayList<E>();
+        for(E e : c) if(!contains(e)) l.add(e);
         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();
@@ -127,7 +117,6 @@ public class ShiftingList<E> implements List<E> {
         return true;
     }
 
-    @Override
     public boolean retainAll(Collection<?> c) {
         int removed = 0;
         for(int i = 0; i<pop; ++i)
@@ -141,7 +130,6 @@ public class ShiftingList<E> implements List<E> {
         return true;
     }
 
-    @Override
     public boolean removeAll(Collection<?> c) {
         int removed = 0;
         for(int i = 0; i<pop; ++i)
@@ -155,13 +143,11 @@ public class ShiftingList<E> implements List<E> {
         return true;
     }
 
-    @Override
     public void clear() {
         pop = 0;
         entries = new Object[1];
     }
 
-    @Override
     public int indexOf(Object o){
         for(int i = 0; i<pop; ++i)
             if(entries[i].equals(o)) return i;
@@ -215,13 +201,11 @@ public class ShiftingList<E> implements List<E> {
         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);
@@ -229,7 +213,6 @@ public class ShiftingList<E> implements List<E> {
         return e;
     }
 
-    @Override
     public void add(int index, E element) {
         if(index<0 || contains(element)) return;
         Object o = element==null?empty:element;
@@ -243,7 +226,6 @@ public class ShiftingList<E> implements List<E> {
         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];
@@ -253,7 +235,6 @@ public class ShiftingList<E> implements List<E> {
         return e;
     }
 
-    @Override
     public int lastIndexOf(Object o) {
         for(int i = pop; i>0; --i)
             if(o.equals(entries[i]))
@@ -261,22 +242,18 @@ public class ShiftingList<E> implements List<E> {
         return -1;
     }
 
-    @Override
+    public Iterator<E> iterator(){ return new Iterator<E>(this); }
-    public Iterator<E> iterator(){ return new Iterator<>(pop, entries); }
 
-    @Override
+    public ListIterator<E> listIterator(){ return new ListIterator<E>(this); }
-    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);
+        return new ListIterator<E>(this, index);
     }
 
-    @Override
     public List<E> subList(int fromIndex, int toIndex) {
-        if(fromIndex<0 || fromIndex>=toIndex || fromIndex>pop || toIndex>pop) return new ArrayList<>();
+        if(fromIndex<0 || fromIndex>=toIndex || fromIndex>pop || toIndex>pop) return new ArrayList<E>();
-        ShiftingList<E> l = new ShiftingList<>(maxSize);
+        ShiftingList<E> l = new ShiftingList<E>(maxSize);
         for(int i = toIndex-1; i>fromIndex; --i) l.add(entries[i]==empty?null:(E)entries[i]);
         return l;
     }
@@ -287,11 +264,16 @@ public class ShiftingList<E> implements List<E> {
      */
     public static class Iterator<V> implements java.util.Iterator<V>{
         protected int counter = 0;
-        private final int pop;
+        private final ShiftingList ref;
-        private final Object[] entries;
+        private Object previous;
-        public Iterator(int pop, Object[] entries){  this.pop = pop; this.entries = entries; }
+        public Iterator(ShiftingList ref){ this.ref = ref; }
-        @Override public boolean hasNext() { return counter<pop; }
+        public boolean hasNext() { return counter<ref.pop; }
-        @Override public V next() { return entries[counter++]==empty?null:(V)entries[counter-1]; }
+        public V next() {
+            return (V)(previous=ref.entries[counter++]==empty?
+                    null:
+                    ref.entries[counter-1]);
+        }
+        public void remove(){ if(counter!=0){ ref.remove(previous); --counter; } }
     }
 
     /**
@@ -307,14 +289,14 @@ public class ShiftingList<E> implements List<E> {
         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; }
+        public boolean hasNext() { return counter<pop; }
-        @Override public V next() { opNxt = true; return (V)(pEl=entries[counter++]==empty?null:entries[counter-1]); }
+        public V next() { opNxt = true; return (V)(pEl=entries[counter++]==empty?null:entries[counter-1]); }
-        @Override public boolean hasPrevious() { return counter>0&&pop!=0; }
+        public boolean hasPrevious() { return counter>0&&pop!=0; }
-        @Override public V previous() { opNxt = false; return (V)(pEl=entries[--counter]==empty?null:entries[counter]); }
+        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; }
+        public int nextIndex() { return counter+1<pop?counter+1:pop; }
-        @Override public int previousIndex() { return counter!=0?counter-1:0; }
+        public int previousIndex() { return counter!=0?counter-1:0; }
-        @Override public void remove() { list.remove(counter-(opNxt?0:1)); }
+        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; }
+        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); }
+        public void add(V v) { list.add(counter, v); }
     }
 }

src/com/tofvesson/logging/TagStream.java

@@ -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);

src/com/tofvesson/reflection/SafeReflection.java

@@ -1,9 +1,10 @@
 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.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.HashMap;
@@ -281,7 +282,7 @@ public class SafeReflection {
      * A definition for custom enum creation.
      */
     public static class EnumDefinition {
-        HashMap<Object, Class> params = new HashMap<>(); // Assign a specific type to each parameter
+        HashMap<Object, Class> params = new HashMap<Object, Class>(); // Assign a specific type to each parameter
 
         /**
          * Put an object in the parameter list.