"Attr" implementation. In DOM, attributes cost quite a lot of * memory because their values are complex structures rather than just * simple strings. To reduce your costs, avoid having more than one * child of an attribute; stick to a single Text node child, and ignore * even that by using the attribute's "nodeValue" property.
* *As a bit of general advice, only look at attribute modification * events through the DOMAttrModified event (sent to the associated * element). Implementations are not guaranteed to report other events * in the same order, so you're very likely to write nonportable code if * you monitor events at the "children of Attr" level.
* *At this writing, not all attribute modifications will cause the * DOMAttrModified event to be triggered ... only the ones using the string * methods (setNodeValue, setValue, and Element.setAttribute) to modify * those values. That is, if you manipulate those children directly, * elements won't get notified that attribute values have changed. * The natural fix for that will report other modifications, but won't * be able to expose "previous" attribute value; it'll need to be cached * or something (at which point why bother using child nodes).
* *You are strongly advised not to use "children" of any attribute * nodes you work with.
* * @author David Brownell * @author Chris Burdess */ public class DomAttr extends DomNsNode implements Attr { private boolean specified; private String value; // string value cache /** * Constructs an Attr node associated with the specified document. * The "specified" flag is initialized to true, since this DOM has * no current "back door" mechanisms to manage default values so * that every value must effectively be "specified". * *This constructor should only be invoked by a Document as part of * its createAttribute functionality, or through a subclass which is * similarly used in a "Sub-DOM" style layer. * * @param owner The document with which this node is associated * @param namespaceURI Combined with the local part of the name, * this is used to uniquely identify a type of attribute * @param name Name of this attribute, which may include a prefix */ protected DomAttr(DomDocument owner, String namespaceURI, String name) { super(ATTRIBUTE_NODE, owner, namespaceURI, name); specified = true; length = 1; // XXX register self to get insertion/removal events // and character data change events and when they happen, // report self-mutation } /** * Constructs an Attr node associated with the specified document. * The "specified" flag is initialized to true, since this DOM has * no current "back door" mechanisms to manage default values so * that every value must effectively be "specified". * *
This constructor should only be invoked by a Document as part of * its createAttribute functionality, or through a subclass which is * similarly used in a "Sub-DOM" style layer. *
* With this constructor, the prefix and local part are given explicitly * rather than being computed. This allows them to be explicitly set to * {@code null} as required by {@link Document#createAttribute(String)}. *
* * @param owner The document with which this node is associated * @param namespaceURI Combined with the local part of the name, * this is used to uniquely identify a type of attribute * @param name Name of this attribute, which may include a prefix * @param prefix the namespace prefix of the name. May be {@code null}. * @param localName the local part of the name. May be {@code null}. */ protected DomAttr(DomDocument owner, String namespaceURI, String name, String prefix, String localName) { super(ATTRIBUTE_NODE, owner, namespaceURI, name, prefix, localName); specified = true; length = 1; } /** * DOM L1 * Returns the attribute name (same as getNodeName) */ public final String getName() { return getNodeName(); } /** * DOM L1 * Returns true if a parser reported this was in the source text. */ public final boolean getSpecified() { return specified; } /** * Records whether this attribute was in the source text. */ public final void setSpecified(boolean value) { specified = value; } /** * DOM L1 * Returns the attribute value, with character and entity * references substituted. * NOTE: entity refs as children aren't currently handled. */ public String getNodeValue() { // If we have a simple node-value, use that if (first == null) { return (value == null) ? "" : value; } // Otherwise collect child node-values CPStringBuilder buf = new CPStringBuilder(); for (DomNode ctx = first; ctx != null; ctx = ctx.next) { switch (ctx.nodeType) { case Node.TEXT_NODE: buf.append(ctx.getNodeValue()); break; case Node.ENTITY_REFERENCE_NODE: // TODO break; } } return buf.toString(); } /** * DOM L1 * Assigns the value of the attribute; it will have one child, * which is a text node with the specified value (same as * setNodeValue). */ public final void setValue(String value) { setNodeValue(value); } /** * DOM L1 * Returns the value of the attribute as a non-null string; same * as getNodeValue. * NOTE: entity refs as children aren't currently handled. */ public final String getValue() { return getNodeValue(); } /** * DOM L1 * Assigns the attribute value; using this API, no entity or * character references will exist. * Causes a DOMAttrModified mutation event to be sent. */ public void setNodeValue(String value) { if (readonly) { throw new DomDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR); } if (value == null) { value = ""; } String oldValue = getNodeValue(); while (last != null) { removeChild(last); } // don't create a new node just for this... /* Node text = owner.createTextNode(value); appendChild(text); */ this.value = value; length = 1; specified = true; mutating(oldValue, value, MutationEvent.MODIFICATION); } public final Node getFirstChild() { // Create a child text node if necessary if (first == null) { length = 0; Node text = owner.createTextNode((value == null) ? "" : value); appendChild(text); } return first; } public final Node getLastChild() { // Create a child text node if necessary if (last == null) { length = 0; Node text = owner.createTextNode((value == null) ? "" : value); appendChild(text); } return last; } public Node item(int index) { // Create a child text node if necessary if (first == null) { length = 0; Node text = owner.createTextNode((value == null) ? "" : value); appendChild(text); } return super.item(index); } /** * DOM L2 * Returns the element with which this attribute is associated. */ public final Element getOwnerElement() { return (Element) parent; } public final Node getNextSibling() { return null; } public final Node getPreviousSibling() { return null; } public Node getParentNode() { return null; } /** * Records the element with which this attribute is associated. */ public final void setOwnerElement(Element e) { if (parent != null) { throw new DomDOMException(DOMException.HIERARCHY_REQUEST_ERR); } if (!(e instanceof DomElement)) { throw new DomDOMException(DOMException.WRONG_DOCUMENT_ERR); } parent = (DomElement) e; depth = parent.depth + 1; } /** * The base URI of an Attr is alwaysnull.
*/
public final String getBaseURI()
{
return null;
}
/**
* Shallow clone of the attribute, breaking all ties with any
* elements.
*/
public Object clone()
{
DomAttr retval = (DomAttr) super.clone();
retval.specified = true;
return retval;
}
private void mutating(String oldValue, String newValue, short why)
{
if (!reportMutations || parent == null || equal(newValue, oldValue))
{
return;
}
// EVENT: DOMAttrModified, target = parent,
// prev/new values provided, also attr name
MutationEvent event;
event = (MutationEvent) createEvent ("MutationEvents");
event.initMutationEvent ("DOMAttrModified",
true /* bubbles */, false /* nocancel */,
null, oldValue, newValue, getNodeName (), why);
parent.dispatchEvent (event);
}
// DOM Level 3 methods
public TypeInfo getSchemaTypeInfo()
{
if (parent != null)
{
// DTD implementation
DomDoctype doctype = (DomDoctype) parent.owner.getDoctype();
if (doctype != null)
{
return doctype.getAttributeTypeInfo(parent.getNodeName(),
getNodeName());
}
// TODO XML Schema implementation
}
return null;
}
public boolean isId()
{
if (parent != null)
{
DomDoctype doctype = (DomDoctype) parent.owner.getDoctype();
if (doctype != null)
{
DTDAttributeTypeInfo info =
doctype.getAttributeTypeInfo(parent.getNodeName(),
getNodeName());
if (info != null && "ID".equals(info.type))
{
return true;
}
}
DomElement element = (DomElement) parent;
if (element.userIdAttrs != null &&
element.userIdAttrs.contains(this))
{
return true;
}
// TODO XML Schema implementation
}
return false;
}
}