[jboss-svn-commits] JBL Code SVN: r13215 - in labs/jbossrules/trunk/drools-core/src: test/java/org/drools/util and 1 other directory.

jboss-svn-commits at lists.jboss.org jboss-svn-commits at lists.jboss.org
Sat Jul 7 15:02:56 EDT 2007


Author: mark.proctor at jboss.com
Date: 2007-07-07 15:02:56 -0400 (Sat, 07 Jul 2007)
New Revision: 13215

Modified:
   labs/jbossrules/trunk/drools-core/src/main/java/org/drools/util/ArrayUtils.java
   labs/jbossrules/trunk/drools-core/src/test/java/org/drools/util/ShadowProxyUtilsTest.java
Log:
-fixed JDK1.5 api usage

Modified: labs/jbossrules/trunk/drools-core/src/main/java/org/drools/util/ArrayUtils.java
===================================================================
--- labs/jbossrules/trunk/drools-core/src/main/java/org/drools/util/ArrayUtils.java	2007-07-07 17:55:43 UTC (rev 13214)
+++ labs/jbossrules/trunk/drools-core/src/main/java/org/drools/util/ArrayUtils.java	2007-07-07 19:02:56 UTC (rev 13215)
@@ -1,6 +1,7 @@
 package org.drools.util;
 
 import java.lang.reflect.Array;
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -18,7 +19,6 @@
  * limitations under the License.
  */
 
