Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## 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!

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

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