Minor improvements

.idea/inspectionProfiles/Project_Default.xml

@@ -14,6 +14,8 @@
       <option name="loggerClassName" value="org.apache.log4j.Logger,org.slf4j.LoggerFactory,org.apache.commons.logging.LogFactory,java.util.logging.Logger" />
       <option name="loggerFactoryMethodName" value="getLogger,getLogger,getLog,getLogger" />
     </inspection_tool>
+    <inspection_tool class="PrivateMemberAccessBetweenOuterAndInnerClass" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="ReturnOfInnerClass" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="WeakerAccess" enabled="false" level="WARNING" enabled_by_default="false">
       <option name="SUGGEST_PACKAGE_LOCAL_FOR_MEMBERS" value="true" />
       <option name="SUGGEST_PACKAGE_LOCAL_FOR_TOP_CLASSES" value="true" />

src/com/tofvesson/collections/ShiftingList.java

@@ -4,7 +4,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
-@SuppressWarnings("unchecked")
+@SuppressWarnings({"unchecked", "ReturnOfInnerClass"})
 public class ShiftingList<E> implements List<E> {
     /**
      * Holder for entries. Dur to reasons, the array holds objects.
@@ -257,19 +257,15 @@ public class ShiftingList<E> implements List<E> {
     }
 
     @Override
-    public Iterator<E> iterator(){
-        return new Iterator<>();
-    }
+    public Iterator<E> iterator(){ return new Iterator<>(pop, entries); }
 
     @Override
-    public ListIterator<E> listIterator() {
-        return new ListIterator<>();
-    }
+    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<>(index);
+        return new ListIterator<>(this, index);
     }
 
     @Override
@@ -280,75 +276,40 @@ public class ShiftingList<E> implements List<E> {
         return l;
     }
 
-    public class Iterator<V> implements java.util.Iterator<V>{
-
-        int counter = 0;
-
-        @Override
-        public boolean hasNext() {
-            return counter<ShiftingList.this.pop;
-        }
-
-        @Override
-        public V next() {
-            return entries[counter++]==empty?null:(V)entries[counter];
-        }
+    /**
+     * 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]; }
     }
 
-    public class ListIterator<V> implements java.util.ListIterator<V>{
-
+    /**
+     * 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;
-
-        public ListIterator(){}
-        public ListIterator(int start){ counter = start; }
-
-        @Override
-        public boolean hasNext() {
-            return counter<ShiftingList.this.pop;
-        }
-
-        @Override
-        public V next() {
-            opNxt = true;
-            return (V)(pEl=entries[counter++]==empty?null:entries[counter-1]);
-        }
-
-        @Override
-        public boolean hasPrevious() {
-            return counter>0&&ShiftingList.this.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() {
-            ShiftingList.this.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) {
-            ShiftingList.this.add(counter, (E)v);
-        }
+        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

@@ -3,7 +3,19 @@ package com.tofvesson.reflection;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 
+/**
+ * Safe tools to help simplify code when dealing with reflection.
+ */
+@SuppressWarnings("unused")
 public class SafeReflection {
+    /**
+     * 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);
@@ -12,6 +24,52 @@ public class SafeReflection {
         }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){
+        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);
@@ -20,6 +78,36 @@ public class SafeReflection {
         }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");
@@ -28,7 +116,11 @@ public class SafeReflection {
         }catch(Exception e){}
         return null;
     }
-    public static boolean isNestedClass(Class<?> c){
-        return c.getEnclosingClass()!=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; }
 }