/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.web.bindery.autobean.shared;
import com.google.gwt.core.client.impl.WeakMapping;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* Utility methods for working with AutoBeans.
*/
public final class AutoBeanUtils {
/*
* TODO(bobv): Make Comparison a real type that holds a map contain the diff
* between the two objects. Then export a Map of PendingComparison to
* Comparisons as a public API to make it easy for developers to perform deep
* diffs across a graph structure.
*
* Three-way merge...
*/
private enum Comparison {
TRUE, FALSE, PENDING;
}
/**
* A Pair where order does not matter and the objects are compared by
* identity.
*/
private static class PendingComparison {
private final AutoBean<?> a;
private final AutoBean<?> b;
private final int hashCode;
public PendingComparison(AutoBean<?> a, AutoBean<?> b) {
this.a = a;
this.b = b;
// Don't make relatively prime since order does not matter
hashCode = System.identityHashCode(a) + System.identityHashCode(b);
}
@Override
public boolean equals(Object o) {
if (!(o instanceof PendingComparison)) {
return false;
}
PendingComparison other = (PendingComparison) o;
return a == other.a && b == other.b || // Direct match
a == other.b && b == other.a; // Swapped
}
@Override
public int hashCode() {
return hashCode;
}
}
/**
* Compare two graphs of AutoBeans based on values.
* <p>
* <ul>
* <li>AutoBeans are compared based on type and property values</li>
* <li>Lists are compared with element-order equality</li>
* <li>Sets and all other Collection types are compare with bag equality</li>
* <li>Maps are compared as a lists of keys-value pairs</li>
* <li>{@link Splittable Splittables} are compared by value</li>
* </ul>
* <p>
* This will work for both simple and wrapper AutoBeans.
* <p>
* This method may crawl the entire object graph reachable from the input
* parameters and may be arbitrarily expensive to compute.
*
* @param a an {@link AutoBean}
* @param b an {@link AutoBean}
* @return {@code false} if any values in the graph reachable through
* <code>a</code> are different from those reachable from
* <code>b</code>
*/
public static boolean deepEquals(AutoBean<?> a, AutoBean<?> b) {
return sameOrEquals(a, b, new HashMap<PendingComparison, Comparison>());
}
/**
* Returns a map of properties that differ (via {@link Object#equals(Object)})
* between two AutoBeans. The keys are property names and the values are the
* value of the property in <code>b</code>. Properties present in
* <code>a</code> but missing in <code>b</code> will be represented by
* <code>null</code> values. This implementation will compare AutoBeans of
* different parameterizations, although the diff produced is likely
* meaningless.
* <p>
* This will work for both simple and wrapper AutoBeans.
*
* @param a an {@link AutoBean}
* @param b an {@link AutoBean}
* @return a {@link Map} of differing properties
*/
public static Map<String, Object> diff(AutoBean<?> a, AutoBean<?> b) {
// Fast check for comparing an object to itself
if (a.equals(b)) {
return Collections.emptyMap();
}
final Map<String, Object> toReturn = getAllProperties(b);
// Remove the entries that are equal, adding nulls for missing properties
a.accept(new AutoBeanVisitor() {
@Override
public boolean visitReferenceProperty(String propertyName, AutoBean<?> previousValue,
PropertyContext ctx) {
if (toReturn.containsKey(propertyName)) {
if (equal(propertyName, previousValue)) {
// No change
toReturn.remove(propertyName);
}
} else {
// The predecessor has a value that this object doesn't.
toReturn.put(propertyName, null);
}
return false;
}
@Override
public boolean visitValueProperty(String propertyName, Object previousValue,
PropertyContext ctx) {
if (toReturn.containsKey(propertyName)) {
if (equal(propertyName, previousValue)) {
// No change
toReturn.remove(propertyName);
}
} else {
// The predecessor has a value that this object doesn't.
toReturn.put(propertyName, null);
}
return false;
}
private boolean equal(String propertyName, AutoBean<?> previousValue) {
return previousValue == null && toReturn.get(propertyName) == null || previousValue != null
&& equal(propertyName, previousValue.as());
}
private boolean equal(String propertyName, Object previousValue) {
Object currentValue = toReturn.get(propertyName);
return previousValue == null && currentValue == null || previousValue != null
&& previousValue.equals(currentValue);
}
});
return toReturn;
}
/**
* Returns a map that is a copy of the properties contained in an AutoBean.
* The returned map is mutable, but editing it will not have any effect on the
* bean that produced it.
*
* @param bean an {@link AutoBean}
* @return a {@link Map} of the bean's properties
*/
public static Map<String, Object> getAllProperties(AutoBean<?> bean) {
final Map<String, Object> toReturn = new LinkedHashMap<String, Object>();
// Look at the previous value of all properties
bean.accept(new AutoBeanVisitor() {
@Override
public boolean visitReferenceProperty(String propertyName, AutoBean<?> value,
PropertyContext ctx) {
toReturn.put(propertyName, value == null ? null : value.as());
return false;
}
@Override
public boolean visitValueProperty(String propertyName, Object value, PropertyContext ctx) {
toReturn.put(propertyName, value);
return false;
}
});
return toReturn;
}
/**
* Return the single AutoBean wrapper that is observing the delegate object or
* {@code null} if the parameter is {@code null}or not wrapped by an AutoBean.
*
* @param delegate a delegate object, or {@code null}
* @return the {@link AutoBean} wrapper for the delegate, or {@code null}
*/
@SuppressWarnings("unchecked")
public static <T, U extends T> AutoBean<T> getAutoBean(U delegate) {
return delegate == null ? null : (AutoBean<T>) WeakMapping.get(delegate, AutoBean.class
.getName());
}
/**
* Compare two AutoBeans, this method has the type fan-out.
*/
static boolean sameOrEquals(Object value, Object otherValue,
Map<PendingComparison, Comparison> pending) {
if (value == otherValue) {
// Fast exit
return true;
}
if (value instanceof Collection<?> && otherValue instanceof Collection<?>) {
// Check collections
return sameOrEquals((Collection<?>) value, (Collection<?>) otherValue, pending, null);
}
if (value instanceof Map<?, ?> && otherValue instanceof Map<?, ?>) {
// Check maps
return sameOrEquals((Map<?, ?>) value, (Map<?, ?>) otherValue, pending);
}
if (value instanceof Splittable && otherValue instanceof Splittable) {
return sameOrEquals((Splittable) value, (Splittable) otherValue, pending);
}
// Possibly substitute the AutoBean for its shim
{
AutoBean<?> maybeValue = AutoBeanUtils.getAutoBean(value);
AutoBean<?> maybeOther = AutoBeanUtils.getAutoBean(otherValue);
if (maybeValue != null && maybeOther != null) {
value = maybeValue;
otherValue = maybeOther;
}
}
if (value instanceof AutoBean<?> && otherValue instanceof AutoBean<?>) {
// Check ValueProxies
return sameOrEquals((AutoBean<?>) value, (AutoBean<?>) otherValue, pending);
}
if (value == null ^ otherValue == null) {
// One is null, the other isn't
return false;
}
if (value != null && !value.equals(otherValue)) {
// Regular object equality
return false;
}
return true;
}
/**
* If a comparison between two AutoBeans is currently pending, this method
* will skip their comparison.
*/
private static boolean sameOrEquals(AutoBean<?> value, AutoBean<?> otherValue,
Map<PendingComparison, Comparison> pending) {
if (value == otherValue) {
// Simple case
return true;
} else if (!value.getType().equals(otherValue.getType())) {
// Beans of different types
return false;
}
/*
* The PendingComparison key allows us to break reference cycles when
* crawling the graph. Since the entire operation is essentially a
* concatenated && operation, it's ok to speculatively return true for
* repeated a.equals(b) tests.
*/
PendingComparison key = new PendingComparison(value, otherValue);
Comparison previous = pending.get(key);
if (previous == null) {
// Prevent the same comparison from being made
pending.put(key, Comparison.PENDING);
// Compare each property
Map<String, Object> beanProperties = AutoBeanUtils.getAllProperties(value);
Map<String, Object> otherProperties = AutoBeanUtils.getAllProperties(otherValue);
for (Map.Entry<String, Object> entry : beanProperties.entrySet()) {
Object property = entry.getValue();
Object otherProperty = otherProperties.get(entry.getKey());
if (!sameOrEquals(property, otherProperty, pending)) {
pending.put(key, Comparison.FALSE);
return false;
}
}
pending.put(key, Comparison.TRUE);
return true;
} else {
// Return true for TRUE or PENDING
return !Comparison.FALSE.equals(previous);
}
}
/**
* Compare two collections by size, then by contents. List comparisons will
* preserve order. All other collections will be treated with bag semantics.
*/
private static boolean sameOrEquals(Collection<?> collection, Collection<?> otherCollection,
Map<PendingComparison, Comparison> pending, Map<Object, Object> pairs) {
if (collection.size() != otherCollection.size()) {
return false;
}
if (collection instanceof List<?>) {
// Lists we can simply iterate over
Iterator<?> it = collection.iterator();
Iterator<?> otherIt = otherCollection.iterator();
while (it.hasNext()) {
assert otherIt.hasNext();
Object element = it.next();
Object otherElement = otherIt.next();
if (!sameOrEquals(element, otherElement, pending)) {
return false;
}
if (pairs != null) {
pairs.put(element, otherElement);
}
}
} else {
// Do an n*m comparison on any other collection type
List<Object> values = new ArrayList<Object>(collection);
List<Object> otherValues = new ArrayList<Object>(otherCollection);
it : for (Iterator<Object> it = values.iterator(); it.hasNext();) {
Object value = it.next();
for (Iterator<Object> otherIt = otherValues.iterator(); otherIt.hasNext();) {
Object otherValue = otherIt.next();
if (sameOrEquals(value, otherValue, pending)) {
if (pairs != null) {
pairs.put(value, otherValue);
}
// If a match is found, remove both values from their lists
it.remove();
otherIt.remove();
continue it;
}
}
// A match for the value wasn't found
return false;
}
assert values.isEmpty() && otherValues.isEmpty();
}
return true;
}
/**
* Compare two Maps by size, and key-value pairs.
*/
private static boolean sameOrEquals(Map<?, ?> map, Map<?, ?> otherMap,
Map<PendingComparison, Comparison> pending) {
if (map.size() != otherMap.size()) {
return false;
}
Map<Object, Object> pairs = new IdentityHashMap<Object, Object>();
if (!sameOrEquals(map.keySet(), otherMap.keySet(), pending, pairs)) {
return false;
}
for (Map.Entry<?, ?> entry : map.entrySet()) {
Object otherValue = otherMap.get(pairs.get(entry.getKey()));
if (!sameOrEquals(entry.getValue(), otherValue, pending)) {
return false;
}
}
return true;
}
/**
* Compare Splittables by kind and values.
*/
private static boolean sameOrEquals(Splittable value, Splittable otherValue,
Map<PendingComparison, Comparison> pending) {
if (value == otherValue) {
return true;
}
// Strings
if (value.isString()) {
if (!otherValue.isString()) {
return false;
}
return value.asString().equals(otherValue.asString());
}
// Arrays
if (value.isIndexed()) {
if (!otherValue.isIndexed()) {
return false;
}
if (value.size() != otherValue.size()) {
return false;
}
for (int i = 0, j = value.size(); i < j; i++) {
if (!sameOrEquals(value.get(i), otherValue.get(i), pending)) {
return false;
}
}
return true;
}
// Objects
if (value.isKeyed()) {
if (!otherValue.isKeyed()) {
return false;
}
/*
* We want to treat a missing property key as a null value, so we can't
* just compare the key lists.
*/
List<String> keys = value.getPropertyKeys();
for (String key : keys) {
if (value.isNull(key)) {
// If value['foo'] is null, other['foo'] must also be null
if (!otherValue.isNull(key)) {
return false;
}
} else if (otherValue.isNull(key)
|| !sameOrEquals(value.get(key), otherValue.get(key), pending)) {
return false;
}
}
// Look at keys only in otherValue, and ensure nullness
List<String> otherKeys = new ArrayList<String>(otherValue.getPropertyKeys());
otherKeys.removeAll(keys);
for (String key : otherKeys) {
if (!value.isNull(key)) {
return false;
}
}
return true;
}
// Unexpected
throw new UnsupportedOperationException("Splittable of unknown type");
}
/**
* Utility class.
*/
private AutoBeanUtils() {
}
}