/*
* @(#)HashAttributeSet.java 1.12 04/05/05
*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
package javax.print.attribute;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.HashMap;
/**
* Class HashAttributeSet provides an <code>AttributeSet</code>
* implementation with characteristics of a hash map.
* <P>
*
* @author Alan Kaminsky
*/
public class HashAttributeSet implements AttributeSet, Serializable {
private static final long serialVersionUID = 5311560590283707917L;
/**
* The interface of which all members of this attribute set must be an
* instance. It is assumed to be interface {@link Attribute Attribute}
* or a subinterface thereof.
* @serial
*/
private Class myInterface;
/*
* A HashMap used by the implementation.
* The serialised form doesn't include this instance variable.
*/
private transient HashMap attrMap = new HashMap();
/**
* Write the instance to a stream (ie serialize the object)
*
* @serialData
* The serialized form of an attribute set explicitly writes the
* number of attributes in the set, and each of the attributes.
* This does not guarantee equality of serialized forms since
* the order in which the attributes are written is not defined.
*/
private void writeObject(ObjectOutputStream s) throws IOException {
s.defaultWriteObject();
Attribute [] attrs = toArray();
s.writeInt(attrs.length);
for (int i = 0; i < attrs.length; i++) {
s.writeObject(attrs[i]);
}
}
/**
* Reconstitute an instance from a stream that is, deserialize it).
*/
private void readObject(ObjectInputStream s)
throws ClassNotFoundException, IOException {
s.defaultReadObject();
attrMap = new HashMap();
int count = s.readInt();
Attribute attr;
for (int i = 0; i < count; i++) {
attr = (Attribute)s.readObject();
add(attr);
}
}
/**
* Construct a new, empty attribute set.
*/
public HashAttributeSet() {
this(Attribute.class);
}
/**
* Construct a new attribute set,
* initially populated with the given attribute.
*
* @param attribute Attribute value to add to the set.
*
* @exception NullPointerException
* (unchecked exception) Thrown if <CODE>attribute</CODE> is null.
*/
public HashAttributeSet(Attribute attribute) {
this (attribute, Attribute.class);
}
/**
* Construct a new attribute set,
* initially populated with the values from the
* given array. The new attribute set is populated by
* adding the elements of <CODE>attributes</CODE> array to the set in
* sequence, starting at index 0. Thus, later array elements may replace
* earlier array elements if the array contains duplicate attribute
* values or attribute categories.
*
* @param attributes Array of attribute values to add to the set.
* If null, an empty attribute set is constructed.
*
* @exception NullPointerException
* (unchecked exception) Thrown if any element of
* <CODE>attributes</CODE> is null.
*/
public HashAttributeSet(Attribute[] attributes) {
this (attributes, Attribute.class);
}
/**
* Construct a new attribute set,
* initially populated with the values from the given set.
*
* @param attributes Set of attributes from which to initialise this set.
* If null, an empty attribute set is constructed.
*
*/
public HashAttributeSet(AttributeSet attributes) {
this (attributes, Attribute.class);
}
/**
* Construct a new, empty attribute set, where the members of
* the attribute set are restricted to the given interface.
*
* @param interfaceName The interface of which all members of this
* attribute set must be an instance. It is assumed to
* be interface {@link Attribute Attribute} or a
* subinterface thereof.
* @exception NullPointerException if interfaceName is null.
*/
protected HashAttributeSet(Class<?> interfaceName) {
if (interfaceName == null) {
throw new NullPointerException("null interface");
}
myInterface = interfaceName;
}
/**
* Construct a new attribute set, initially populated with the given
* attribute, where the members of the attribute set are restricted to the
* given interface.
*
* @param attribute Attribute value to add to the set.
* @param interfaceName The interface of which all members of this
* attribute set must be an instance. It is assumed to
* be interface {@link Attribute Attribute} or a
* subinterface thereof.
*
* @exception NullPointerException
* (unchecked exception) Thrown if <CODE>attribute</CODE> is null.
* @exception NullPointerException if interfaceName is null.
* @exception ClassCastException
* (unchecked exception) Thrown if <CODE>attribute</CODE> is not an
* instance of <CODE>interfaceName</CODE>.
*/
protected HashAttributeSet(Attribute attribute, Class<?> interfaceName) {
if (interfaceName == null) {
throw new NullPointerException("null interface");
}
myInterface = interfaceName;
add (attribute);
}
/**
* Construct a new attribute set, where the members of the attribute
* set are restricted to the given interface.
* The new attribute set is populated
* by adding the elements of <CODE>attributes</CODE> array to the set in
* sequence, starting at index 0. Thus, later array elements may replace
* earlier array elements if the array contains duplicate attribute
* values or attribute categories.
*
* @param attributes Array of attribute values to add to the set. If
* null, an empty attribute set is constructed.
* @param interfaceName The interface of which all members of this
* attribute set must be an instance. It is assumed to
* be interface {@link Attribute Attribute} or a
* subinterface thereof.
*
* @exception NullPointerException
* (unchecked exception) Thrown if any element of
* <CODE>attributes</CODE> is null.
* @exception NullPointerException if interfaceName is null.
* @exception ClassCastException
* (unchecked exception) Thrown if any element of
* <CODE>attributes</CODE> is not an instance of
* <CODE>interfaceName</CODE>.
*/
protected HashAttributeSet(Attribute[] attributes, Class<?> interfaceName) {
if (interfaceName == null) {
throw new NullPointerException("null interface");
}
myInterface = interfaceName;
int n = attributes == null ? 0 : attributes.length;
for (int i = 0; i < n; ++ i) {
add (attributes[i]);
}
}
/**
* Construct a new attribute set, initially populated with the
* values from the given set where the members of the attribute
* set are restricted to the given interface.
*
* @param attributes set of attribute values to initialise the set. If
* null, an empty attribute set is constructed.
* @param interfaceName The interface of which all members of this
* attribute set must be an instance. It is assumed to
* be interface {@link Attribute Attribute} or a
* subinterface thereof.
*
* @exception ClassCastException
* (unchecked exception) Thrown if any element of
* <CODE>attributes</CODE> is not an instance of
* <CODE>interfaceName</CODE>.
*/
protected HashAttributeSet(AttributeSet attributes, Class<?> interfaceName) {
myInterface = interfaceName;
if (attributes != null) {
Attribute[] attribArray = attributes.toArray();
int n = attribArray == null ? 0 : attribArray.length;
for (int i = 0; i < n; ++ i) {
add (attribArray[i]);
}
}
}
/**
* Returns the attribute value which this attribute set contains in the
* given attribute category. Returns <tt>null</tt> if this attribute set
* does not contain any attribute value in the given attribute category.
*
* @param category Attribute category whose associated attribute value
* is to be returned. It must be a
* {@link java.lang.Class Class}
* that implements interface {@link Attribute
* Attribute}.
*
* @return The attribute value in the given attribute category contained
* in this attribute set, or <tt>null</tt> if this attribute set
* does not contain any attribute value in the given attribute
* category.
*
* @throws NullPointerException
* (unchecked exception) Thrown if the <CODE>category</CODE> is null.
* @throws ClassCastException
* (unchecked exception) Thrown if the <CODE>category</CODE> is not a
* {@link java.lang.Class Class} that implements interface {@link
* Attribute Attribute}.
*/
public Attribute get(Class<?> category) {
return (Attribute)
attrMap.get(AttributeSetUtilities.
verifyAttributeCategory(category,
Attribute.class));
}
/**
* Adds the specified attribute to this attribute set if it is not
* already present, first removing any existing in the same
* attribute category as the specified attribute value.
*
* @param attribute Attribute value to be added to this attribute set.
*
* @return <tt>true</tt> if this attribute set changed as a result of the
* call, i.e., the given attribute value was not already a
* member of this attribute set.
*
* @throws NullPointerException
* (unchecked exception) Thrown if the <CODE>attribute</CODE> is null.
* @throws UnmodifiableSetException
* (unchecked exception) Thrown if this attribute set does not support
* the <CODE>add()</CODE> operation.
*/
public boolean add(Attribute attribute) {
Object oldAttribute =
attrMap.put(attribute.getCategory(),
AttributeSetUtilities.
verifyAttributeValue(attribute, myInterface));
return (!attribute.equals(oldAttribute));
}
/**
* Removes any attribute for this category from this attribute set if
* present. If <CODE>category</CODE> is null, then
* <CODE>remove()</CODE> does nothing and returns <tt>false</tt>.
*
* @param category Attribute category to be removed from this
* attribute set.
*
* @return <tt>true</tt> if this attribute set changed as a result of the
* call, i.e., the given attribute category had been a member of
* this attribute set.
*
* @throws UnmodifiableSetException
* (unchecked exception) Thrown if this attribute set does not
* support the <CODE>remove()</CODE> operation.
*/
public boolean remove(Class<?> category) {
return
category != null &&
AttributeSetUtilities.
verifyAttributeCategory(category, Attribute.class) != null &&
attrMap.remove(category) != null;
}
/**
* Removes the specified attribute from this attribute set if
* present. If <CODE>attribute</CODE> is null, then
* <CODE>remove()</CODE> does nothing and returns <tt>false</tt>.
*
* @param attribute Attribute value to be removed from this attribute set.
*
* @return <tt>true</tt> if this attribute set changed as a result of the
* call, i.e., the given attribute value had been a member of
* this attribute set.
*
* @throws UnmodifiableSetException
* (unchecked exception) Thrown if this attribute set does not
* support the <CODE>remove()</CODE> operation.
*/
public boolean remove(Attribute attribute) {
return
attribute != null &&
attrMap.remove(attribute.getCategory()) != null;
}
/**
* Returns <tt>true</tt> if this attribute set contains an
* attribute for the specified category.
*
* @param category whose presence in this attribute set is
* to be tested.
*
* @return <tt>true</tt> if this attribute set contains an attribute
* value for the specified category.
*/
public boolean containsKey(Class<?> category) {
return
category != null &&
AttributeSetUtilities.
verifyAttributeCategory(category, Attribute.class) != null &&
attrMap.get(category) != null;
}
/**
* Returns <tt>true</tt> if this attribute set contains the given
* attribute.
*
* @param attribute value whose presence in this attribute set is
* to be tested.
*
* @return <tt>true</tt> if this attribute set contains the given
* attribute value.
*/
public boolean containsValue(Attribute attribute) {
return
attribute != null &&
attribute instanceof Attribute &&
attribute.equals(attrMap.get(((Attribute)attribute).getCategory()));
}
/**
* Adds all of the elements in the specified set to this attribute.
* The outcome is the same as if the
* {@link #add(Attribute) <CODE>add(Attribute)</CODE>}
* operation had been applied to this attribute set successively with
* each element from the specified set.
* The behavior of the <CODE>addAll(AttributeSet)</CODE>
* operation is unspecified if the specified set is modified while
* the operation is in progress.
* <P>
* If the <CODE>addAll(AttributeSet)</CODE> operation throws an exception,
* the effect on this attribute set's state is implementation dependent;
* elements from the specified set before the point of the exception may
* or may not have been added to this attribute set.
*
* @param attributes whose elements are to be added to this attribute
* set.
*
* @return <tt>true</tt> if this attribute set changed as a result of the
* call.
*
* @throws UnmodifiableSetException
* (Unchecked exception) Thrown if this attribute set does not
* support the <tt>addAll(AttributeSet)</tt> method.
* @throws NullPointerException
* (Unchecked exception) Thrown if some element in the specified
* set is null, or the set is null.
*
* @see #add(Attribute)
*/
public boolean addAll(AttributeSet attributes) {
Attribute []attrs = attributes.toArray();
boolean result = false;
for (int i=0; i<attrs.length; i++) {
Attribute newValue =
AttributeSetUtilities.verifyAttributeValue(attrs[i],
myInterface);
Object oldValue = attrMap.put(newValue.getCategory(), newValue);
result = (! newValue.equals(oldValue)) || result;
}
return result;
}
/**
* Returns the number of attributes in this attribute set. If this
* attribute set contains more than <tt>Integer.MAX_VALUE</tt> elements,
* returns <tt>Integer.MAX_VALUE</tt>.
*
* @return The number of attributes in this attribute set.
*/
public int size() {
return attrMap.size();
}
/**
*
* @return the Attributes contained in this set as an array, zero length
* if the AttributeSet is empty.
*/
public Attribute[] toArray() {
Attribute []attrs = new Attribute[size()];
attrMap.values().toArray(attrs);
return attrs;
}
/**
* Removes all attributes from this attribute set.
*
* @throws UnmodifiableSetException
* (unchecked exception) Thrown if this attribute set does not support
* the <CODE>clear()</CODE> operation.
*/
public void clear() {
attrMap.clear();
}
/**
* Returns true if this attribute set contains no attributes.
*
* @return true if this attribute set contains no attributes.
*/
public boolean isEmpty() {
return attrMap.isEmpty();
}
/**
* Compares the specified object with this attribute set for equality.
* Returns <tt>true</tt> if the given object is also an attribute set and
* the two attribute sets contain the same attribute category-attribute
* value mappings. This ensures that the
* <tt>equals()</tt> method works properly across different
* implementations of the AttributeSet interface.
*
* @param object to be compared for equality with this attribute set.
*
* @return <tt>true</tt> if the specified object is equal to this
* attribute set.
*/
public boolean equals(Object object) {
if (object == null || !(object instanceof AttributeSet)) {
return false;
}
AttributeSet aset = (AttributeSet)object;
if (aset.size() != size()) {
return false;
}
Attribute[] attrs = toArray();
for (int i=0;i<attrs.length; i++) {
if (!aset.containsValue(attrs[i])) {
return false;
}
}
return true;
}
/**
* Returns the hash code value for this attribute set.
* The hash code of an attribute set is defined to be the sum
* of the hash codes of each entry in the AttributeSet.
* This ensures that <tt>t1.equals(t2)</tt> implies that
* <tt>t1.hashCode()==t2.hashCode()</tt> for any two attribute sets
* <tt>t1</tt> and <tt>t2</tt>, as required by the general contract of
* {@link java.lang.Object#hashCode() <CODE>Object.hashCode()</CODE>}.
*
* @return The hash code value for this attribute set.
*/
public int hashCode() {
int hcode = 0;
Attribute[] attrs = toArray();
for (int i=0;i<attrs.length; i++) {
hcode += attrs[i].hashCode();
}
return hcode;
}
}
|
