qadevOOo/runner/util/ValueComparer.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 package util;
  20
  21 import com.sun.star.beans.PropertyValue;
  22 import java.lang.reflect.Array;
  23 import java.lang.reflect.Field;
  24 import java.lang.reflect.Modifier;
  25 import com.sun.star.uno.Type;
  26 import com.sun.star.uno.Enum;
  27 import com.sun.star.uno.XInterface;
  28 import com.sun.star.uno.Any;
  29 import com.sun.star.uno.AnyConverter;
  30 import java.util.HashMap;
  31
  32
  33 public class ValueComparer {
  34
  35     // Method to change a Value, thought for properties
  36     public static boolean equalValue( Object first, Object second ) {
  37
  38         if (first instanceof com.sun.star.uno.Any) {
  39             try {
  40                 first = AnyConverter.toObject(((Any) first).getType(),first);
  41             } catch (com.sun.star.lang.IllegalArgumentException iae) {
  42             }
  43         }
  44         if (second instanceof com.sun.star.uno.Any) {
  45             try {
  46                 second = AnyConverter.toObject(((Any) second).getType(),second);
  47             } catch (com.sun.star.lang.IllegalArgumentException iae) {
  48             }
  49         }
  50         boolean eq = false;
  51         try {
  52             if ( (first==null) || (second == null) ) {
  53                 eq = (first == second);
  54             }
  55             else {
  56                 if ( util.utils.isVoid(first) && util.utils.isVoid(second) ) {
  57                     eq=true;
  58                 } else if ( util.utils.isVoid(first) || util.utils.isVoid(second) ) {
  59                     eq = (first == second);
  60                 } else {
  61                     eq = compareObjects(first, second);
  62                 }
  63             }
  64         }
  65         catch (Exception e) {
  66             System.out.println("Exception occurred while comparing Objects");
  67             e.printStackTrace();
  68         }
  69         return eq;
  70     } // end of equalValue
  71
  72     private static boolean compareArrayOfPropertyValue(PropertyValue[] pv1, PropertyValue[] pv2){
  73         if ( pv1.length != pv2.length) {
  74             return  false;
  75         }
  76         HashMap<String, Object> hm1 = new HashMap<String, Object>();
  77         boolean result = true;
  78         int i = 0;
  79
  80         for (i = 0; i < pv1.length; i++){
  81             hm1.put(pv1[i].Name, pv1[i].Value);
  82         }
  83
  84         i = 0;
  85         while (i < pv2.length && result) {
  86             result &= equalValue(hm1.get(pv2[i].Name),pv2[i].Value);
  87             i++;
  88         }
  89         return result;
  90     }
  91
  92     private static boolean compareArrays(Object op1, Object op2) throws Exception {
  93
  94         if (op1 instanceof PropertyValue[] && op2 instanceof PropertyValue[]) {
  95            return compareArrayOfPropertyValue((PropertyValue[])op1,(PropertyValue[])op2);
  96        }
  97         boolean result = true;
  98         if((op1.getClass().getComponentType() == op2.getClass().getComponentType())
  99            && (Array.getLength(op1) == Array.getLength(op2)))
 100         {
 101             op1.getClass().getComponentType();
 102
 103             for(int i = 0; i < Array.getLength(op1); ++ i)
 104                 result = result & compareObjects(Array.get(op1, i), Array.get(op2, i));
 105         } else {
 106             result = false ;
 107         }
 108
 109         return result;
 110     }
 111
 112     private static boolean compareInterfaces(XInterface op1, XInterface op2) {
 113         return op1 == op2;
 114     }
 115
 116     private static boolean compareUntil(Class<?> zClass, Class<?> untilClass, Object op1, Object op2) throws Exception {
 117         boolean result = true;
 118
 119         // write inherited members first
 120         Class<?> superClass = zClass.getSuperclass();
 121         if(superClass != null && superClass != untilClass)
 122             result = result & compareUntil(superClass, untilClass, op1, op2);
 123
 124         Field fields[] = zClass.getDeclaredFields();
 125
 126         for(int i = 0; i < fields.length && result; ++ i) {
 127             if((fields[i].getModifiers() & (Modifier.STATIC | Modifier.TRANSIENT)) == 0) { // neither static nor transient ?
 128                 Object obj1 = fields[i].get(op1);
 129                 Object obj2 = fields[i].get(op2);
 130                 if (obj1 instanceof com.sun.star.uno.Any) {
 131                     try {
 132                         if (utils.isVoid(obj1)) {
 133                             obj1 = null;
 134                         } else {
 135                             obj1 = AnyConverter.toObject(((Any) obj1).getType(),obj1);
 136                         }
 137                     } catch (com.sun.star.lang.IllegalArgumentException iae) {
 138                     }
 139                 }
 140                 if (obj2 instanceof com.sun.star.uno.Any) {
 141                     try {
 142                         if (utils.isVoid(obj2)) {
 143                             obj2 = null;
 144                         } else {
 145                             obj2 = AnyConverter.toObject(((Any) obj2).getType(),obj2);
 146                         }
 147                     } catch (com.sun.star.lang.IllegalArgumentException iae) {
 148                     }
 149                 }
 150
 151                 result = result & compareObjects(obj1, obj2);
 152
 153             }
 154         }
 155
 156         return result;
 157     }
 158
 159     private static boolean compareStructs(Object op1, Object op2) throws Exception {
 160         boolean result = true;
 161
 162         if(op1.getClass() != op2.getClass())
 163             result = false;
 164         else {
 165             result = compareUntil(op1.getClass(), Object.class, op1, op2);
 166         }
 167
 168         return result;
 169     }
 170
 171     private static boolean compareThrowable(Throwable op1, Throwable op2) throws Exception {
 172         boolean result = true;
 173
 174         if(op1.getClass() != op2.getClass())
 175             result = false;
 176         else {
 177             result = compareUntil(op1.getClass(), Throwable.class, op1, op2);
 178
 179             result = result & op1.getMessage().equals(op2.getMessage());
 180         }
 181
 182         return result;
 183     }
 184
 185     private static boolean compareEnums(Enum en1, Enum en2) {
 186         return en1.getValue() == en2.getValue();
 187     }
 188
 189     private static boolean compareObjects(Object op1, Object op2) throws Exception {
 190         if(op1 == op2)
 191             return true;
 192         else if(op1==null || op2 == null)
 193             return op1 == op2;
 194         else if(op1.getClass().isPrimitive() && op2.getClass().isPrimitive())
 195             return op1.equals(op2);
 196         else if(op1.getClass() == Byte.class && op2.getClass() == Byte.class)
 197             return op1.equals(op2);
 198         else if(op1.getClass() == Type.class && op2.getClass() == Type.class)
 199             return op1.equals(op2);
 200         else if(op1.getClass() == Boolean.class && op2.getClass() == Boolean.class)
 201             return op1.equals(op2);
 202         else if(op1.getClass() == Short.class && op2.getClass() == Short.class)
 203             return op1.equals(op2);
 204         else if(Throwable.class.isAssignableFrom(op1.getClass()) && Throwable.class.isAssignableFrom(op2.getClass()))
 205             return compareThrowable((Throwable)op1, (Throwable)op2);
 206         else if(op1.getClass() == Integer.class && op2.getClass() == Integer.class)
 207             return op1.equals(op2);
 208         else if(op1.getClass() == Character.class && op2.getClass() == Character.class)
 209             return op1.equals(op2);
 210         else if(op1.getClass() == Long.class && op2.getClass() == Long.class)
 211             return op1.equals(op2);
 212         else if(op1.getClass() == Void.class && op2.getClass() == Void.class)
 213             return op1.equals(op2);
 214         else if(op1.getClass() == Float.class && op2.getClass() == Float.class)
 215             return op1.equals(op2);
 216         else if(op1.getClass() == Double.class && op2.getClass() == Double.class)
 217             return op1.equals(op2);
 218         else if(op1.getClass().isArray() && op2.getClass().isArray())
 219             return compareArrays(op1, op2);
 220         else if(op1.getClass() == Void.class || op2.getClass() == void.class) // write nothing ?
 221             return true;
 222         else if(XInterface.class.isAssignableFrom(op1.getClass()) && XInterface.class.isAssignableFrom(op2.getClass()))
 223             return compareInterfaces((XInterface)op1, (XInterface)op2);
 224         else if(Enum.class.isAssignableFrom(op1.getClass()) && Enum.class.isAssignableFrom(op2.getClass()))
 225             return compareEnums((Enum)op1, (Enum)op2);
 226         else if(op1.getClass() == String.class && op2.getClass() == String.class) // is it a String ?
 227             return ((String)op1).equals(op2);
 228         else // otherwise it must be a struct
 229             return compareStructs(op1, op2);
 230     }
 231
 232
 233 }