## Uses of Interface
org.dom4j.Node

Packages that use Node
org.dom4j: Defines the XML Document Object Model in Java interfaces together with some helper classes.
org.dom4j.bean: An implementation of the dom4j API which allows JavaBeans to be used to store and retrieve attribute values from Element.
org.dom4j.datatype: An implementation of the dom4j API which supports the XML Schema Data Types specification.
org.dom4j.dom: An implementation of the dom4j API which also supports the W3C object model.
org.dom4j.io: Provides input and output via SAX and DOM together with writing dom4j objects to streams as XML text.
org.dom4j.rule: A `Pattern` based XML rule engine which implements the full XSLT processing model while allowing any `Action` to be fired if a pattern matches.
org.dom4j.rule.pattern
org.dom4j.swing: A collection of adapters to allow easy integration with dom4j XML documents and Swing such as TreeModels and TableModels.
org.dom4j.tree: Contains the default implementations of the dom4j Document Object Model together with some helpful base classes for those wishing to implement their own document object model.
org.dom4j.util: A collection of utility classes for the dom4j API.
org.dom4j.xpath: Provides the core tools needed to use the XPath library

Uses of Node in org.dom4j

Subinterfaces of Node in org.dom4j
`interface` `Attribute` `Attribute` defines an XML attribute.
`interface` `Branch` `Branch` interface defines the common behaviour for Nodes which can contain child nodes (content) such as XML elements and documents.
`interface` `CDATA` `CDATA` defines an XML CDATA section.
`interface` `CharacterData` `CharacterData` is a marker interface for character based nodes such as the `CDATA`,`Comment` and `Text` nodes.
`interface` `Comment` `Comment` defines the behavior of an XML comment.
`interface` `Document` `Document` defines an XML Document.
`interface` `DocumentType` `DocumentType` defines an XML DOCTYPE declaration.
`interface` `Element` `Element` interface defines an XML element.
`interface` `Entity` `Entity` defines an XML entity.
`interface` `ProcessingInstruction` `ProcessingInstruction` defines an XML processing instruction.
`interface` `Text` `Text` defines an XML Text node.

Classes in org.dom4j that implement Node
`class` `Namespace` `Namespace` is a Flyweight Namespace that can be shared amongst nodes.

Methods in org.dom4j that return Node
`Node` `XPath.selectSingleNode(Object context)` `selectSingleNode` evaluates this XPath expression on the given `Node`or `List`of `Node`s and returns the result as a single `Node` instance.
`Node` `Node.detach()` Removes this node from its parent if there is one.
`Node` `Node.selectSingleNode(String xpathExpression)` `selectSingleNode` evaluates an XPath expression and returns the result as a single `Node` instance.
`Node` `Node.asXPathResult(Element parent)` `asXPathResult` returns a version of this node which is capable of being an XPath result.
`protected Node` `Namespace.createXPathResult(Element parent)`
`Node` `Element.getXPathResult(int index)` Returns a node at the given index suitable for an XPath result set.
`Node` `Branch.node(int index)` Returns the `Node` at the specified index position.

Methods in org.dom4j with parameters of type Node
`boolean` `XPath.matches(Node node)` `matches` returns true if the given node matches the XPath expression.
`boolean` `NodeFilter.matches(Node node)` `matches` returns true if the given node matches the filter condition.
`static List` `DocumentHelper.selectNodes(String xpathFilterExpression, Node node)` `selectNodes` performs the given XPath expression on the `List`of `Node`instances appending all the results together into a single list.
`int` `Branch.indexOf(Node node)` Returns the index of the given node if it is a child node of this branch or -1 if the given node is not a child node.
`void` `Branch.add(Node node)` Adds the given `Node` or throws `IllegalAddException` if the given node is not of a valid type.
`boolean` `Branch.remove(Node node)` Removes the given `Node` if the node is an immediate child of this branch.

Constructors in org.dom4j with parameters of type Node
`IllegalAddException(Element parent, Node node, String reason)`
`IllegalAddException(Branch parent, Node node, String reason)`

Uses of Node in org.dom4j.bean

Classes in org.dom4j.bean that implement Node
`class` `BeanAttribute` `BeanAttribute` represents a mutable XML attribute which is backed by a property of the JavaBean of its parent element.
`class` `BeanElement` `BeanElement` uses a Java Bean to store its attributes.

Uses of Node in org.dom4j.datatype

Classes in org.dom4j.datatype that implement Node
`class` `DatatypeAttribute` `DatatypeAttribute` represents an Attribute which supports the XML Schema Data Types specification.
`class` `DatatypeElement` `DatatypeElement` represents an Element which supports the XML Schema Data Types specification.

