ClassInspector.wrapPrimitive - opakowuje także tablice prymitywów

ClassInspector.isInstance - zwraca true dla object==null

EnumHashMap / EnumInspector - refaktoryzacja

src/main/java/net/ranides/assira/reflection/ClassInspector.java

@@ -51,6 +51,25 @@ public final class ClassInspector {
      */
     @SuppressWarnings("PMD.CyclomaticComplexity")
     public static Class<?> wrapPrimitive(Class<?> clazz) {
+        
+        if (byte[].class.equals(clazz)) {
+            return Byte[].class;
+        } else if (short[].class.equals(clazz)) {
+            return Short[].class;
+        } else if (int[].class.equals(clazz)) {
+            return Integer[].class;
+        } else if (long[].class.equals(clazz)) {
+            return Long[].class;
+        } else if (char[].class.equals(clazz)) {
+            return Character[].class;
+        } else if (float[].class.equals(clazz)) {
+            return Float[].class;
+        } else if (double[].class.equals(clazz)) {
+            return Double[].class;
+        } else if (boolean[].class.equals(clazz)) {
+            return Boolean[].class;
+        } 
+        
         if (byte.class.equals(clazz)) {
             return Byte.class;
         } else if (short.class.equals(clazz)) {
@@ -198,8 +217,7 @@ public final class ClassInspector {
      */
     public static boolean isInstance(Class<?> ssuper, Object value) {
         assert ssuper != null;
-        assert value != null;
-        return ssuper.isInstance(value);
+        return value==null || ssuper.isInstance(value);
     }
     
     /**

src/main/java/net/ranides/assira/reflection/EnumHashMap.java

@@ -20,41 +20,45 @@ public class EnumHashMap<K,V extends EnumHash<K>> {
     private final Map<K,V> mMap = new HashMap<K, V>();
 
     public static class DuplicateEnumKey extends Error {
-        private final String mKey;
-        private final String mValuePrev;
-        private final String mValueCurrent;
-
-        public DuplicateEnumKey(Object key, Object valueKey, Object currentValue) {
-            mKey = (null==key) ? "" : key.toString();
-            mValuePrev = (null==valueKey) ? "" : valueKey.toString();
-            mValueCurrent = (null==currentValue) ? "" : currentValue.toString();
+        private final Enum<?> first;
+        private final Enum<?> second;
+        private final Object value;
+
+        public DuplicateEnumKey(Enum<?> first, Enum<?> second, Object value) {
+            this.first = first;
+            this.second = second;
+            this.value = value;
         }
-
-        public String key() {
-            return mKey;
+        
+        public Class<?> type() {
+            return first.getDeclaringClass();
         }
 
-        public String prevValue() {
-            return mValuePrev;
+        public Enum<?> first() {
+            return first;
         }
 
-        public String currentValue() {
-            return mValueCurrent;
+        public Enum<?> second() {
+            return second;
+        }
+        
+        public Object value() {
+            return value;
         }
+
     }
 
     public EnumHashMap(Class<V> clazz) {
-
-        V[] values = clazz.getEnumConstants();
-        if(null == values) {
+        V[] items = clazz.getEnumConstants();
+        if(null == items) {
             throw new AssertionError("Attempt to create HashEnumMap from non-enum class");
         }
-        for(V value : values) {
-            K key = value.toEnumKey();
+        for(V current : items) {
+            K key = current.toEnumKey();
             if(mMap.containsKey(key) ) {
-                throw new DuplicateEnumKey(key, mMap.get(key), value);
+                throw new DuplicateEnumKey((Enum)mMap.get(key), (Enum)current, key);
             }
-            mMap.put(key, value);
+            mMap.put(key, current);
         }
     }
 

src/main/java/net/ranides/assira/reflection/EnumInspector.java

@@ -67,10 +67,10 @@ public final class EnumInspector<E extends Enum<E>> {
         private final Enum<?> second;
         private final Object value;
 
-        private EnumDuplicateKey(String property, Enum<?> prev, Enum<?> current, Object value) {
+        private EnumDuplicateKey(String property, Enum<?> first, Enum<?> second, Object value) {
             this.name   = property;
-            this.first       = prev;
-            this.second    = current;
+            this.first       = first;
+            this.second    = second;
             this.value      = value;
         }