"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
}
/**
* 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
StringBuffer buf = new StringBuffer();
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 always null.
*/
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;
}
}