duke@1: /*
ohair@158:  * Copyright (c) 2002, 2006, Oracle and/or its affiliates. All rights reserved.
duke@1:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@1:  *
duke@1:  * This code is free software; you can redistribute it and/or modify it
duke@1:  * under the terms of the GNU General Public License version 2 only, as
ohair@158:  * published by the Free Software Foundation.  Oracle designates this
duke@1:  * particular file as subject to the "Classpath" exception as provided
ohair@158:  * by Oracle in the LICENSE file that accompanied this code.
duke@1:  *
duke@1:  * This code is distributed in the hope that it will be useful, but WITHOUT
duke@1:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@1:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
duke@1:  * version 2 for more details (a copy is included in the LICENSE file that
duke@1:  * accompanied this code).
duke@1:  *
duke@1:  * You should have received a copy of the GNU General Public License version
duke@1:  * 2 along with this work; if not, write to the Free Software Foundation,
duke@1:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@1:  *
ohair@158:  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
ohair@158:  * or visit www.oracle.com if you need additional information or have any
ohair@158:  * questions.
duke@1:  */
duke@1: 
duke@1: package com.sun.corba.se.impl.orbutil;
duke@1: 
duke@1: import java.security.PrivilegedAction;
duke@1: import java.security.AccessController;
duke@1: import java.util.ArrayList;
duke@1: import java.util.Arrays;
duke@1: import java.util.Map;
duke@1: import java.util.List;
duke@1: import java.util.ListIterator;
duke@1: import java.util.Set;
duke@1: import java.util.Map.Entry;
duke@1: import java.util.Collection;
duke@1: import java.util.HashMap;
duke@1: import java.util.HashSet;
duke@1: import java.util.Hashtable;
duke@1: import java.util.Iterator;
duke@1: import java.util.Enumeration;
duke@1: import java.util.Properties;
duke@1: import java.util.IdentityHashMap;
duke@1: import java.lang.reflect.Array;
duke@1: import java.lang.reflect.Field;
duke@1: import java.lang.reflect.Method;
duke@1: import java.lang.reflect.Modifier;
duke@1: import java.math.BigInteger ;
duke@1: import java.math.BigDecimal ;
duke@1: 
duke@1: public final class ObjectUtility {
duke@1:     private boolean useToString ;
duke@1:     private boolean isIndenting ;
duke@1:     private int initialLevel ;
duke@1:     private int increment ;
duke@1:     private ClassMap classToPrinter = new ClassMap() ;
duke@1: 
duke@1:     private static ObjectUtility standard = new ObjectUtility( false, true,
duke@1:         0, 4 ) ;
duke@1:     private static ObjectUtility compact = new ObjectUtility( true, false,
duke@1:         0, 4 ) ;
duke@1: 
duke@1:     private ObjectUtility( boolean useToString, boolean isIndenting,
duke@1:         int initialLevel, int increment )
duke@1:     {
duke@1:         this.useToString = useToString ;
duke@1:         this.isIndenting = isIndenting ;
duke@1:         this.initialLevel = initialLevel ;
duke@1:         this.increment = increment ;
duke@1:         classToPrinter.put( Properties.class, propertiesPrinter ) ;
duke@1:         classToPrinter.put( Collection.class, collectionPrinter ) ;
duke@1:         classToPrinter.put( Map.class, mapPrinter ) ;
duke@1:     }
duke@1: 
duke@1:     /** Construct an Utility instance with the desired objectToString
duke@1:     * behavior.
duke@1:     */
duke@1:     public static ObjectUtility make( boolean useToString, boolean isIndenting,
duke@1:         int initialLevel, int increment )
duke@1:     {
duke@1:         return new ObjectUtility( useToString, isIndenting, initialLevel,
duke@1:             increment ) ;
duke@1:     }
duke@1: 
duke@1:     /** Construct an Utility instance with the desired objectToString
duke@1:     * behavior.
duke@1:     */
duke@1:     public static ObjectUtility make( boolean useToString, boolean isIndenting )
duke@1:     {
duke@1:         return new ObjectUtility( useToString, isIndenting, 0, 4 ) ;
duke@1:     }
duke@1: 
duke@1:     /** Get the standard Utility object that supports objectToString with
duke@1:     * indented display and no use of toString() methods.
duke@1:     */
duke@1:     public static ObjectUtility make()
duke@1:     {
duke@1:         return standard ;
duke@1:     }
duke@1: 
duke@1:     /** A convenience method that gives the default behavior: use indenting
duke@1:     * to display the object's structure and do not use built-in toString
duke@1:     * methods.
duke@1:     */
duke@1:     public static String defaultObjectToString( java.lang.Object object )
duke@1:     {
duke@1:         return standard.objectToString( object ) ;
duke@1:     }
duke@1: 
duke@1:     public static String compactObjectToString( java.lang.Object object )
duke@1:     {
duke@1:         return compact.objectToString( object ) ;
duke@1:     }
duke@1: 
duke@1:     /** objectToString handles display of arbitrary objects.  It correctly
duke@1:     * handles objects whose elements form an arbitrary graph.  It uses
duke@1:     * reflection to display the contents of any kind of object.
duke@1:     * An object's toString() method may optionally be used, but the default
duke@1:     * is to ignore all toString() methods except for those defined for
duke@1:     * primitive types, primitive type wrappers, and strings.
duke@1:     */
duke@1:     public String objectToString(java.lang.Object obj)
duke@1:     {
duke@1:         IdentityHashMap printed = new IdentityHashMap() ;
duke@1:         ObjectWriter result = ObjectWriter.make( isIndenting, initialLevel,
duke@1:             increment ) ;
duke@1:         objectToStringHelper( printed, result, obj ) ;
duke@1:         return result.toString() ;
duke@1:     }
duke@1: 
duke@1:     // Perform a deep structural equality comparison of the two objects.
duke@1:     // This handles all arrays, maps, and sets specially, otherwise
duke@1:     // it just calls the object's equals() method.
duke@1:     public static boolean equals( java.lang.Object obj1, java.lang.Object obj2 )
duke@1:     {
duke@1:         // Set of pairs of objects that have been (or are being) considered for
duke@1:         // equality.  Such pairs are presumed to be equals.  If they are not,
duke@1:         // this will be detected eventually and the equals method will return
duke@1:         // false.
duke@1:         Set considered = new HashSet() ;
duke@1: 
duke@1:         // Map that gives the corresponding component of obj2 for a component
duke@1:         // of obj1.  This is used to check for the same aliasing and use of
duke@1:         // equal objects in both objects.
duke@1:         Map counterpart = new IdentityHashMap() ;
duke@1: 
duke@1:         return equalsHelper( counterpart, considered, obj1, obj2 ) ;
duke@1:     }
duke@1: 
duke@1:     /** If arr1 and arr2 are both arrays of the same component type,
duke@1:      * return an array of that component type that consists of the
duke@1:      * elements of arr1 followed by the elements of arr2.
duke@1:      * Throws IllegalArgumentException otherwise.
duke@1:      */
duke@1:     public static Object concatenateArrays( Object arr1, Object arr2 )
duke@1:     {
duke@1:         Class comp1 = arr1.getClass().getComponentType() ;
duke@1:         Class comp2 = arr2.getClass().getComponentType() ;
duke@1:         int len1 = Array.getLength( arr1 ) ;
duke@1:         int len2 = Array.getLength( arr2 ) ;
duke@1: 
duke@1:         if ((comp1 == null) || (comp2 == null))
duke@1:             throw new IllegalStateException( "Arguments must be arrays" ) ;
duke@1:         if (!comp1.equals( comp2 ))
duke@1:             throw new IllegalStateException(
duke@1:                 "Arguments must be arrays with the same component type" ) ;
duke@1: 
duke@1:         Object result = Array.newInstance( comp1, len1 + len2 ) ;
duke@1: 
duke@1:         int index = 0 ;
duke@1: 
duke@1:         for (int ctr=0; ctr<len1; ctr++)
duke@1:             Array.set( result, index++, Array.get( arr1, ctr ) ) ;
duke@1: 
duke@1:         for (int ctr=0; ctr<len2; ctr++)
duke@1:             Array.set( result, index++, Array.get( arr2, ctr ) ) ;
duke@1: 
duke@1:         return result ;
duke@1:     }
duke@1: 
duke@1: //===========================================================================
duke@1: //  Implementation
duke@1: //===========================================================================
duke@1: 
duke@1:     private void objectToStringHelper( IdentityHashMap printed,
duke@1:         ObjectWriter result, java.lang.Object obj)
duke@1:     {
duke@1:         if (obj==null) {
duke@1:             result.append( "null" ) ;
duke@1:             result.endElement() ;
duke@1:         } else {
duke@1:             Class cls = obj.getClass() ;
duke@1:             result.startObject( obj ) ;
duke@1: 
duke@1:             if (printed.keySet().contains( obj )) {
duke@1:                 result.endObject( "*VISITED*" ) ;
duke@1:             } else {
duke@1:                 printed.put( obj, null ) ;
duke@1: 
duke@1:                 if (mustUseToString(cls)) {
duke@1:                     result.endObject( obj.toString() ) ;
duke@1:                 } else {
duke@1:                     // First, handle any classes that have special printer
duke@1:                     // methods defined.  This is useful when the class
duke@1:                     // overrides toString with something that
duke@1:                     // is not sufficiently detailed.
duke@1:                     ObjectPrinter printer = (ObjectPrinter)(classToPrinter.get(
duke@1:                         cls )) ;
duke@1:                     if (printer != null) {
duke@1:                         printer.print( printed, result, obj ) ;
duke@1:                         result.endObject() ;
duke@1:                     } else {
duke@1:                         Class compClass = cls.getComponentType() ;
duke@1: 
duke@1:                         if (compClass == null)
duke@1:                             // handleObject always calls endObject
duke@1:                             handleObject( printed, result, obj ) ;
duke@1:                         else {
duke@1:                             handleArray( printed, result, obj ) ;
duke@1:                             result.endObject() ;
duke@1:                         }
duke@1:                     }
duke@1:                 }
duke@1:             }
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     private static interface ObjectPrinter {
duke@1:         void print( IdentityHashMap printed, ObjectWriter buff,
duke@1:             java.lang.Object obj ) ;
duke@1:     }
duke@1: 
duke@1:     private ObjectPrinter propertiesPrinter = new ObjectPrinter() {
duke@1:         public void print( IdentityHashMap printed, ObjectWriter buff,
duke@1:             java.lang.Object obj )
duke@1:         {
duke@1:             if (!(obj instanceof Properties))
duke@1:                 throw new Error() ;
duke@1: 
duke@1:             Properties props = (Properties)obj ;
duke@1:             Enumeration keys = props.propertyNames() ;
duke@1:             while (keys.hasMoreElements()) {
duke@1:                 String key = (String)(keys.nextElement()) ;
duke@1:                 String value = props.getProperty( key ) ;
duke@1:                 buff.startElement() ;
duke@1:                 buff.append( key ) ;
duke@1:                 buff.append( "=" ) ;
duke@1:                 buff.append( value ) ;
duke@1:                 buff.endElement() ;
duke@1:             }
duke@1:         }
duke@1:     } ;
duke@1: 
duke@1:     private ObjectPrinter collectionPrinter = new ObjectPrinter() {
duke@1:         public void print( IdentityHashMap printed, ObjectWriter buff,
duke@1:             java.lang.Object obj )
duke@1:         {
duke@1:             if (!(obj instanceof Collection))
duke@1:                 throw new Error() ;
duke@1: 
duke@1:             Collection coll = (Collection)obj ;
duke@1:             Iterator iter = coll.iterator() ;
duke@1:             while (iter.hasNext()) {
duke@1:                 java.lang.Object element = iter.next() ;
duke@1:                 buff.startElement() ;
duke@1:                 objectToStringHelper( printed, buff, element ) ;
duke@1:                 buff.endElement() ;
duke@1:             }
duke@1:         }
duke@1:     } ;
duke@1: 
duke@1:     private ObjectPrinter mapPrinter = new ObjectPrinter() {
duke@1:         public void print( IdentityHashMap printed, ObjectWriter buff,
duke@1:             java.lang.Object obj )
duke@1:         {
duke@1:             if (!(obj instanceof Map))
duke@1:                 throw new Error() ;
duke@1: 
duke@1:             Map map = (Map)obj ;
duke@1:             Iterator iter = map.entrySet().iterator() ;
duke@1:             while (iter.hasNext()) {
duke@1:                 Entry entry = (Entry)(iter.next()) ;
duke@1:                 buff.startElement() ;
duke@1:                 objectToStringHelper( printed, buff, entry.getKey() ) ;
duke@1:                 buff.append( "=>" ) ;
duke@1:                 objectToStringHelper( printed, buff, entry.getValue() ) ;
duke@1:                 buff.endElement() ;
duke@1:             }
duke@1:         }
duke@1:     } ;
duke@1: 
duke@1:     private static class ClassMap {
duke@1:         ArrayList data ;
duke@1: 
duke@1:         public ClassMap()
duke@1:         {
duke@1:             data = new ArrayList() ;
duke@1:         }
duke@1: 
duke@1:         /** Return the first element of the ClassMap that is assignable to cls.
duke@1:         * The order is determined by the order in which the put method was
duke@1:         * called.  Returns null if there is no match.
duke@1:         */
duke@1:         public java.lang.Object get( Class cls )
duke@1:         {
duke@1:             Iterator iter = data.iterator() ;
duke@1:             while (iter.hasNext()) {
duke@1:                 java.lang.Object[] arr = (java.lang.Object[])(iter.next()) ;
duke@1:                 Class key = (Class)(arr[0]) ;
duke@1:                 if (key.isAssignableFrom( cls ))
duke@1:                     return arr[1] ;
duke@1:             }
duke@1: 
duke@1:             return null ;
duke@1:         }
duke@1: 
duke@1:         /** Add obj to the map with key cls.  Note that order matters,
duke@1:          * as the first match is returned.
duke@1:          */
duke@1:         public void put( Class cls, java.lang.Object obj )
duke@1:         {
duke@1:             java.lang.Object[] pair = { cls, obj } ;
duke@1:             data.add( pair ) ;
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     private boolean mustUseToString( Class cls )
duke@1:     {
duke@1:         // These probably never occur
duke@1:         if (cls.isPrimitive())
duke@1:             return true ;
duke@1: 
duke@1:         // We must use toString for all primitive wrappers, since
duke@1:         // otherwise the code recurses endlessly (access value field
duke@1:         // inside Integer, returns another Integer through reflection).
duke@1:         if ((cls == Integer.class) ||
duke@1:             (cls == BigInteger.class) ||
duke@1:             (cls == BigDecimal.class) ||
duke@1:             (cls == String.class) ||
duke@1:             (cls == StringBuffer.class) ||
duke@1:             (cls == Long.class) ||
duke@1:             (cls == Short.class) ||
duke@1:             (cls == Byte.class) ||
duke@1:             (cls == Character.class) ||
duke@1:             (cls == Float.class) ||
duke@1:             (cls == Double.class) ||
duke@1:             (cls == Boolean.class))
duke@1:             return true ;
duke@1: 
duke@1:         if (useToString) {
duke@1:             try {
jjg@173:                 cls.getDeclaredMethod( "toString", (Class[])null ) ;
duke@1:                 return true ;
duke@1:             } catch (Exception exc) {
duke@1:                 return false ;
duke@1:             }
duke@1:         }
duke@1: 
duke@1:         return false ;
duke@1:     }
duke@1: 
duke@1:     private void handleObject( IdentityHashMap printed, ObjectWriter result,
duke@1:         java.lang.Object obj )
duke@1:     {
duke@1:         Class cls = obj.getClass() ;
duke@1: 
duke@1:         try {
duke@1:             Field[] fields;
duke@1:             SecurityManager security = System.getSecurityManager();
duke@1:             if (security != null && !Modifier.isPublic(cls.getModifiers())) {
duke@1:                 fields = new Field[0];
duke@1:             } else {
duke@1:                 fields = cls.getDeclaredFields();
duke@1:             }
duke@1: 
duke@1:             for (int ctr=0; ctr<fields.length; ctr++ ) {
duke@1:                 final Field fld = fields[ctr] ;
duke@1:                 int modifiers = fld.getModifiers() ;
duke@1: 
duke@1:                 // Do not display field if it is static, since these fields
duke@1:                 // are always the same for every instances.  This could
duke@1:                 // be made configurable, but I don't think it is
duke@1:                 // useful to do so.
duke@1:                 if (!Modifier.isStatic( modifiers )) {
duke@1:                     if (security != null) {
duke@1:                         if (!Modifier.isPublic(modifiers))
duke@1:                             continue;
duke@1:                     }
duke@1:                     result.startElement() ;
duke@1:                     result.append( fld.getName() ) ;
duke@1:                     result.append( ":" ) ;
duke@1: 
duke@1:                     try {
duke@1:                         // Make sure that we can read the field if it is
duke@1:                         // not public
duke@1:                         AccessController.doPrivileged( new PrivilegedAction() {
duke@1:                             public Object run() {
duke@1:                                 fld.setAccessible( true ) ;
duke@1:                                 return null ;
duke@1:                             }
duke@1:                         } ) ;
duke@1: 
duke@1:                         java.lang.Object value = fld.get( obj ) ;
duke@1:                         objectToStringHelper( printed, result, value ) ;
duke@1:                     } catch (Exception exc2) {
duke@1:                         result.append( "???" ) ;
duke@1:                     }
duke@1: 
duke@1:                     result.endElement() ;
duke@1:                 }
duke@1:             }
duke@1: 
duke@1:             result.endObject() ;
duke@1:         } catch (Exception exc2) {
duke@1:             result.endObject( obj.toString() ) ;
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     private void handleArray( IdentityHashMap printed, ObjectWriter result,
duke@1:         java.lang.Object obj )
duke@1:     {
duke@1:         Class compClass = obj.getClass().getComponentType() ;
duke@1:         if (compClass == boolean.class) {
duke@1:             boolean[] arr = (boolean[])obj ;
duke@1:             for (int ctr=0; ctr<arr.length; ctr++) {
duke@1:                 result.startElement() ;
duke@1:                 result.append( arr[ctr] ) ;
duke@1:                 result.endElement() ;
duke@1:             }
duke@1:         } else if (compClass == byte.class) {
duke@1:             byte[] arr = (byte[])obj ;
duke@1:             for (int ctr=0; ctr<arr.length; ctr++) {
duke@1:                 result.startElement() ;
duke@1:                 result.append( arr[ctr] ) ;
duke@1:                 result.endElement() ;
duke@1:             }
duke@1:         } else if (compClass == short.class) {
duke@1:             short[] arr = (short[])obj ;
duke@1:             for (int ctr=0; ctr<arr.length; ctr++) {
duke@1:                 result.startElement() ;
duke@1:                 result.append( arr[ctr] ) ;
duke@1:                 result.endElement() ;
duke@1:             }
duke@1:         } else if (compClass == int.class) {
duke@1:             int[] arr = (int[])obj ;
duke@1:             for (int ctr=0; ctr<arr.length; ctr++) {
duke@1:                 result.startElement() ;
duke@1:                 result.append( arr[ctr] ) ;
duke@1:                 result.endElement() ;
duke@1:             }
duke@1:         } else if (compClass == long.class) {
duke@1:             long[] arr = (long[])obj ;
duke@1:             for (int ctr=0; ctr<arr.length; ctr++) {
duke@1:                 result.startElement() ;
duke@1:                 result.append( arr[ctr] ) ;
duke@1:                 result.endElement() ;
duke@1:             }
duke@1:         } else if (compClass == char.class) {
duke@1:             char[] arr = (char[])obj ;
duke@1:             for (int ctr=0; ctr<arr.length; ctr++) {
duke@1:                 result.startElement() ;
duke@1:                 result.append( arr[ctr] ) ;
duke@1:                 result.endElement() ;
duke@1:             }
duke@1:         } else if (compClass == float.class) {
duke@1:             float[] arr = (float[])obj ;
duke@1:             for (int ctr=0; ctr<arr.length; ctr++) {
duke@1:                 result.startElement() ;
duke@1:                 result.append( arr[ctr] ) ;
duke@1:                 result.endElement() ;
duke@1:             }
duke@1:         } else if (compClass == double.class) {
duke@1:             double[] arr = (double[])obj ;
duke@1:             for (int ctr=0; ctr<arr.length; ctr++) {
duke@1:                 result.startElement() ;
duke@1:                 result.append( arr[ctr] ) ;
duke@1:                 result.endElement() ;
duke@1:             }
duke@1:         } else { // array of object
duke@1:             java.lang.Object[] arr = (java.lang.Object[])obj ;
duke@1:             for (int ctr=0; ctr<arr.length; ctr++) {
duke@1:                 result.startElement() ;
duke@1:                 objectToStringHelper( printed, result, arr[ctr] ) ;
duke@1:                 result.endElement() ;
duke@1:             }
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     private static class Pair
duke@1:     {
duke@1:         private java.lang.Object obj1 ;
duke@1:         private java.lang.Object obj2 ;
duke@1: 
duke@1:         Pair( java.lang.Object obj1, java.lang.Object obj2 )
duke@1:         {
duke@1:             this.obj1 = obj1 ;
duke@1:             this.obj2 = obj2 ;
duke@1:         }
duke@1: 
duke@1:         public boolean equals( java.lang.Object obj )
duke@1:         {
duke@1:             if (!(obj instanceof Pair))
duke@1:                 return false ;
duke@1: 
duke@1:             Pair other = (Pair)obj ;
duke@1:             return other.obj1 == obj1 && other.obj2 == obj2 ;
duke@1:         }
duke@1: 
duke@1:         public int hashCode()
duke@1:         {
duke@1:             return System.identityHashCode( obj1 ) ^
duke@1:                 System.identityHashCode( obj2 ) ;
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     private static boolean equalsHelper( Map counterpart, Set considered,
duke@1:         java.lang.Object obj1, java.lang.Object obj2 )
duke@1:     {
duke@1:         if ((obj1 == null) || (obj2 == null))
duke@1:             return obj1 == obj2 ;
duke@1: 
duke@1:         java.lang.Object other2 = counterpart.get( obj1 ) ;
duke@1:         if (other2 == null) {
duke@1:             other2 = obj2 ;
duke@1:             counterpart.put( obj1, other2 ) ;
duke@1:         }
duke@1: 
duke@1:         if (obj1 == other2)
duke@1:             return true ;
duke@1: 
duke@1:         if (obj2 != other2)
duke@1:             return false ;
duke@1: 
duke@1:         Pair pair = new Pair( obj1, obj2 ) ;
duke@1:         if (considered.contains( pair ))
duke@1:             return true ;
duke@1:         else
duke@1:             considered.add( pair ) ;
duke@1: 
duke@1:         if (obj1 instanceof java.lang.Object[] &&
duke@1:             obj2 instanceof java.lang.Object[])
duke@1:             return equalArrays( counterpart, considered,
duke@1:                 (java.lang.Object[])obj1, (java.lang.Object[])obj2 ) ;
duke@1:         else if (obj1 instanceof Map && obj2 instanceof Map)
duke@1:             return equalMaps( counterpart, considered,
duke@1:                 (Map)obj1, (Map)obj2 ) ;
duke@1:         else if (obj1 instanceof Set && obj2 instanceof Set)
duke@1:             return equalSets( counterpart, considered,
duke@1:                 (Set)obj1, (Set)obj2 ) ;
duke@1:         else if (obj1 instanceof List && obj2 instanceof List)
duke@1:             return equalLists( counterpart, considered,
duke@1:                 (List)obj1, (List)obj2 ) ;
duke@1:         else if (obj1 instanceof boolean[] && obj2 instanceof boolean[])
duke@1:             return Arrays.equals( (boolean[])obj1, (boolean[])obj2 ) ;
duke@1:         else if (obj1 instanceof byte[] && obj2 instanceof byte[])
duke@1:             return Arrays.equals( (byte[])obj1, (byte[])obj2 ) ;
duke@1:         else if (obj1 instanceof char[] && obj2 instanceof char[])
duke@1:             return Arrays.equals( (char[])obj1, (char[])obj2 ) ;
duke@1:         else if (obj1 instanceof double[] && obj2 instanceof double[])
duke@1:             return Arrays.equals( (double[])obj1, (double[])obj2 ) ;
duke@1:         else if (obj1 instanceof float[] && obj2 instanceof float[])
duke@1:             return Arrays.equals( (float[])obj1, (float[])obj2 ) ;
duke@1:         else if (obj1 instanceof int[] && obj2 instanceof int[])
duke@1:             return Arrays.equals( (int[])obj1, (int[])obj2 ) ;
duke@1:         else if (obj1 instanceof long[] && obj2 instanceof long[])
duke@1:             return Arrays.equals( (long[])obj1, (long[])obj2 ) ;
duke@1:         else {
duke@1:             Class cls = obj1.getClass() ;
duke@1:             if (cls != obj2.getClass())
duke@1:                 return obj1.equals( obj2 ) ;
duke@1:             else
duke@1:                 return equalsObject( counterpart, considered, cls, obj1, obj2 ) ;
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     private static boolean equalsObject( Map counterpart, Set considered,
duke@1:         Class cls, java.lang.Object obj1, java.lang.Object obj2 )
duke@1:     {
duke@1:         Class objectClass = java.lang.Object.class ;
duke@1:         if (cls == objectClass)
duke@1:             return true ;
duke@1: 
duke@1:         Class[] equalsTypes = { objectClass } ;
duke@1:         try {
duke@1:             Method equalsMethod = cls.getDeclaredMethod( "equals",
duke@1:                 equalsTypes ) ;
duke@1:             return obj1.equals( obj2 ) ;
duke@1:         } catch (Exception exc) {
duke@1:             if (equalsObjectFields( counterpart, considered,
duke@1:                     cls, obj1, obj2 ))
duke@1:                 return equalsObject( counterpart, considered,
duke@1:                     cls.getSuperclass(), obj1, obj2 ) ;
duke@1:             else
duke@1:                 return false ;
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     private static boolean equalsObjectFields( Map counterpart, Set considered,
duke@1:         Class cls, java.lang.Object obj1, java.lang.Object obj2 )
duke@1:     {
duke@1:         Field[] fields = cls.getDeclaredFields() ;
duke@1:         for (int ctr=0; ctr<fields.length; ctr++) {
duke@1:             try {
duke@1:                 final Field field = fields[ctr] ;
duke@1:                 // Ignore static fields
duke@1:                 if (!Modifier.isStatic( field.getModifiers())) {
duke@1:                     AccessController.doPrivileged(new PrivilegedAction() {
duke@1:                         public Object run() {
duke@1:                             field.setAccessible( true ) ;
duke@1:                             return null ;
duke@1:                         }
duke@1:                     } ) ;
duke@1: 
duke@1:                     java.lang.Object value1 = field.get( obj1 ) ;
duke@1:                     java.lang.Object value2 = field.get( obj2 ) ;
duke@1:                     if (!equalsHelper( counterpart, considered, value1,
duke@1:                         value2 ))
duke@1:                         return false ;
duke@1:                 }
duke@1:             } catch (IllegalAccessException exc) {
duke@1:                 return false ;
duke@1:             }
duke@1:         }
duke@1: 
duke@1:         return true ;
duke@1:     }
duke@1: 
duke@1:     private static boolean equalArrays( Map counterpart, Set considered,
duke@1:         java.lang.Object[] arr1, java.lang.Object[] arr2 )
duke@1:     {
duke@1:         int len = arr1.length ;
duke@1:         if (len != arr2.length)
duke@1:             return false ;
duke@1: 
duke@1:         for (int ctr = 0; ctr<len; ctr++ )
duke@1:             if (!equalsHelper( counterpart, considered, arr1[ctr], arr2[ctr] ))
duke@1:                 return false ;
duke@1: 
duke@1:         return true ;
duke@1:     }
duke@1: 
duke@1:     private static boolean equalMaps( Map counterpart, Set considered,
duke@1:         Map map1, Map map2 )
duke@1:     {
duke@1:         if (map2.size() != map1.size())
duke@1:             return false;
duke@1: 
duke@1:         try {
duke@1:             Iterator i = map1.entrySet().iterator();
duke@1:             while (i.hasNext()) {
duke@1:                 Entry e = (Entry) i.next();
duke@1:                 java.lang.Object key = e.getKey();
duke@1:                 java.lang.Object value = e.getValue();
duke@1:                 if (value == null) {
duke@1:                     if (!(map2.get(key)==null && map2.containsKey(key)))
duke@1:                         return false;
duke@1:                 } else {
duke@1:                     if (!equalsHelper( counterpart, considered,
duke@1:                         value, map2.get(key)))
duke@1:                         return false;
duke@1:                 }
duke@1:             }
duke@1:         } catch(ClassCastException unused)   {
duke@1:             return false;
duke@1:         } catch(NullPointerException unused) {
duke@1:             return false;
duke@1:         }
duke@1: 
duke@1:         return true;
duke@1:     }
duke@1: 
duke@1:     // Obviously this is an inefficient quadratic algorithm.
duke@1:     // This is taken pretty directly from AbstractSet and AbstractCollection
duke@1:     // in the JDK.
duke@1:     // For HashSet, an O(n) (with a good hash function) algorithm
duke@1:     // is possible, and likewise TreeSet, since it is
duke@1:     // ordered, is O(n).  But this is not worth the effort here.
duke@1:     // Note that the inner loop uses equals, not equalsHelper.
duke@1:     // This is needed because of the searching behavior of this test.
duke@1:     // However, note that this will NOT correctly handle sets that
duke@1:     // contain themselves as members, or that have members that reference
duke@1:     // themselves.  These cases will cause infinite regress!
duke@1:     private static boolean equalSets( Map counterpart, Set considered,
duke@1:         Set set1, Set set2 )
duke@1:     {
duke@1:         if (set1.size() != set2.size())
duke@1:             return false ;
duke@1: 
duke@1:         Iterator e1 = set1.iterator() ;
duke@1:         while (e1.hasNext()) {
duke@1:             java.lang.Object obj1 = e1.next() ;
duke@1: 
duke@1:             boolean found = false ;
duke@1:             Iterator e2 = set2.iterator() ;
duke@1:             while (e2.hasNext() && !found) {
duke@1:                 java.lang.Object obj2 = e2.next() ;
duke@1:                 found = equals( obj1, obj2 ) ;
duke@1:             }
duke@1: 
duke@1:             if (!found)
duke@1:                 return false ;
duke@1:         }
duke@1: 
duke@1:         return true ;
duke@1:     }
duke@1: 
duke@1:     private static boolean equalLists( Map counterpart, Set considered,
duke@1:         List list1, List list2 )
duke@1:     {
duke@1:         ListIterator e1 = list1.listIterator();
duke@1:         ListIterator e2 = list2.listIterator();
duke@1:         while(e1.hasNext() && e2.hasNext()) {
duke@1:             java.lang.Object o1 = e1.next();
duke@1:             java.lang.Object o2 = e2.next();
duke@1:             if (!(o1==null ? o2==null : equalsHelper(
duke@1:                 counterpart, considered, o1, o2)))
duke@1:                 return false;
duke@1:         }
duke@1:         return !(e1.hasNext() || e2.hasNext());
duke@1:     }
duke@1: }