Methods in org.dom4j.datatype with parameters of type Node
`protected void` `DatatypeElement.childAdded(Node node)` Override to force lazy recreation of data object
`protected void` `DatatypeElement.childRemoved(Node node)` Override to force lazy recreation of data object

Uses of Node in org.dom4j.dom

Classes in org.dom4j.dom that implement Node
`class` `DOMAttribute` `DOMAttribute` implements a doubly linked attribute which supports the W3C DOM API.
`class` `DOMCDATA` `DOMCDATA` implements a CDATA Section which supports the W3C DOM API.
`class` `DOMComment` `DOMText` implements a Text node which supports the W3C DOM API.
`class` `DOMDocument` `DOMDocument` implements an XML document which supports the W3C DOM API.
`class` `DOMDocumentType` `DOMDocumentType` implements a DocumentType node which supports the W3C DOM API.
`class` `DOMElement` `DOMElement` implements an XML element which supports the W3C DOM API.
`class` `DOMEntityReference` `DOMEntity` implements a Entity node which supports the W3C DOM API.
`class` `DOMNamespace` `DOMNamespace` implements a Namespace that is compatable with the DOM API.
`class` `DOMProcessingInstruction` `DOMProcessingInstruction` implements a ProcessingInstruction node which supports the W3C DOM API.
`class` `DOMText` `DOMText` implements a Text node which supports the W3C DOM API.

Methods in org.dom4j.dom with parameters of type Node
`static boolean` `DOMNodeHelper.supports(Node node, String feature, String version)`
`static String` `DOMNodeHelper.getNamespaceURI(Node node)`
`static String` `DOMNodeHelper.getPrefix(Node node)`
`static String` `DOMNodeHelper.getLocalName(Node node)`
`static void` `DOMNodeHelper.setPrefix(Node node, String prefix)`
`static String` `DOMNodeHelper.getNodeValue(Node node)`
`static void` `DOMNodeHelper.setNodeValue(Node node, String nodeValue)`
`static Node` `DOMNodeHelper.getParentNode(Node node)`
`static NodeList` `DOMNodeHelper.getChildNodes(Node node)`
`static Node` `DOMNodeHelper.getFirstChild(Node node)`
`static Node` `DOMNodeHelper.getLastChild(Node node)`
`static Node` `DOMNodeHelper.getPreviousSibling(Node node)`
`static Node` `DOMNodeHelper.getNextSibling(Node node)`
`static NamedNodeMap` `DOMNodeHelper.getAttributes(Node node)`
`static Document` `DOMNodeHelper.getOwnerDocument(Node node)`
`static Node` `DOMNodeHelper.insertBefore(Node node, Node newChild, Node refChild)`
`static Node` `DOMNodeHelper.replaceChild(Node node, Node newChild, Node oldChild)`
`static Node` `DOMNodeHelper.removeChild(Node node, Node oldChild)`
`static Node` `DOMNodeHelper.appendChild(Node node, Node newChild)`
`static boolean` `DOMNodeHelper.hasChildNodes(Node node)`
`static Node` `DOMNodeHelper.cloneNode(Node node, boolean deep)`
`static void` `DOMNodeHelper.normalize(Node node)`
`static boolean` `DOMNodeHelper.isSupported(Node n, String feature, String version)`
`static boolean` `DOMNodeHelper.hasAttributes(Node node)`
`static Node` `DOMNodeHelper.asDOMNode(Node node)`
`static Element` `DOMNodeHelper.asDOMElement(Node element)`
`static Attr` `DOMNodeHelper.asDOMAttr(Node attribute)`

Uses of Node in org.dom4j.io

Methods in org.dom4j.io that return Node
`Node` `STAXEventReader.readNode(javax.xml.stream.XMLEventReader reader)` Reads a `Node`from the event stream.

Methods in org.dom4j.io with parameters of type Node
`void` `XMLWriter.write(Node node)` Writes the given `Node`.
`protected void` `XMLWriter.writeNodeText(Node node)` This method is used to write out Nodes that contain text and still allow for xml:space to be handled properly.
`protected void` `XMLWriter.writeNode(Node node)`
`void` `STAXEventWriter.writeNode(Node n)` Writes a DOM4J `Node`to the stream.
`void` `SAXWriter.write(Node node)` A polymorphic method to write any Node to this SAX stream

Constructors in org.dom4j.io with parameters of type Node
`DocumentSource(Node node)` Creates a JAXP `SAXSource`for the given `Node`.

Uses of Node in org.dom4j.rule

