SimpleAttributeSet with the same attributes
* and resolve parent as the specified set.
*
* @param a the attributes (null not permitted).
*
* @throws NullPointerException if a is null.
*/
public SimpleAttributeSet(AttributeSet a)
{
tab = new Hashtable();
addAttributes(a);
}
/**
* Adds an attribute with the given name and value
* to the set. If the set already contains an attribute with the given
* name, the attribute value is updated.
*
* @param name the attribute name (null not permitted).
* @param value the value (null not permitted).
*
* @throws NullPointerException if either argument is null.
*/
public void addAttribute(Object name, Object value)
{
tab.put(name, value);
}
/**
* Adds all the attributes from attributes to this set.
*
* @param attributes the set of attributes to add (null not
* permitted).
*
* @throws NullPointerException if attributes is
* null.
*/
public void addAttributes(AttributeSet attributes)
{
Enumeration e = attributes.getAttributeNames();
while (e.hasMoreElements())
{
Object name = e.nextElement();
Object val = attributes.getAttribute(name);
tab.put(name, val);
}
}
/**
* Returns a clone of the attribute set.
*
* @return A clone of the attribute set.
*/
public Object clone()
{
SimpleAttributeSet attr = null;
try
{
attr = (SimpleAttributeSet) super.clone();
attr.tab = (Hashtable) tab.clone();
}
catch (CloneNotSupportedException ex)
{
assert false;
}
return attr;
}
/**
* Returns true if the given name and value represent an attribute
* found either in this AttributeSet or in its resolve parent hierarchy.
* @param name the key for the attribute
* @param value the value for the attribute
* @return true if the attribute is found here or in this set's resolve
* parent hierarchy
*/
public boolean containsAttribute(Object name, Object value)
{
if (value == null)
throw new NullPointerException("Null 'value' argument.");
if (tab.containsKey(name))
return tab.get(name).equals(value);
else
{
AttributeSet p = getResolveParent();
if (p != null)
return p.containsAttribute(name, value);
else
return false;
}
}
/**
* Returns true if the given name and value are found in this AttributeSet.
* Does not check the resolve parent.
* @param name the key for the attribute
* @param value the value for the attribute
* @return true if the attribute is found in this AttributeSet
*/
boolean containsAttributeLocally(Object name, Object value)
{
return tab.containsKey(name)
&& tab.get(name).equals(value);
}
/**
* Returns true of this AttributeSet contains all
* of the specified attributes.
*
* @param attributes the requested attributes
*
* @return true of this AttributeSet contains all
* of the specified attributes
*/
public boolean containsAttributes(AttributeSet attributes)
{
Enumeration e = attributes.getAttributeNames();
while (e.hasMoreElements())
{
Object name = e.nextElement();
Object val = attributes.getAttribute(name);
if (! containsAttribute(name, val))
return false;
}
return true;
}
/**
* Creates and returns a copy of this AttributeSet.
*
* @return a copy of this AttributeSet
*/
public AttributeSet copyAttributes()
{
return (AttributeSet) clone();
}
/**
* Checks this set for equality with an arbitrary object.
*
* @param obj the object (null permitted).
*
* @return true if this set is equal to obj, and
* false otherwise.
*/
public boolean equals(Object obj)
{
return
(obj instanceof AttributeSet)
&& this.isEqual((AttributeSet) obj);
}
/**
* Returns the value of the specified attribute, or null if
* there is no attribute with that name. If the attribute is not defined
* directly in this set, the parent hierarchy (if there is one) will be
* used.
*
* @param name the attribute (null not permitted).
*
* @throws NullPointerException if name is null.
*/
public Object getAttribute(Object name)
{
Object val = tab.get(name);
if (val != null)
return val;
AttributeSet p = getResolveParent();
if (p != null)
return p.getAttribute(name);
return null;
}
/**
* Returns the number of attributes stored in this set, plus 1 if a parent
* has been specified (the reference to the parent is stored as a special
* attribute). The attributes stored in the parent do NOT contribute
* to the count.
*
* @return The attribute count.
*/
public int getAttributeCount()
{
return tab.size();
}
/**
* Returns an enumeration of the attribute names.
*
* @return An enumeration of the attribute names.
*/
public Enumeration getAttributeNames()
{
return tab.keys();
}
/**
* Returns the resolving parent.
*
* @return The resolving parent (possibly null).
*
* @see #setResolveParent(AttributeSet)
*/
public AttributeSet getResolveParent()
{
return (AttributeSet) tab.get(ResolveAttribute);
}
/**
* Returns a hash code for this instance.
*
* @return A hash code.
*/
public int hashCode()
{
return tab.hashCode();
}
/**
* Returns true if the given attribute is defined in this set,
* and false otherwise. The parent attribute set is not
* checked.
*
* @param attrName the attribute name (null not permitted).
*/
public boolean isDefined(Object attrName)
{
return tab.containsKey(attrName);
}
/**
* Returns true if the set contains no attributes, and
* false otherwise. Note that the resolving parent is
* stored as an attribute, so this method will return false if
* a resolving parent is set.
*
* @return true if the set contains no attributes, and
* false otherwise.
*/
public boolean isEmpty()
{
return tab.isEmpty();
}
/**
* Returns true if the given set has the same number of attributes
* as this set and containsAttributes(attr) returns
* true.
*
* @param attr the attribute set (null not permitted).
*
* @return A boolean.
*
* @throws NullPointerException if attr is null.
*/
public boolean isEqual(AttributeSet attr)
{
return getAttributeCount() == attr.getAttributeCount()
&& this.containsAttributes(attr);
}
/**
* Removes the attribute with the specified name, if this
* attribute is defined. This method will only remove an attribute from
* this set, not from the resolving parent.
*
* @param name the attribute name (null not permitted).
*
* @throws NullPointerException if name is null.
*/
public void removeAttribute(Object name)
{
tab.remove(name);
}
/**
* Removes attributes from this set if they are found in the
* given set. Only attributes whose key AND value are removed.
* Removes attributes only from this set, not from the resolving parent.
* Since the resolving parent is stored as an attribute, if
* attributes has the same resolving parent as this set, the
* parent will be removed from this set.
*
* @param attributes the attributes (null not permitted).
*/
public void removeAttributes(AttributeSet attributes)
{
Enumeration e = attributes.getAttributeNames();
while (e.hasMoreElements())
{
Object name = e.nextElement();
Object val = attributes.getAttribute(name);
if (containsAttributeLocally(name, val))
removeAttribute(name);
}
}
/**
* Removes the attributes listed in names.
*
* @param names the attribute names (null not permitted).
*
* @throws NullPointerException if names is null
* or contains any null values.
*/
public void removeAttributes(Enumeration names)
{
while (names.hasMoreElements())
{
removeAttribute(names.nextElement());
}
}
/**
* Sets the reolving parent for this set. When looking up an attribute, if
* it is not found in this set, then the resolving parent is also used for
* the lookup.
*
* Note that the parent is stored as an attribute, and will contribute 1 to
* the count returned by {@link #getAttributeCount()}.
*
* @param parent the parent attribute set (null not permitted).
*
* @throws NullPointerException if parent is null.
*
* @see #setResolveParent(AttributeSet)
*/
public void setResolveParent(AttributeSet parent)
{
addAttribute(ResolveAttribute, parent);
}
/**
* Returns a string representation of this instance, typically used for
* debugging purposes.
*
* @return A string representation of this instance.
*/
public String toString()
{
return tab.toString();
}
}