| java.lang.Object
 org.apache.xerces.dom.NodeImpl
org.apache.xerces.dom.AttrImpl
All known Subclasses: org.apache.xerces.dom.DeferredAttrImpl, org.apache.xerces.dom.AttrNSImpl,
| AttrImpl | | public class AttrImpl extends NodeImpl implements Attr(Code) | | Attribute represents an XML-style attribute of an
Element. Typically, the allowable values are controlled by its
declaration in the Document Type Definition (DTD) governing this
kind of document.
If the attribute has not been explicitly assigned a value, but has
been declared in the DTD, it will exist and have that default. Only
if neither the document nor the DTD specifies a value will the
Attribute really be considered absent and have no value; in that
case, querying the attribute will return null.
Attributes may have multiple children that contain their data. (XML
allows attributes to contain entity references, and tokenized
attribute types such as NMTOKENS may have a child for each token.)
For convenience, the Attribute object's getValue() method returns
the string version of the attribute's value.
Attributes are not children of the Elements they belong to, in the
usual sense, and have no valid Parent reference. However, the spec
says they _do_ belong to a specific Element, and an INUSE exception
is to be thrown if the user attempts to explicitly share them
between elements.
Note that Elements do not permit attributes to appear to be shared
(see the INUSE exception), so this object's mutability is
officially not an issue.
Note: The ownerNode attribute is used to store the Element the Attr
node is associated with. Attr nodes do not have parent nodes.
Besides, the getOwnerElement() method can be used to get the element node
this attribute is associated with.
AttrImpl does not support Namespaces. AttrNSImpl, which inherits from
it, does.
AttrImpl used to inherit from ParentNode. It now directly inherits from
NodeImpl and provide its own implementation of the ParentNode's behavior.
The reason is that we now try and avoid to always create a Text node to
hold the value of an attribute. The DOM spec requires it, so we still have
to do it in case getFirstChild() is called for instance. The reason
attribute values are stored as a list of nodes is so that they can carry
more than a simple string. They can also contain EntityReference nodes.
However, most of the times people only have a single string that they only
set and get through Element.set/getAttribute or Attr.set/getValue. In this
new version, the Attr node has a value pointer which can either be the
String directly or a pointer to the first ChildNode. A flag tells which one
it currently is. Note that while we try to stick with the direct String as
much as possible once we've switched to a node there is no going back. This
is because we have no way to know whether the application keeps referring to
the node we once returned.
The gain in memory varies on the density of attributes in the document.
But in the tests I've run I've seen up to 12% of memory gain. And the good
thing is that it also leads to a slight gain in speed because we allocate
fewer objects! I mean, that's until we have to actually create the node...
To avoid too much duplicated code, I got rid of ParentNode and renamed
ChildAndParentNode, which I never really liked, to ParentNode for
simplicity, this doesn't make much of a difference in memory usage because
there are only very few objects that are only a Parent. This is only true
now because AttrImpl now inherits directly from NodeImpl and has its own
implementation of the ParentNode's node behavior. So there is still some
duplicated code there.
This class doesn't directly support mutation events, however, it notifies
the document when mutations are performed so that the document class do so.
WARNING: Some of the code here is partially duplicated in
ParentNode, be careful to keep these two classes in sync!
See Also: AttrNSImpl
author:
Arnaud Le Hors, IBM
author:
Joe Kesselman, IBM
author:
Andy Clark, IBM
since:
PR-DOM-Level-1-19980818. |
| Method Summary | |
| void | checkNormalizationAfterInsert(ChildNode insertedChild)
Checks the normalized state of this node after inserting a child. | | void | checkNormalizationAfterRemove(ChildNode previousSibling)
Checks the normalized of this node after removing a child. | | public Node | cloneNode(boolean deep)
| | public NodeList | getChildNodes()
Obtain a NodeList enumerating all children of this node. | | public Element | getElement()
Returns the element node that this attribute is associated with,
or null if the attribute has not been added to an element. | | public Node | getFirstChild()
The first child of this Node, or null if none. | | public Node | getLastChild()
The last child of this Node, or null if none. | | public int | getLength()
| | public String | getName()
| | public String | getNodeName()
| | public short | getNodeType()
A short integer indicating what type of node this is. | | public String | getNodeValue()
In Attribute objects, NodeValue is considered a synonym for
Value. | | public Element | getOwnerElement()
Returns the element node that this attribute is associated with,
or null if the attribute has not been added to an element. | | public boolean | getSpecified()
The "specified" flag is true if and only if this attribute's
value was explicitly specified in the original document. | | public String | getValue()
The "string value" of an Attribute is its text representation,
which in turn is a concatenation of the string values of its children. | | public boolean | hasChildNodes()
Test whether this node has any children. | | public Node | insertBefore(Node newChild, Node refChild)
Move one or more node(s) to our list of children. | | Node | internalInsertBefore(Node newChild, Node refChild, boolean replace)
NON-DOM INTERNAL: Within DOM actions,we sometimes need to be able
to control which mutation events are spawned. | | Node | internalRemoveChild(Node oldChild, boolean replace)
NON-DOM INTERNAL: Within DOM actions,we sometimes need to be able
to control which mutation events are spawned. | | public Node | item(int index)
NodeList method: Return the Nth immediate child of this node, or
null if the index is out of bounds. | | final ChildNode | lastChild()
| | final void | lastChild(ChildNode node)
| | protected void | makeChildNode()
| | public void | normalize()
| | public Node | removeChild(Node oldChild)
Remove a child from this Node. | | public Node | replaceChild(Node newChild, Node oldChild)
Make newChild occupy the location that oldChild used to
have. | | public void | setNodeValue(String value)
Implicit in the rerouting of getNodeValue to getValue is the
need to redefine setNodeValue, for symmetry's sake. | | void | setOwnerDocument(CoreDocumentImpl doc)
| | public void | setReadOnly(boolean readOnly, boolean deep)
Override default behavior so that if deep is true, children are also
toggled. | | public void | setSpecified(boolean arg)
| | public void | setValue(String newvalue)
The DOM doesn't clearly define what setValue(null) means. | | protected void | synchronizeChildren()
Override this method in subclass to hook in efficient
internal data structure. | | public String | toString()
|
| serialVersionUID | | final static long serialVersionUID(Code) | | Serialization version.
|
| value | | protected Object value(Code) | | This can either be a String or the first child node.
|
| AttrImpl | | protected AttrImpl(CoreDocumentImpl ownerDocument, String name)(Code) | | Attribute has no public constructor. Please use the factory
method in the Document class.
|
| AttrImpl | | protected AttrImpl()(Code) | | |
| checkNormalizationAfterInsert | | void checkNormalizationAfterInsert(ChildNode insertedChild)(Code) | | Checks the normalized state of this node after inserting a child.
If the inserted child causes this node to be unnormalized, then this
node is flagged accordingly.
The conditions for changing the normalized state are:
- The inserted child is a text node and one of its adjacent siblings
is also a text node.
- The inserted child is is itself unnormalized.
Parameters:
insertedChild - the child node that was inserted into this node
throws:
NullPointerException - if the inserted child is null |
| checkNormalizationAfterRemove | | void checkNormalizationAfterRemove(ChildNode previousSibling)(Code) | | Checks the normalized of this node after removing a child.
If the removed child causes this node to be unnormalized, then this
node is flagged accordingly.
The conditions for changing the normalized state are:
- The removed child had two adjacent siblings that were text nodes.
Parameters:
previousSibling - the previous sibling of the removed child, ornull |
| cloneNode | | public Node cloneNode(boolean deep)(Code) | | |
| getChildNodes | | public NodeList getChildNodes()(Code) | | Obtain a NodeList enumerating all children of this node. If there
are none, an (initially) empty NodeList is returned.
NodeLists are "live"; as children are added/removed the NodeList
will immediately reflect those changes. Also, the NodeList refers
to the actual nodes, so changes to those nodes made via the DOM tree
will be reflected in the NodeList and vice versa.
In this implementation, Nodes implement the NodeList interface and
provide their own getChildNodes() support. Other DOMs may solve this
differently.
|
| getElement | | public Element getElement()(Code) | | Returns the element node that this attribute is associated with,
or null if the attribute has not been added to an element.
See Also: AttrImpl.getOwnerElement |
| getFirstChild | | public Node getFirstChild()(Code) | | The first child of this Node, or null if none.
|
| getLastChild | | public Node getLastChild()(Code) | | The last child of this Node, or null if none.
|
| getLength | | public int getLength()(Code) | | NodeList method: Count the immediate children of this node
int |
| getName | | public String getName()(Code) | | In Attributes, NodeName is considered a synonym for the
attribute's Name
|
| getNodeName | | public String getNodeName()(Code) | | Returns the attribute name
|
| getNodeType | | public short getNodeType()(Code) | | A short integer indicating what type of node this is. The named
constants for this value are defined in the org.w3c.dom.Node interface.
|
| getOwnerElement | | public Element getOwnerElement()(Code) | | Returns the element node that this attribute is associated with,
or null if the attribute has not been added to an element.
since:
WD-DOM-Level-2-19990719 |
| getSpecified | | public boolean getSpecified()(Code) | | The "specified" flag is true if and only if this attribute's
value was explicitly specified in the original document. Note that
the implementation, not the user, is in charge of this
property. If the user asserts an Attribute value (even if it ends
up having the same value as the default), it is considered a
specified attribute. If you really want to revert to the default,
delete the attribute from the Element, and the Implementation will
re-assert the default (if any) in its place, with the appropriate
specified=false setting.
|
| getValue | | public String getValue()(Code) | | The "string value" of an Attribute is its text representation,
which in turn is a concatenation of the string values of its children.
|
| hasChildNodes | | public boolean hasChildNodes()(Code) | | Test whether this node has any children. Convenience shorthand
for (Node.getFirstChild()!=null)
|
| insertBefore | | public Node insertBefore(Node newChild, Node refChild) throws DOMException(Code) | | Move one or more node(s) to our list of children. Note that this
implicitly removes them from their previous parent.
Parameters:
newChild - The Node to be moved to our subtree. As aconvenience feature, inserting a DocumentNode will instead insertall its children.
Parameters:
refChild - Current child which newChild should be placedimmediately before. If refChild is null, the insertion occursafter all existing Nodes, like appendChild().
throws:
DOMException - (HIERARCHY_REQUEST_ERR) if newChild is of atype that shouldn't be a child of this node, or if newChild is anancestor of this node.
throws:
DOMException - (WRONG_DOCUMENT_ERR) if newChild has adifferent owner document than we do.
throws:
DOMException - (NOT_FOUND_ERR) if refChild is not a child ofthis node.
throws:
DOMException - (NO_MODIFICATION_ALLOWED_ERR) if this node isread-only. |
| internalInsertBefore | | Node internalInsertBefore(Node newChild, Node refChild, boolean replace) throws DOMException(Code) | | NON-DOM INTERNAL: Within DOM actions,we sometimes need to be able
to control which mutation events are spawned. This version of the
insertBefore operation allows us to do so. It is not intended
for use by application programs.
|
| internalRemoveChild | | Node internalRemoveChild(Node oldChild, boolean replace) throws DOMException(Code) | | NON-DOM INTERNAL: Within DOM actions,we sometimes need to be able
to control which mutation events are spawned. This version of the
removeChild operation allows us to do so. It is not intended
for use by application programs.
|
| item | | public Node item(int index)(Code) | | NodeList method: Return the Nth immediate child of this node, or
null if the index is out of bounds.
org.w3c.dom.Node
Parameters:
Index - int |
| makeChildNode | | protected void makeChildNode()(Code) | | |
| normalize | | public void normalize()(Code) | | |
| removeChild | | public Node removeChild(Node oldChild) throws DOMException(Code) | | Remove a child from this Node. The removed child's subtree
remains intact so it may be re-inserted elsewhere.
oldChild, in its new state (removed).
throws:
DOMException - (NOT_FOUND_ERR) if oldChild is not a child ofthis node.
throws:
DOMException - (NO_MODIFICATION_ALLOWED_ERR) if this node isread-only. |
| replaceChild | | public Node replaceChild(Node newChild, Node oldChild) throws DOMException(Code) | | Make newChild occupy the location that oldChild used to
have. Note that newChild will first be removed from its previous
parent, if any. Equivalent to inserting newChild before oldChild,
then removing oldChild.
throws:
DOMException - (HIERARCHY_REQUEST_ERR) if newChild is of atype that shouldn't be a child of this node, or if newChild isone of our ancestors.
throws:
DOMException - (WRONG_DOCUMENT_ERR) if newChild has adifferent owner document than we do.
throws:
DOMException - (NOT_FOUND_ERR) if oldChild is not a child ofthis node.
throws:
DOMException - (NO_MODIFICATION_ALLOWED_ERR) if this node isread-only. |
| setNodeValue | | public void setNodeValue(String value) throws DOMException(Code) | | Implicit in the rerouting of getNodeValue to getValue is the
need to redefine setNodeValue, for symmetry's sake. Note that
since we're explicitly providing a value, Specified should be set
true.... even if that value equals the default.
|
| setOwnerDocument | | void setOwnerDocument(CoreDocumentImpl doc)(Code) | | NON-DOM
set the ownerDocument of this node and its children
|
| setReadOnly | | public void setReadOnly(boolean readOnly, boolean deep)(Code) | | Override default behavior so that if deep is true, children are also
toggled.
See Also: Node
See Also:
See Also: Note: this will not change the state of an EntityReference or its
See Also: children, which are always read-only.
|
| setSpecified | | public void setSpecified(boolean arg)(Code) | | NON-DOM, for use by parser
|
| setValue | | public void setValue(String newvalue)(Code) | | The DOM doesn't clearly define what setValue(null) means. I've taken it
as "remove all children", which from outside should appear
similar to setting it to the empty string.
|
| synchronizeChildren | | protected void synchronizeChildren()(Code) | | Override this method in subclass to hook in efficient
internal data structure.
|
| toString | | public String toString()(Code) | | NON-DOM method for debugging convenience
|
|
|