Minor update

- Started creating a new revision of the ShiftingList
  - Populated entries are shifted to the end of the array
  - Shifting is done in blocks
  - Referring to indexes is more secure now
- Added final collection helper class
- Started adding ShiftingMap based on ShiftingList
- Made SafeReflection helper class final

src/com/tofvesson/collections/Collections.java

@@ -0,0 +1,14 @@
+package com.tofvesson.collections;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+@SuppressWarnings("unchecked")
+public final class Collections {
+    public static <T> ArrayList<T> flip(Collection<T> c){
+        ArrayList<T> a = new ArrayList<T>();
+        T[] t = (T[]) c.toArray();
+        for(int i = c.size()-1; i>0; --i) a.add(t[i]);
+        return a;
+    }
+}

src/com/tofvesson/collections/Empty.java

@@ -1,3 +1,8 @@
 package com.tofvesson.collections;
 
-final class Empty {}
+final class Empty {
+    /**
+     * Internal reference to reserved, unpopulated entries in collections.
+     */
+    static final Empty empty = new Empty();
+}

src/com/tofvesson/collections/NShiftingList.java

@@ -0,0 +1,220 @@
+package com.tofvesson.collections;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+@SuppressWarnings("ALL")
+public class NShiftingList<E> implements List<E> {
+
+    private final float load;
+    private final int maxSize;
+    private int pop = 0;
+    private Object[] entries = new Object[1];
+
+
+
+    public NShiftingList(int maxSize, float load){ this.maxSize = maxSize; this.load = load; }
+    public NShiftingList(int maxSize){ this(maxSize, 0.75f); }
+
+
+
+    public int size() { return pop; }
+    public boolean isEmpty() { return pop==0; }
+
+    public boolean contains(Object o) {
+        if(o==null) return false;
+        for(int i = entries.length-1; i>entries.length-pop; --i) if(o==entries[i]) return true;
+        return false;
+    }
+
+    public Iterator<E> iterator() {
+        //TODO: Implement
+        return null;
+    }
+
+    public Object[] toArray() {
+        Object[] o = new Object[pop];
+        System.arraycopy(entries, entries.length-pop, o, 0, pop);
+        return o;
+    }
+
+    public <T> T[] toArray(T[] a) {
+        System.arraycopy(entries, entries.length-pop, a, 0, pop>a.length?a.length:pop);
+        return a;
+    }
+
+    public boolean add(E e) {
+        if(entries.length==pop) preparePopulate(1);
+        entries[entries.length-(pop=pop==maxSize?maxSize:pop+1)] = e;
+        return true;
+    }
+
+    public boolean remove(Object o) {
+        for(int i = entries.length-1; i>entries.length-pop; --i) if(entries[i]==o){ entries[i] = null; shift(); return true; }
+        return false;
+    }
+
+    public boolean containsAll(Collection<?> c) {
+        for(Object o : c)
+            for(int i = entries.length-1; i>entries.length-pop; --i)
+                if(entries[i]==o) break;
+                else if(i==entries.length-pop+1) return false;
+        return true;
+    }
+
+    public boolean addAll(Collection<? extends E> c) {
+        preparePopulate(c.size());
+        return false;
+    }
+
+    public boolean addAll(int index, Collection<? extends E> c) {
+        //TODO: Implement
+        return false;
+    }
+
+    public boolean removeAll(Collection<?> c) {
+        //TODO: Implement
+        return false;
+    }
+
+    public boolean retainAll(Collection<?> c) {
+        //TODO: Implement
+        return false;
+    }
+
+    public void clear() {
+        //TODO: Implement
+
+    }
+
+    public E get(int index) {
+        if(index>=pop || index<0) throw new IndexOutOfBoundsException();                                                // Ensure that user has defined a valid index
+        return (E) entries[entries.length-pop+index];
+    }
+
+    public E set(int index, E element) {
+        if(index>=pop || index<0) throw new IndexOutOfBoundsException();                                                // Ensure that user has defined a valid index
+        E e = (E) entries[entries.length-pop+index];
+        entries[entries.length-pop+index] = element;
+        if(element==null) adaptLoad(0);                                                                      // Handle load adaptation
+        return e;
+    }
+
+    public void add(int index, E element) {
+        //TODO: Implement
+    }
+
+    public E remove(int index) {
+        //TODO: Implement
+        return null;
+    }
+
+    public int indexOf(Object o) {
+        //TODO: Implement
+        return 0;
+    }
+
+    public int lastIndexOf(Object o) {
+        //TODO: Implement
+        return 0;
+    }
+
+    public ListIterator<E> listIterator() {
+        //TODO: Implement
+        return null;
+    }
+
+    public ListIterator<E> listIterator(int index) {
+        //TODO: Implement
+        return null;
+    }
+
+    public List<E> subList(int fromIndex, int toIndex) {
+        //TODO: Implement
+        return null;
+    }
+
+    /**
+     * Shift populated to replace unpopulated (removed) entries
+     */
+    protected void shift(){
+        /*
+        Reads three data points:
+        1: starting position of a block of populated entries,
+        2: ending position,
+        3: starting position of next block
+
+                     1        2           3
+                     ▼       ▼          ▼
+        [U, U, U, U, P, P, P, U, U, U, U, P, P, U, U, P]         Pass 1
+                     4        7           11
+
+
+                                 1              2     3
+                                 ▼             ▼    ▼
+        [U, U, U, U, U, U, U, U, P, P, P, P, P, U, U, P]         Pass 2
+                                 8              13    15
+
+
+                                       1
+                                       ▼
+        [U, U, U, U, U, U, U, U, U, U, P, P, P, P, P, P]         Pass 3 ("2" can't be placed because end was found)
+
+         */
+        for(int i = 0; i<entries.length-1; ++i)
+            if(entries[i]!=null)
+                for(int j = i; j<entries.length; ++j)
+                    if(entries[j]==null) {
+                        for (int k = j; k < entries.length + 1; ++k)
+                            if (k < entries.length && entries[k] != null) {
+                                System.arraycopy(entries, i, entries, k - j + i, j - i);
+                                break;
+                            }else if (k == entries.length) System.arraycopy(entries, i, entries, k - j + i, j - i);
+                        break;
+                    }else if(j==entries.length-1) return;                                                               // No more unpopulated entries found
+    }
+
+    /**
+     * Array load adaptation.
+     */
+    protected void adaptLoad(int accountFor){
+        if(!checkShifted()) shift(); // Ensure that array is properly shifted before adapting load.
+        adaptLoad0(accountFor);
+    }
+
+    /**
+     * Internal array load adaptation if it is known for a fact that array already has been shifted.
+     */
+    private void adaptLoad0(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, entries.length-pop, o, o.length-pop, pop);
+        entries = o;
+    }
+
+    /**
+     * Check if populated space contain unpopulated entries.
+     * If there are unpopulated entries, it means that array isn't propperly shifted.
+     * @return True if values are shifted, false if there exist unpopulated entries in the populated space.
+     */
+    protected boolean checkShifted(){
+        for(int i = entries.length-1; i>entries.length-pop; --i) if(entries[i]==null) return false; // Check if any unpopulated values exist in the populated range
+        return true;
+    }
+
+    /**
+     * Prepares entry array for population of new values.
+     * @param accountFor New values to account for (in pop variable hasn't been updated).
+     */
+    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
+        if(accountFor+pop>entries.length) System.arraycopy(entries, entries.length-pop, entries,
+                entries.length-pop+accountFor, pop+accountFor-entries.length);                          // Shift old values (possible deletion)
+    }
+}

