"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 * @version $Date: 2002/09/30 15:08:51 $ */ public class DomAttr extends DomNsNode implements Attr { private boolean specified; // NOTE: it could be possible to rework this code a bit so that // this extra field isn't needed; "parent" might do double duty, // with appropriate safeguards. Using less space is healthy! private DomElement element; /** * 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 (Document owner, String namespaceURI, String name) { super (owner, ATTRIBUTE_NODE, namespaceURI, name); specified = true; // XXX register self to get insertion/removal events // and character data change events and when they happen, // report self-mutation } /** * DOM L1 * Returns the attribute name (same as getNodeName) */ final public String getName () { return getNodeName (); } /** * DOM L1 * Returns true if a parser reported this was in the source text. */ final public boolean getSpecified () { return specified; } /** * Records whether this attribute was in the source text. */ final public 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 () { int length = getLength (); String retval = null; for (int i = 0; i < length; i++) { Node n = item (i); if (n.getNodeType () == TEXT_NODE) { if (retval == null) retval = n.getNodeValue (); else retval += n.getNodeValue (); continue; } // XXX entity ref child of attribute // contents exclude comments, PIs, elements throw new DomEx (DomEx.NOT_SUPPORTED_ERR); } if (retval == null) retval = ""; return retval; } /** * 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). */ final public 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. */ final public 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) { int len = getLength (); String oldValue; if (isReadonly ()) throw new DomEx (DomEx.NO_MODIFICATION_ALLOWED_ERR); oldValue = getValue (); for (int i = 0; i < len; i++) removeChild (getLastChild ()); appendChild (getOwnerDocument ().createTextNode (value)); mutating (oldValue, value, MutationEvent.MODIFICATION); } /** * DOM L2 * Returns the element with which this attribute is associated. */ final public Element getOwnerElement () { return element; } /** * Records the element with which this attribute is associated. */ final public void setOwnerElement (Element e) { if (element != null) throw new DomEx (DomEx.HIERARCHY_REQUEST_ERR); if (!(e instanceof DomElement)) throw new DomEx (DomEx.WRONG_DOCUMENT_ERR); element = (DomElement) e; } /** * Shallow clone of the attribute, breaking all ties with any * elements. */ public Object clone () { DomAttr retval = (DomAttr) super.clone (); retval.element = null; retval.specified = false; return retval; } private void mutating (String oldValue, String newValue, short why) { if (!reportMutations || element == null) return; // EVENT: DOMAttrModified, target = element, // prev/new values provided, also attr name MutationEvent event; event = (MutationEvent) createEvent ("DOMAttrModified"); event.initMutationEvent ("DOMAttrModified", true /* bubbles */, false /* nocancel */, null, oldValue, newValue, getNodeName (), why); element.dispatchEvent (event); } }