Major fix

- Fixed fatal but with foreach on ShiftingList

.idea/artifacts/libRefTools_jar.xml

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

src/com/tofvesson/collections/ShiftingList.java

@@ -1,6 +1,7 @@
 package com.tofvesson.collections;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 
@@ -188,6 +189,7 @@ public class ShiftingList<E> implements List<E> {
         }
         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;
     }
 
     /**
@@ -205,7 +207,7 @@ public class ShiftingList<E> implements List<E> {
     }
 
     protected void preparePopulate(int accountFor){
-        if(accountFor>entries.length) adaptLoad(accountFor);                                                            // If new elements exceed limit, adapt load
+        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
     }
@@ -286,7 +288,7 @@ public class ShiftingList<E> implements List<E> {
         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]; }
+        @Override public V next() { return entries[counter++]==empty?null:(V)entries[counter-1]; }
     }
 
     /**

src/com/tofvesson/reflection/SafeReflection.java

@@ -1,5 +1,6 @@
 package com.tofvesson.reflection;
 
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 
@@ -8,6 +9,38 @@ import java.lang.reflect.Method;
  */
 @SuppressWarnings("unused")
 public class SafeReflection {
+
+    /**
+     * 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 {
+            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.