src/com/tofvesson/collections/ShiftingList.java

@@ -3,6 +3,7 @@ package com.tofvesson.collections;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import static com.tofvesson.collections.Empty.empty;
 
 @SuppressWarnings({"unchecked", "ReturnOfInnerClass", "unused"})
 public class ShiftingList<E> implements List<E> {
@@ -19,26 +20,21 @@ public class ShiftingList<E> implements List<E> {
     /**
      * Maximum size of set.
      */
-    final int maxSize;
+    public final int maxSize;
 
     /**
      * Load factor used when calculating how to resize array.
      */
-    double load;
+    protected final float load;
 
-    /**
+    public ShiftingList(int maxSize, float 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;
+        this.load = load>0.99||load<0.1?0.75f:load;
         entries = new Object[1];
     }
 
     public ShiftingList(int maxSize){
-        this(maxSize, 0.75);
+        this(maxSize, 0.75f);
     }
 
     public int size() {
@@ -173,7 +169,7 @@ public class ShiftingList<E> implements List<E> {
             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
+        System.arraycopy(entries, 0, o, 0, Math.min(o.length, entries.length));                          // Move as many entries as possible
         entries = o;
     }
 
@@ -198,7 +194,7 @@ public class ShiftingList<E> implements List<E> {
     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
+        System.arraycopy(entries, 0, entries, accountFor, entries.length-accountFor);                     // Shift array elements to account for new elements
     }
 
     public E get(int i){

src/com/tofvesson/collections/ShiftingMap.java

@@ -0,0 +1,63 @@
+package com.tofvesson.collections;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+@SuppressWarnings("ALL")
+/**
+ * Map that shifts (and deletes overflowing values) as new values are added.
+ * Does not support null keys.
+ */
+public class ShiftingMap<K, V> implements Map<K, V> {
+
+    private final ShiftingList<Pair<K, V>> entries;
+
+    public ShiftingMap(int maxSize, float load){ entries = new ShiftingList<Pair<K, V>>(maxSize, load); }
+    public ShiftingMap(int maxSize){ this(maxSize, 0.75f); }
+
+    public int size() { return entries.pop; }
+
+    public boolean isEmpty() { return entries.pop==0; }
+
+    public boolean containsKey(Object key) {
+
+        return false;
+    }
+
+    public boolean containsValue(Object value) {
+        return false;
+    }
+
+    public V get(Object key) {
+        return null;
+    }
+
+    public V put(K key, V value) {
+        return null;
+    }
+
+    public V remove(Object key) {
+        return null;
+    }
+
+    public void putAll(Map<? extends K, ? extends V> m) {
+
+    }
+
+    public void clear() {
+
+    }
+
+    public Set<K> keySet() {
+        return null;
+    }
+
+    public Collection<V> values() {
+        return null;
+    }
+
+    public Set<Entry<K, V>> entrySet() {
+        return null;
+    }
+}

src/com/tofvesson/reflection/SafeReflection.java

@@ -12,12 +12,13 @@ import java.util.Iterator;
  * Safe tools to help simplify code when dealing with reflection.
  */
 @SuppressWarnings("ALL")
-public class SafeReflection {
+public final class SafeReflection {
 
 
     private static final Unsafe unsafe;
     private static final Method newInstance, aConAccess, gFieldAccess, fieldAccess;
     private static final Field ro;
+    private static final String version;
     private static final long override;
 
     static{
@@ -25,25 +26,25 @@ public class SafeReflection {
         Method m = null, m1 = null, m2 = null, m3 = null;
         Field f = null;
         long l = 0;
-        String version = "sun.reflect";
+        String ver = "sun.reflect";
         //Get package based on java version (Java 9+ use "jdk.internal.reflect" while "sun.reflect" is used by earlier versions)
         try{
             Class.forName("sun.reflect.DelegatingConstructorAccessorImpl");
         }catch(Throwable ignored){
-            version="jdk.internal.reflect";
+            ver="jdk.internal.reflect"; // If class can't be found in sun.reflect; we know that user is running Java 9+
         }
         try{
             Class<?> c;
             f = Unsafe.class.getDeclaredField("theUnsafe");
             f.setAccessible(true);
             u = (Unsafe) f.get(null);
-            m = Class.forName(version+".DelegatingConstructorAccessorImpl").getDeclaredMethod("newInstance", Object[].class);
+            m = Class.forName(ver+".DelegatingConstructorAccessorImpl").getDeclaredMethod("newInstance", Object[].class);
             u.putBoolean(m, l=u.objectFieldOffset(AccessibleObject.class.getDeclaredField("override")), true);
             m1 = Constructor.class.getDeclaredMethod("acquireConstructorAccessor");
             m1.setAccessible(true);
             m2 = Field.class.getDeclaredMethod("getFieldAccessor", Object.class);
             m2.setAccessible(true);
-            m3 = (c=Class.forName(version+".UnsafeQualifiedStaticObjectFieldAccessorImpl")).getDeclaredMethod("set", Object.class, Object.class);
+            m3 = (c=Class.forName(ver+".UnsafeQualifiedStaticObjectFieldAccessorImpl")).getDeclaredMethod("set", Object.class, Object.class);
             u.putBoolean(m3, l, true);
             f = c.getSuperclass().getDeclaredField("isReadOnly");
             u.putBoolean(f, l, true);
@@ -55,6 +56,7 @@ public class SafeReflection {
         fieldAccess = m3;
         ro = f;
         override = l;
+        version = ver;
     }
 
     /**
@@ -423,8 +425,8 @@ public class SafeReflection {
         String s2;
         while(i.hasNext()){
             if((s2=i.next().toString()).contains("java.lang.reflect.Method.invoke")
-                    || s2.contains("sun.reflect.NativeMethodAccessorImpl.invoke")
+                    || s2.contains(version+".NativeMethodAccessorImpl.invoke")
-                    || s2.contains("sun.reflect.DelegatingMethodAccessorImpl.invoke"))
+                    || s2.contains(version+".DelegatingMethodAccessorImpl.invoke"))
                 i.remove();
         }
         try { return Class.forName(s.get(s.size()==1?0:1).getClassName()); } catch (ClassNotFoundException e) { }