-
 /**
  * Taken from commons lang
  * 
@@ -45,9 +45,9 @@
  */
 public class ArrayUtils {
     // Taken from commons ArrayUtils
-    
+
     public static final int INDEX_NOT_FOUND = -1;
-    
+
     /**
      * <p>Checks if the object is in the given array.</p>
      *
@@ -57,13 +57,15 @@
      * @param objectToFind  the object to find
      * @return <code>true</code> if the array contains the object
      */
-    public static boolean contains(Object[] array, Object objectToFind) {
-        return indexOf(array, objectToFind) != INDEX_NOT_FOUND;
-    }    
-    
+    public static boolean contains(Object[] array,
+                                   Object objectToFind) {
+        return indexOf( array,
+                        objectToFind ) != INDEX_NOT_FOUND;
+    }
+
     // IndexOf search
     // ----------------------------------------------------------------------
-    
+
     // Object IndexOf
     //-----------------------------------------------------------------------
     /**
@@ -76,8 +78,11 @@
      * @return the index of the object within the array, 
      *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
      */
-    public static int indexOf(Object[] array, Object objectToFind) {
-        return indexOf(array, objectToFind, 0);
+    public static int indexOf(Object[] array,
+                              Object objectToFind) {
+        return indexOf( array,
+                        objectToFind,
+                        0 );
     }
 
     /**
@@ -94,29 +99,31 @@
      * @return the index of the object within the array starting at the index,
      *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
      */
-    public static int indexOf(Object[] array, Object objectToFind, int startIndex) {
-        if (array == null) {
+    public static int indexOf(Object[] array,
+                              Object objectToFind,
+                              int startIndex) {
+        if ( array == null ) {
             return INDEX_NOT_FOUND;
         }
-        if (startIndex < 0) {
+        if ( startIndex < 0 ) {
             startIndex = 0;
         }
-        if (objectToFind == null) {
-            for (int i = startIndex; i < array.length; i++) {
-                if (array[i] == null) {
+        if ( objectToFind == null ) {
+            for ( int i = startIndex; i < array.length; i++ ) {
+                if ( array[i] == null ) {
                     return i;
                 }
             }
         } else {
-            for (int i = startIndex; i < array.length; i++) {
-                if (objectToFind.equals(array[i])) {
+            for ( int i = startIndex; i < array.length; i++ ) {
+                if ( objectToFind.equals( array[i] ) ) {
                     return i;
                 }
             }
         }
         return INDEX_NOT_FOUND;
     }
-    
+
     public static int hashCode(Object[] array) {
         final int PRIME = 31;
         if ( array == null ) return 0;
@@ -125,13 +132,106 @@
             result = PRIME * result + (array[index] == null ? 0 : array[index].hashCode());
         }
         return result;
-    }    
-    
-    public static Object[] copyOf(Object[] original, int newLength, Class newType) {
-        Object[] arr = (newType == Object[].class) ? new Object[newLength] :
-            (Object[])Array.newInstance(newType.getComponentType(), newLength);
-        int len  = (original.length < newLength ? original.length : newLength);
-        System.arraycopy(original, 0, arr, 0, len);
+    }
+
+    public static Object[] copyOf(Object[] original,
+                                  int newLength,
+                                  Class newType) {
+        Object[] arr = (newType == Object[].class) ? new Object[newLength] : (Object[]) Array.newInstance( newType.getComponentType(),
+                                                                                                           newLength );
+        int len = (original.length < newLength ? original.length : newLength);
+        System.arraycopy( original,
+                          0,
+                          arr,
+                          0,
+                          len );
         return arr;
-    }    
+    }
+
+    /**
+     * @since 1.5
+     */
+    public static boolean deepEquals(Object[] a1,
+                                     Object[] a2) {
+        if ( a1 == a2 ) return true;
+        if ( a1 == null || a2 == null ) return false;
+        int len = a1.length;
+        if ( len != a2.length ) return false;
+        for ( int i = 0; i < len; i++ ) {
+            Object e1 = a1[i];
+            Object e2 = a2[i];
+            if ( e1 == e2 ) continue;
+            if ( e1 == null ) return false;
+            boolean eq = (e1.getClass() != e2.getClass() || e1.getClass().isArray()) ? e1.equals( e2 ) : (e1 instanceof Object[] && e2 instanceof Object[]) ? deepEquals( (Object[]) e1,
+                                                                                                                                                                          (Object[]) e2 ) : (e1 instanceof byte[] && e2 instanceof byte[]) ? equals( (byte[]) e1,
+                                                                                                                                                                                                                                                     (byte[]) e2 ) : (e1 instanceof short[] && e2 instanceof short[]) ? equals( (short[]) e1,
+                                                                                                                                                                                                                                                                                                                                (short[]) e2 ) : (e1 instanceof int[] && e2 instanceof int[]) ? equals( (int[]) e1,
+                                                                                                                                                                                                                                                                                                                                                                                                        (int[]) e2 ) : (e1 instanceof long[] && e2 instanceof long[]) ? equals( (long[]) e1,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (long[]) e2 ) : (e1 instanceof char[] && e2 instanceof char[]) ? equals( (char[]) e1,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (char[]) e2 ) : (e1 instanceof boolean[] && e2 instanceof boolean[]) ? equals( (boolean[]) e1,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (boolean[]) e2 ) : (e1 instanceof float[] && e2 instanceof float[]) ? equals( (float[]) e1,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (float[]) e2 ) : (e1 instanceof double[] && e2 instanceof double[]) ? equals( (double[]) e1,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (double[]) e2 ) : e1.equals( e2 );
+
+            if ( !eq ) return false;
+        }
+        return true;
+    }
+
+    // Equality Testing
+
+    public static boolean equals(long[] a,
+                                 long[] a2) {
+        return java.util.Arrays.equals( a,
+                                        a2 );
+    }
+
+    public static boolean equals(int[] a,
+                                 int[] a2) {
+        return java.util.Arrays.equals( a,
+                                        a2 );
+    }
+
+    public static boolean equals(short[] a,
+                                 short a2[]) {
+        return java.util.Arrays.equals( a,
+                                        a2 );
+    }
+
+    public static boolean equals(char[] a,
+                                 char[] a2) {
+        return java.util.Arrays.equals( a,
+                                        a2 );
+    }
+
+    public static boolean equals(byte[] a,
+                                 byte[] a2) {
+        return java.util.Arrays.equals( a,
+                                        a2 );
+    }
+
+    public static boolean equals(boolean[] a,
+                                 boolean[] a2) {
+        return java.util.Arrays.equals( a,
+                                        a2 );
+    }
+
+    public static boolean equals(double[] a,
+                                 double[] a2) {
+        return java.util.Arrays.equals( a,
+                                        a2 );
+    }
+
+    public static boolean equals(float[] a,
+                                 float[] a2) {
+        return java.util.Arrays.equals( a,
+                                        a2 );
+    }
+
+    public static boolean equals(Object[] a,
+                                 Object[] a2) {
+        return java.util.Arrays.equals( a,
+                                        a2 );
+    }
+
 }

Modified: labs/jbossrules/trunk/drools-core/src/test/java/org/drools/util/ShadowProxyUtilsTest.java
===================================================================
--- labs/jbossrules/trunk/drools-core/src/test/java/org/drools/util/ShadowProxyUtilsTest.java	2007-07-07 17:55:43 UTC (rev 13214)
+++ labs/jbossrules/trunk/drools-core/src/test/java/org/drools/util/ShadowProxyUtilsTest.java	2007-07-07 19:02:56 UTC (rev 13215)
@@ -51,7 +51,7 @@
         int[][] array = new int[][]{{0, 0}, {0, 1}, {1, 0}, {1, 1}};
 
         int[][] clone = (int[][]) ShadowProxyUtils.cloneObject( array );
-        assertTrue( Arrays.deepEquals( array,
+        assertTrue( ArrayUtils.deepEquals( array,
                                        clone ) );
         assertNotSame( array,
                        clone );




More information about the jboss-svn-commits mailing list