Methods in org.dom4j.rule with parameters of type Node
`void` `Stylesheet.run(Node node)`
`void` `Stylesheet.run(Node node, String mode)`
`Rule` `RuleSet.getMatchingRule(Node node)` Performs an XSLT processing model match for the rule which matches the given Node the best.
`Rule` `RuleManager.getMatchingRule(String modeName, Node node)` Performs an XSLT processing model match for the rule which matches the given Node the best.
`boolean` `Rule.matches(Node node)` DOCUMENT ME!
`boolean` `Pattern.matches(Node node)` DOCUMENT ME!
`void` `NullAction.run(Node node)`
`void` `Mode.fireRule(Node node)` Runs the actions associated with the given node
`Rule` `Mode.getMatchingRule(Node node)` Performs an XSLT processing model match for the rule which matches the given Node the best.
`void` `Action.run(Node node)`

Uses of Node in org.dom4j.rule.pattern

Methods in org.dom4j.rule.pattern with parameters of type Node
`boolean` `NodeTypePattern.matches(Node node)`
`boolean` `DefaultPattern.matches(Node node)`

Uses of Node in org.dom4j.swing

Fields in org.dom4j.swing declared as Node
`protected Node` `LeafTreeNode.xmlNode` The dom4j Node which contains the

Methods in org.dom4j.swing that return Node
`Node` `LeafTreeNode.getXmlNode()`

Methods in org.dom4j.swing with parameters of type Node
`protected TreeNode` `BranchTreeNode.createChildTreeNode(Node xmlNode)` Factory method to create child tree nodes for a given XML node type

Constructors in org.dom4j.swing with parameters of type Node
`LeafTreeNode(Node xmlNode)`
`LeafTreeNode(TreeNode parent, Node xmlNode)`

Uses of Node in org.dom4j.tree

Classes in org.dom4j.tree that implement Node
`class` `AbstractAttribute` `AbstractNamespace` is an abstract base class for tree implementors to use for implementation inheritence.
`class` `AbstractBranch` `AbstractBranch` is an abstract base class for tree implementors to use for implementation inheritence.
`class` `AbstractCDATA` `AbstractCDATA` is an abstract base class for tree implementors to use for implementation inheritence.
`class` `AbstractCharacterData` `AbstractCharacterData` is an abstract base class for tree implementors to use for implementation inheritence.
`class` `AbstractComment` `AbstractComment` is an abstract base class for tree implementors to use for implementation inheritence.
`class` `AbstractDocument` `AbstractDocument` is an abstract base class for tree implementors to use for implementation inheritence.
`class` `AbstractDocumentType` `AbstractDocumentType` is an abstract base class for tree implementors to use for implementation inheritence.
`class` `AbstractElement` `AbstractElement` is an abstract base class for tree implementors to use for implementation inheritence.
`class` `AbstractEntity` `AbstractEntity` is an abstract base class for tree implementors to use for implementation inheritence.
`class` `AbstractNode` `AbstractNode` is an abstract base class for tree implementors to use for implementation inheritence.
`class` `AbstractProcessingInstruction` `AbstractProcessingInstruction` is an abstract base class for tree implementors to use for implementation inheritence.
`class` `AbstractText` `AbstractText` is an abstract base class for tree implementors to use for implementation inheritence.
`class` `BaseElement` `BaseElement` is a useful base class for implemementation inheritence of an XML element.
`class` `DefaultAttribute` `DefaultAttribute` implements a doubly linked node which supports the parent relationship and is mutable.
`class` `DefaultCDATA` `DefaultCDATA` is the default CDATA implementation.
`class` `DefaultComment` `DefaultComment` is the default Comment implementation.
`class` `DefaultDocument` `DefaultDocument` is the default DOM4J default implementation of an XML document.
`class` `DefaultDocumentType` `DefaultDocumentType` is the DOM4J default implementation of an XML document type.
`class` `DefaultElement` `DefaultElement` is the default DOM4J default implementation of an XML element.
`class` `DefaultEntity` `DefaultEntity` is the default Entity implementation.
`class` `DefaultNamespace` `DefaultNamespace` implements a doubly linked node which supports the parent relationship and is mutable.
`class` `DefaultProcessingInstruction` `DefaultProcessingInstruction` is the default Processing Instruction implementation.
`class` `DefaultText` `DefaultText` is the default Text implementation.
`class` `FlyweightAttribute` `FlyweightAttribute` is a Flyweight pattern implementation of a singly linked, read-only XML Attribute.
`class` `FlyweightCDATA` `FlyweightCDATA` is a Flyweight pattern implementation of a singly linked, read-only XML CDATA.
`class` `FlyweightComment` `FlyweightComment` is a Flyweight pattern implementation of a singly linked, read-only XML Comment.
`class` `FlyweightEntity` `FlyweightEntity` is a Flyweight pattern implementation of a singly linked, read-only XML entity.
`class` `FlyweightProcessingInstruction` `FlyweightProcessingInstruction` is a Flyweight pattern implementation of a singly linked, read-only XML Processing Instruction.
`class` `FlyweightText` `FlyweightText` is a Flyweight pattern implementation of a singly linked, read-only XML Text.

