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 Nodeor Listof Nodes 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 Listof Nodeinstances 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 Nodefrom 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 Nodeto 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 SAXSourcefor 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 Elementwhich 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!