Uses of Interface org.dom4j.Node (dom4j 1.6.1 API)

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

Uses of Interfaceorg.dom4j.Node

Uses of Interface
org.dom4j.Node