Methods in org.dom4j.tree that return Node
`protected Node` `FlyweightText.createXPathResult(Element parent)`
`protected Node` `FlyweightProcessingInstruction.createXPathResult(Element parent)`
`protected Node` `FlyweightEntity.createXPathResult(Element parent)`
`protected Node` `FlyweightComment.createXPathResult(Element parent)`
`protected Node` `FlyweightCDATA.createXPathResult(Element parent)`
`Node` `DefaultElement.node(int index)`
`protected Node` `ContentListFacade.asNode(Object object)`
`protected Node` `BackedList.asNode(Object object)`
`Node` `AbstractNode.detach()`
`Node` `AbstractNode.selectSingleNode(String xpathExpression)`
`Node` `AbstractNode.asXPathResult(Element parent)`
`protected Node` `AbstractNode.createXPathResult(Element parent)`
`Node` `AbstractElement.node(int index)`
`Node` `AbstractElement.getXPathResult(int index)`
`Node` `AbstractDocument.asXPathResult(Element parent)`
`Node` `AbstractBranch.node(int index)`
`protected Node` `AbstractAttribute.createXPathResult(Element parent)`

Methods in org.dom4j.tree with parameters of type Node
`int` `DefaultElement.indexOf(Node node)`
`protected void` `DefaultElement.addNewNode(Node node)`
`protected boolean` `DefaultElement.removeNode(Node node)`
`protected void` `DefaultDocument.addNode(Node node)`
`protected void` `DefaultDocument.addNode(int index, Node node)`
`protected boolean` `DefaultDocument.removeNode(Node node)`
`int` `AbstractElement.indexOf(Node node)`
`void` `AbstractElement.add(Node node)`
`boolean` `AbstractElement.remove(Node node)`
`protected void` `AbstractElement.addNode(Node node)`
`protected void` `AbstractElement.addNode(int index, Node node)`
`protected void` `AbstractElement.addNewNode(Node node)` Like addNode() but does not require a parent check
`protected void` `AbstractElement.addNewNode(int index, Node node)`
`protected boolean` `AbstractElement.removeNode(Node node)`
`protected void` `AbstractElement.childAdded(Node node)` Called when a new child node is added to create any parent relationships
`protected void` `AbstractElement.childRemoved(Node node)`
`protected void` `AbstractDocument.childAdded(Node node)`
`protected void` `AbstractDocument.childRemoved(Node node)`
`void` `AbstractBranch.add(Node node)`
`boolean` `AbstractBranch.remove(Node node)`
`int` `AbstractBranch.indexOf(Node node)`
`protected abstract void` `AbstractBranch.addNode(Node node)`
`protected abstract void` `AbstractBranch.addNode(int index, Node node)`
`protected abstract boolean` `AbstractBranch.removeNode(Node node)`
`protected abstract void` `AbstractBranch.childAdded(Node node)` Called when a new child node has been added to me to allow any parent relationships to be created or events to be fired.
`protected abstract void` `AbstractBranch.childRemoved(Node node)` Called when a child node has been removed to allow any parent relationships to be deleted or events to be fired.
`protected void` `AbstractBranch.invalidNodeTypeAddException(Node node)` Called when an invalid node has been added.

Uses of Node in org.dom4j.util

Classes in org.dom4j.util that implement Node
`class` `IndexedElement` `IndexedElement` is an implementation of `Element`which maintains an index of the attributes and elements it contains to optimise lookups via name.
`class` `NonLazyElement` `NonLazyElement` is the default DOM4J default implementation of an XML element.
`class` `UserDataAttribute` `UserDataAttribute` support the adornment of a user data object on an Element or Attribute instance such that the methods `UserDataAttribute.setData(Object)`will get and set the values of a user data object.
`class` `UserDataElement` `UserDataElement` support the adornment of a user data object on an Element or Attribute instance such that the methods `UserDataElement.setData(Object)`will get and set the values of a user data object.

Methods in org.dom4j.util with parameters of type Node
`int` `NodeComparator.compare(Node n1, Node n2)`
`protected void` `IndexedElement.addNode(Node node)`
`protected boolean` `IndexedElement.removeNode(Node node)`

Uses of Node in org.dom4j.xpath

Methods in org.dom4j.xpath that return Node
`Node` `DefaultXPath.selectSingleNode(Object context)`

Methods in org.dom4j.xpath with parameters of type Node
`boolean` `XPathPattern.matches(Node node)`
`boolean` `DefaultXPath.matches(Node node)`
`protected Object` `DefaultXPath.getCompareValue(Node node)` DOCUMENT ME!

Copyright © 2001-2005 MetaStuff Ltd.. All Rights Reserved.