equals, hashCode, and
* toString. Implementations of the Entry
* interface may, but are not required to, extend this class.
*
* The methods of this class consult the entry fields of the
* entries they process. The entry fields of an Entry are
* its public, non-primitive, non-static, non-transient, non-final
* fields.
*
*
* @see Entry
*/
public abstract class AbstractEntry implements Entry {
static final long serialVersionUID = 5071868345060424804L;
/**
* Creates an instance of this class.
*/
protected AbstractEntry() { }
/**
* Compares this AbstractEntry to the specified
* object. If other is null or not an
* instance of {@link Entry} returns false,
* otherwise returns the result of calling {@link #equals(Entry,Entry)
* AbstractEntry.equals(this, (Entry) other)}.
* @param other the object to compare this AbstractEntry
* against
* @return true if this object is equivalent
* to other and false otherwise
*/
public boolean equals(Object other) {
if (!(other instanceof Entry))
return false;
return equals(this, (Entry) other);
}
/**
* Returns true if the two arguments are of the same
* class and for each entry field F, the arguments'
* values for F are either both null or the
* invocation of equals on one argument's value for
* F with the other argument's value for F as
* its parameter returns true. Will also return
* true if both arguments are null. In
* all other cases an invocation of this method will return
* false.
*
* @param e1 an entry object to compare to e2
* @param e2 an entry object to compare to e1
* @return true if the two arguments are equivalent
*/
public static boolean equals(Entry e1, Entry e2) {
if (e1 == e2)
return true;
// Note, if both e1 and e2 are null the previous test would
// have returned true.
if (e1 == null || e2 == null)
return false;
if (e1.getClass() != e2.getClass())
return false;
Field[] fields = fieldInfo(e1);
try {
// compare each field
for (int i = 0; i < fields.length; i++) {
// f works for other since other is the same type as this
Field f = fields[i];
Object ov = f.get(e1);
Object tv = f.get(e2);
if (tv == ov) // same obj or both null is OK
continue;
if (tv == null || ov == null) // if only one is null, not OK
return false;
if (!tv.equals(ov)) // not equals is not OK
return false;
}
return true;
} catch (IllegalAccessException e) {
// should never happen, all entry fields are public
throw new AssertionError(e);
}
}
/**
* Returns the result of calling {@link #hashCode(Entry)
* AbstractEntry.hashCode(this)}.
* @return the result of calling {@link #hashCode(Entry)
* AbstractEntry.hashCode(this)}
*/
public int hashCode() {
return hashCode(this);
}
/**
* Returns zero XORed with the result of invoking
* hashCode on each of the argument's
* non-null entry fields. Returns 0 if
* the argument is null.
*
* @param entry the Entry for which to generate a
* hash code
* @return a hash code formed by XORing the hash codes of
* entry's non-null entry field,
* or 0 if entry is
* null
*/
public static int hashCode(Entry entry) {
if (entry == null)
return 0;
int hash = 0;
Field[] fields = fieldInfo(entry);
try {
for (int i = 0; i < fields.length; i++) {
Object tv = fields[i].get(entry);
if (tv != null)
hash ^= tv.hashCode();
}
return hash;
} catch (IllegalAccessException e) {
// should never happen, all entry fields are public
throw new AssertionError(e);
}
}
/**
* Returns the result of calling {@link #toString(Entry)
* AbstractEntry.toString(this)}.
* @return the result of calling {@link #toString(Entry)
* AbstractEntry.toString(this)}
*/
public String toString() {
return toString(this);
}
/**
* Returns a String representation of its argument
* that will contain the name of the argument's class and a
* representation of each of the argument's entry fields. The
* representation of each entry field will include the field's
* name and a representation of its value. If passed
* null will return the string "null".
*
* @param entry an entry to represent as a String
* @return a String representation of
* entry that contains the name of the
* entry's class and a representation of each
* of entry's entry fields
*/
public static String toString(Entry entry) {
if (entry == null)
return "null";
Field[] fields = fieldInfo(entry);
StringBuffer str = new StringBuffer(entry.getClass().getName());
str.append('('); // later matched with a ')'
for (int i = 0; i < fields.length; i++) {
try {
Field f = fields[i];
if (i > 0)
str.append(',');
str.append(f.getName());
str.append('=');
str.append(f.get(entry));
} catch (IllegalAccessException e) {
// should never happen, all entry fields are public
throw new AssertionError(e);
}
}
// now add the ending '('
str.append(')');
return str.toString();
}
private static WeakHashMap fieldArrays;
/**
* Calculate the list of usable fields for this type
*/
private static Field[] fieldInfo(Entry entry) {
Field[] fields = null;
synchronized (AbstractEntry.class) {
if (fieldArrays == null)
fieldArrays = new WeakHashMap();
else {
fields = (Field[]) fieldArrays.get(entry.getClass());
if (fields != null)
return fields;
}
}
/*
* Scan the array to see if we can use it or if we must build up
* a smaller array because we must skip some fields. If so, we
* create an ArrayList and add the unskippable fields to it, and
* then fetch the array back out of it.
*/
final int SKIP_MODIFIERS =
(Modifier.STATIC | Modifier.TRANSIENT | Modifier.FINAL);
fields = entry.getClass().getFields();
ArrayList usable = null;
for (int i = 0; i < fields.length; i++) {
// exclude this one?
if ((fields[i].getModifiers() & SKIP_MODIFIERS) != 0 ||
(fields[i].getType().isPrimitive()))
{
if (usable == null) { // first excluded: set up for it
usable = new ArrayList(); // allocate the list of usable
for (int j = 0; j < i; j++) // earlier fields are usable
usable.add(fields[j]);
}
} else { // not excluded
if (usable != null) // tracking usable fields?
usable.add(fields[i]);
}
}
if (usable != null)
fields = (Field[]) usable.toArray(new Field[usable.size()]);
synchronized (AbstractEntry.class) {
// We could check to make sure someone else
// has not already stuck a value for entry.getClass() in,
// fieldArrays but there should be no harm in an overwrite
// and if anything likely to be less efficient
fieldArrays.put(entry.getClass(), fields);
}
return fields;
}
}