Java tutorial
/* * Copyright (c) 2012 Data Harmonisation Panel * * All rights reserved. This program and the accompanying materials are made * available under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation, either version 3 of the License, * or (at your option) any later version. * * You should have received a copy of the GNU Lesser General Public License * along with this distribution. If not, see <http://www.gnu.org/licenses/>. * * Contributors: * HUMBOLDT EU Integrated Project #030962 * Data Harmonisation Panel <http://www.dhpanel.eu> */ package eu.esdihumboldt.hale.common.instance.model; import java.math.BigDecimal; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import javax.xml.namespace.QName; import com.google.common.base.Objects; import com.google.common.collect.Iterables; import com.google.common.primitives.Booleans; import com.google.common.primitives.Bytes; import com.google.common.primitives.Chars; import com.google.common.primitives.Doubles; import com.google.common.primitives.Floats; import com.google.common.primitives.Ints; import com.google.common.primitives.Longs; import com.google.common.primitives.Shorts; import eu.esdihumboldt.hale.common.schema.geometry.GeometryProperty; /** * Instance utility functions. * * @author Kai Schwierczek */ public final class InstanceUtil { private InstanceUtil() { // static utility class } /** * Checks whether the two given instances equal each other disregarding * their data set. * * @param a the first instance * @param b the second instance * @param propertyOrderRelevant whether the order of properties of the same * name is relevant or not * @return true, iff both instances are equal to each other except for their * data set */ public static boolean instanceEqual(Instance a, Instance b, boolean propertyOrderRelevant) { if (a == b) return true; if (a == null || b == null) return false; // compare value // XXX other checks than equals possible? if (!equals(a.getValue(), b.getValue())) return false; // check groups properties return groupEqual(a, b, propertyOrderRelevant); } /** * Equals implementation comparing two objects, with some improvements and * adaptations. * * @param o1 the first object * @param o2 the second object * @return if the two objects are deemed equal */ private static boolean equals(Object o1, Object o2) { if (o1 != null && o2 != null) { // special case: arrays if (o1.getClass().isArray() && o2.getClass().isArray()) { return arrayToList(o1).equals(arrayToList(o2)); } // special case: geometry properties if (o1 instanceof GeometryProperty<?> && o2 instanceof GeometryProperty<?>) { GeometryProperty<?> g1 = (GeometryProperty<?>) o1; GeometryProperty<?> g2 = (GeometryProperty<?>) o2; if (g1.getGeometry() == null && g2.getGeometry() == null) { return true; } else if (g1.getGeometry() != null && g2.getGeometry() != null) { boolean crsEquals; if (g1.getCRSDefinition() != null && g2.getCRSDefinition() != null) { crsEquals = Objects.equal(g1.getCRSDefinition().getCRS(), g2.getCRSDefinition().getCRS()); } else { crsEquals = Objects.equal(g1.getCRSDefinition(), g2.getCRSDefinition()); } // XXX do conversion of geometry? // topological comparison (added 0.005 as tolerance for // testing purpose) boolean geometryEquals = g1.getGeometry().equalsExact(g2.getGeometry(), 0.005); // geometryEquals && crsEquals; return geometryEquals || crsEquals; } else { return false; } } } return Objects.equal(o1, o2); } private static List<?> arrayToList(Object array) { if (array instanceof byte[]) { return Bytes.asList((byte[]) array); } if (array instanceof int[]) { return Ints.asList((int[]) array); } if (array instanceof short[]) { return Shorts.asList((short[]) array); } if (array instanceof long[]) { return Longs.asList((long[]) array); } if (array instanceof float[]) { return Floats.asList((float[]) array); } if (array instanceof double[]) { return Doubles.asList((double[]) array); } if (array instanceof char[]) { return Chars.asList((char[]) array); } if (array instanceof boolean[]) { return Booleans.asList((boolean[]) array); } return Arrays.asList((Object[]) array); } /** * Check if an instance is present in the given candidates. If found, will * remove the match from the candidates collection. * * @param instance the instance to test * @param candidates the candidates to compare the instance against * @return the error message if the check failed, otherwise * <code>null</code> */ public static String checkInstance(Instance instance, Collection<Instance> candidates) { boolean found = false; Iterator<Instance> candidatesIter = candidates.iterator(); while (!found && candidatesIter.hasNext()) { if (InstanceUtil.instanceEqual(instance, candidatesIter.next(), false)) { candidatesIter.remove(); found = true; } } if (!found) { StringBuilder sb = new StringBuilder(); sb.append("Could not find matching instance for: \n"); sb.append(InstanceUtil.instanceToString(instance)); sb.append("\n inside the available ones: \n"); for (Instance candidate : candidates) { sb.append(InstanceUtil.instanceToString(candidate)); } String message = sb.toString(); return message; } return null; } /** * Checks whether the two given groups equal each other. * * @param a the first group * @param b the second group * @param propertyOrderRelevant whether the order of properties of the same * name is relevant or not * @return true, if both groups are equal to each */ public static boolean groupEqual(Group a, Group b, boolean propertyOrderRelevant) { if (a == b) return true; // compare definitions if (!Objects.equal(a.getDefinition(), b.getDefinition())) return false; // check property count Iterable<QName> aProperties = a.getPropertyNames(); if (Iterables.size(aProperties) != Iterables.size(b.getPropertyNames())) return false; // iterate over a properties for (QName aPropertyName : aProperties) { Object[] aProperty = a.getProperty(aPropertyName); Object[] bProperty = b.getProperty(aPropertyName); // check whether the property exists (in the same amount) if (bProperty == null || bProperty.length != aProperty.length) return false; if (propertyOrderRelevant) { // simply iterate over the property array once for (int i = 0; i < aProperty.length; i++) if (!propertyValueEquals(aProperty[i], bProperty[i], propertyOrderRelevant)) return false; } else { // check whether each property value of a has an equal property // value in b List<Object> bPropertyList = new LinkedList<Object>(Arrays.asList(bProperty)); for (Object aPropertyValue : aProperty) { Iterator<Object> bPropertyValueIterator = bPropertyList.iterator(); boolean match = false; while (!match && bPropertyValueIterator.hasNext()) { Object bPropertyValue = bPropertyValueIterator.next(); match = propertyValueEquals(aPropertyValue, bPropertyValue, propertyOrderRelevant); if (match) bPropertyValueIterator.remove(); } if (!match) return false; } } } return true; } private static boolean propertyValueEquals(Object a, Object b, boolean propertyOrderRelevant) { if (a == b) return true; // check if a is an instance or a group for specialized check // XXX other method than equals if it is not a group or instance? if (a instanceof Instance) { if (b instanceof Instance && instanceEqual((Instance) a, (Instance) b, propertyOrderRelevant)) return true; } else if (a instanceof Group) { if (b instanceof Group && groupEqual((Group) a, (Group) b, propertyOrderRelevant)) return true; } // Two BigDecimal objects that are equal in value but have a different // scale (like 2.0 and 2.00) should consider as equal. else if (a instanceof BigDecimal && b instanceof BigDecimal) { BigDecimal x = (BigDecimal) a; BigDecimal y = (BigDecimal) b; return x.compareTo(y) == 0; } else if (equals(a, b)) return true; return false; } // TODO better output for values in case of Collections? /** * Returns a string representation of the given instance. * * @param instance the instance * @return a string representation of the given instance */ public static String instanceToString(Instance instance) { StringBuilder builder = new StringBuilder(); if (instance.getValue() != null) builder.append("value=").append(instance.getValue()).append('\n'); builder.append("properties=[\n"); builder.append(indent(groupToString(instance))).append("\n]"); return builder.toString(); } /** * Returns a string representation of the given group. * * @param group the group * @return a string representation of the given group */ public static String groupToString(Group group) { StringBuilder builder = new StringBuilder(); boolean first = true; for (QName property : group.getPropertyNames()) { if (first) first = false; else builder.append('\n'); builder.append(property.toString()).append("=[\n"); for (Object propertyValue : group.getProperty(property)) { String representation; if (propertyValue instanceof Instance) representation = instanceToString((Instance) propertyValue); else if (propertyValue instanceof Group) representation = groupToString((Group) propertyValue); else if (propertyValue != null) { if (propertyValue.getClass().isArray()) { representation = arrayToList(propertyValue).toString(); } else { representation = propertyValue.toString(); } } else representation = "<null>"; builder.append(indent(representation)).append('\n'); } builder.append("]"); } return builder.toString(); } /** * Indents the given string with one tab. * * @param string the string to indent * @return the string indented with one tab */ private static String indent(String string) { return "\t" + string.replace("\n", "\n\t"); } /** * Creates a list of instances out of a FamilyInstance * * @param fi the FamilyInstance, may be <code>null</code> * @return a collection of instances or an empty list */ public static Collection<Instance> getInstanceOutOfFamily(FamilyInstance fi) { Collection<Instance> result = new ArrayList<Instance>(); if (fi != null) { result.add(fi); if (!fi.getChildren().isEmpty()) { for (FamilyInstance inst : fi.getChildren()) { if (!inst.getChildren().isEmpty()) { result.addAll(getInstanceOutOfFamily(inst)); } else result.add(inst); } } } return result; } }