/**
* Returns true if the given key is valid for the
*
* @link{TabularType} of this instance.
* @return true if the key is valid.
* @throws NullPointerException if <code>key</code> is null.
*/
private boolean isKeyValid(Object[] key) {
Iterator<String> it = tabularType.getIndexNames().iterator();
CompositeType rowType = tabularType.getRowType();
for (int a = 0; it.hasNext(); ++a) {
OpenType<?> type = rowType.getType(it.next());
if (!(type.isValue(key[a]))) return false;
}
return true;
}
/**
* Calculates the index the specified {@link CompositeData} value would have, if it was to be
* added to this {@link TabularData} instance. This method includes a check that the type of the
* given value is the same as the row type of this instance, but not a check for existing
* instances of the given value. The value must also not be <code>null</code>. Possible indices
* are selected by the {@link TabularType#getIndexNames()} method of this instance's tabular type.
* The returned indices are the values of the fields in the supplied {@link CompositeData}
* instance that match the names given in the {@link TabularType}.
*
* @param val the {@link CompositeData} value whose index should be calculated.
* @return the index the value would take on, if it were to be added.
* @throws NullPointerException if the value is <code>null</code>.
* @throws InvalidOpenTypeException if the value does not match the row type of this instance.
*/
public Object[] calculateIndex(CompositeData val) {
if (!(val.getCompositeType().equals(tabularType.getRowType())))
throw new InvalidOpenTypeException(
"The type of the given value " + "does not match the row type " + "of this instance.");
List<String> indexNames = tabularType.getIndexNames();
List<String> matchingIndicies = new ArrayList<String>(indexNames.size());
for (String name : indexNames) matchingIndicies.add(val.get(name).toString());
return matchingIndicies.toArray();
}
/**
* Returns the hash code of the composite data type. This is computed as the sum of the hash codes
* of each value, together with the hash code of the tabular type. These are the same elements of
* the type that are compared as part of the {@link #equals(java.lang.Object)} method, thus
* ensuring that the hashcode is compatible with the equality test.
*
* @return the hash code of this instance.
*/
public int hashCode() {
return tabularType.hashCode() + dataMap.values().hashCode();
}
/**
* Compares the specified object with this object for equality. The object is judged equivalent if
* it is non-null, and also an instance of {@link TabularData} with the same row type, and {@link
* CompositeData} values. The two compared instances may be equivalent even if they represent
* different implementations of {@link TabularData}.
*
* @param obj the object to compare for equality.
* @return true if <code>obj</code> is equal to <code>this</code>.
*/
public boolean equals(Object obj) {
if (!(obj instanceof TabularData)) return false;
TabularData data = (TabularData) obj;
return tabularType.equals(data.getTabularType()) && dataMap.values().equals(data.values());
}
/**
* Returns true iff this instance of the {@link TabularData} class contains the specified {@link
* CompositeData} value. In any other circumstance, including if the given value is <code>null
* </code> or of the incorrect type, according to the {@link TabularType} of this instance, this
* method returns false.
*
* @param val the value to test for.
* @return true if the value exists.
*/
public boolean containsValue(CompositeData val) {
if (val == null) return false;
if (!(val.getCompositeType().equals(tabularType.getRowType()))) return false;
return dataMap.containsValue(val);
}
