qadevOOo/runner/util/ValueComparer.java

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ValueComparer.java,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 package util;
  32
  33 import com.sun.star.beans.PropertyValue;
  34 import java.lang.reflect.Array;
  35 import java.lang.reflect.Field;
  36 import java.lang.reflect.Modifier;
  37 import com.sun.star.uno.Type;
  38 import com.sun.star.uno.Enum;
  39 import com.sun.star.uno.XInterface;
  40 import com.sun.star.uno.Any;
  41 import com.sun.star.uno.AnyConverter;
  42 import java.util.HashMap;
  43
  44
  45 public class ValueComparer {
  46
  47     // Method to change a Value, thought for properties
  48     public static boolean equalValue( Object first, Object second ) {
  49
  50         if (first instanceof com.sun.star.uno.Any) {
  51             try {
  52                 first = AnyConverter.toObject(((Any) first).getType(),first);
  53             } catch (com.sun.star.lang.IllegalArgumentException iae) {
  54             }
  55         }
  56         if (second instanceof com.sun.star.uno.Any) {
  57             try {
  58                 second = AnyConverter.toObject(((Any) second).getType(),second);
  59             } catch (com.sun.star.lang.IllegalArgumentException iae) {
  60             }
  61         }
  62         boolean eq = false;
  63         try {
  64             if ( (first==null) || (second == null) ) {
  65                 eq = (first == second);
  66             }
  67             else {
  68                 if ( util.utils.isVoid(first) && util.utils.isVoid(second) ) {
  69                     eq=true;
  70                 } else if ( util.utils.isVoid(first) || util.utils.isVoid(second) ) {
  71                     eq = (first == second);
  72                 } else {
  73                     eq = compareObjects(first, second);
  74                 }
  75             }
  76         }
  77         catch (Exception e) {
  78             System.out.println("Exception occured while comparing Objects");
  79             e.printStackTrace();
  80         }
  81         return eq;
  82     } // end of equalValue
  83
  84     static boolean compareArrayOfPropertyValue(PropertyValue[] pv1, PropertyValue[] pv2){
  85         if ( pv1.length != pv2.length) {
  86             return  false;
  87         }
  88         HashMap hm1 = new HashMap();
  89         boolean result = true;
  90         int i = 0;
  91
  92         for (i = 0; i < pv1.length; i++){
  93             hm1.put(pv1[i].Name, pv1[i].Value);
  94         }
  95
  96         i = 0;
  97         while (i < pv2.length && result) {
  98             result &= equalValue(hm1.get(pv2[i].Name),pv2[i].Value);
  99             i++;
 100         }
 101         return result;
 102     }
 103
 104     static boolean compareArrays(Object op1, Object op2) throws Exception {
 105
 106         if (op1 instanceof PropertyValue[] && op2 instanceof PropertyValue[]) {
 107            return compareArrayOfPropertyValue((PropertyValue[])op1,(PropertyValue[])op2);
 108        }
 109         boolean result = true;
 110         if((op1.getClass().getComponentType() == op2.getClass().getComponentType())
 111            && (Array.getLength(op1) == Array.getLength(op2)))
 112         {
 113             Class zClass = op1.getClass().getComponentType();
 114
 115             for(int i = 0; i < Array.getLength(op1); ++ i)
 116                 result = result & compareObjects(Array.get(op1, i), Array.get(op2, i));
 117         } else {
 118             result = false ;
 119         }
 120
 121         return result;
 122     }
 123
 124     static boolean compareInterfaces(XInterface op1, XInterface op2) {
 125         return op1 == op2;
 126     }
 127
 128     static boolean compareUntil(Class zClass, Class untilClass, Object op1, Object op2) throws Exception {
 129         boolean result = true;
 130
 131         // write inherited members first
 132         Class superClass = zClass.getSuperclass();
 133         if(superClass != null && superClass != untilClass)
 134             result = result & compareUntil(superClass, untilClass, op1, op2);
 135
 136         Field fields[] = zClass.getDeclaredFields();
 137
 138         for(int i = 0; i < fields.length && result; ++ i) {
 139             if((fields[i].getModifiers() & (Modifier.STATIC | Modifier.TRANSIENT)) == 0) { // neither static nor transient ?
 140                 Object obj1 = fields[i].get(op1);
 141                 Object obj2 = fields[i].get(op2);
 142                 if (obj1 instanceof com.sun.star.uno.Any) {
 143                     try {
 144                         if (utils.isVoid(obj1)) {
 145                             obj1 = null;
 146                         } else {
 147                             obj1 = AnyConverter.toObject(((Any) obj1).getType(),obj1);
 148                         }
 149                     } catch (com.sun.star.lang.IllegalArgumentException iae) {
 150                     }
 151                 }
 152                 if (obj2 instanceof com.sun.star.uno.Any) {
 153                     try {
 154                         if (utils.isVoid(obj2)) {
 155                             obj2 = null;
 156                         } else {
 157                             obj2 = AnyConverter.toObject(((Any) obj2).getType(),obj2);
 158                         }
 159                     } catch (com.sun.star.lang.IllegalArgumentException iae) {
 160                     }
 161                 }
 162
 163                 result = result & compareObjects(obj1, obj2);
 164
 165             }
 166         }
 167
 168         return result;
 169     }
 170
 171     static boolean compareStructs(Object op1, Object op2) throws Exception {
 172         boolean result = true;
 173
 174         if(op1.getClass() != op2.getClass())
 175             result = false;
 176         else {
 177             result = compareUntil(op1.getClass(), Object.class, op1, op2);
 178         }
 179
 180         return result;
 181     }
 182
 183     static boolean compareThrowable(Throwable op1, Throwable op2) throws Exception {
 184         boolean result = true;
 185
 186         if(op1.getClass() != op2.getClass())
 187             result = false;
 188         else {
 189             result = compareUntil(op1.getClass(), Throwable.class, op1, op2);
 190
 191             result = result & op1.getMessage().equals(op2.getMessage());
 192         }
 193
 194         return result;
 195     }
 196
 197     static boolean compareEnums(Enum en1, Enum en2) {
 198         return en1.getValue() == en2.getValue();
 199     }
 200
 201     static boolean compareObjects(Object op1, Object op2) throws Exception {
 202         boolean result = false;
 203
 204         if(op1 == op2)
 205             result = true;
 206
 207         if ( (op1==null) || (op2 == null) ) {
 208             result = (op1 == op2);
 209             }
 210
 211         else if(op1.getClass().isPrimitive() && op2.getClass().isPrimitive())
 212             result = op1.equals(op2);
 213
 214         else if(op1.getClass() == Byte.class && op2.getClass() == Byte.class)
 215             result = op1.equals(op2);
 216
 217         else if(op1.getClass() == Type.class && op2.getClass() == Type.class)
 218             result = op1.equals(op2);
 219
 220         else if(op1.getClass() == Boolean.class && op2.getClass() == Boolean.class)
 221             result = op1.equals(op2);
 222
 223         else if(op1.getClass() == Short.class && op2.getClass() == Short.class)
 224             result = op1.equals(op2);
 225
 226         else if(Throwable.class.isAssignableFrom(op1.getClass()) && Throwable.class.isAssignableFrom(op2.getClass()))
 227             result = compareThrowable((Throwable)op1, (Throwable)op2);
 228
 229         else if(op1.getClass() == Integer.class && op2.getClass() == Integer.class)
 230             result = op1.equals(op2);
 231
 232         else if(op1.getClass() == Character.class && op2.getClass() == Character.class)
 233             result = op1.equals(op2);
 234
 235         else if(op1.getClass() == Long.class && op2.getClass() == Long.class)
 236             result = op1.equals(op2);
 237
 238         else if(op1.getClass() == Void.class && op2.getClass() == Void.class)
 239             result = op1.equals(op2);
 240
 241         else if(op1.getClass() == Float.class && op2.getClass() == Float.class)
 242             result = op1.equals(op2);
 243
 244         else if(op1.getClass() == Double.class && op2.getClass() == Double.class)
 245             result = op1.equals(op2);
 246
 247         else if(op1.getClass().isArray() && op2.getClass().isArray())
 248             result = compareArrays(op1, op2);
 249
 250         else if(op1.getClass() == Void.class || op2.getClass() == void.class) // write nothing ?
 251             result = true;
 252
 253         else if(XInterface.class.isAssignableFrom(op1.getClass()) && XInterface.class.isAssignableFrom(op2.getClass()))
 254             compareInterfaces((XInterface)op1, (XInterface)op2);
 255
 256         else if(Enum.class.isAssignableFrom(op1.getClass()) && Enum.class.isAssignableFrom(op2.getClass()))
 257             compareEnums((Enum)op1, (Enum)op2);
 258
 259         else if(op1.getClass() == String.class && op2.getClass() == String.class) // is it a String ?
 260             result = ((String)op1).equals((String)op2);
 261
 262         else // otherwise it must be a struct
 263             result = compareStructs(op1, op2);
 264
 265         return result;
 266     }
 267
 268
 269 }