Uses of Interface
org.dom4j.Node

Packages that use Node

Package	Description
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

Modifier and Type	Interface	Description
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

Modifier and Type	Class	Description
class	Namespace	Namespace is a Flyweight Namespace that can be shared amongst nodes.

Methods in org.dom4j that return Node

Modifier and Type	Method	Description
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	Node.detach()	Removes this node from its parent if there is one.
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.
Node	Node.selectSingleNode(String xpathExpression)	selectSingleNode evaluates an XPath expression and returns the result as a single Node instance.
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.

Methods in org.dom4j that return types with arguments of type Node

Modifier and Type	Method	Description
List<Node>	Branch.content()	Returns the content nodes of this branch as a backed Listso that the content of this branch may be modified directly using the Listinterface.
Iterator<Node>	Branch.nodeIterator()	Returns an iterator through the content nodes of this branch
static List<Node>	DocumentHelper.selectNodes(String xpathFilterExpression, List<Node> nodes)	selectNodes performs the given XPath expression on the Listof Nodeinstances appending all the results together into a single list.
static List<Node>	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.
List<Node>	Node.selectNodes(String xpathExpression)	selectNodes evaluates an XPath expression and returns the result as a List of Node instances or String instances depending on the XPath expression.
List<Node>	Node.selectNodes(String xpathExpression, String comparisonXPathExpression)	selectNodes evaluates an XPath expression then sorts the results using a secondary XPath expression Returns a sorted List of Node instances.
List<Node>	Node.selectNodes(String xpathExpression, String comparisonXPathExpression, boolean removeDuplicates)	selectNodes evaluates an XPath expression then sorts the results using a secondary XPath expression Returns a sorted List of Node instances.
List<Node>	XPath.selectNodes(Object context)	selectNodes performs this XPath expression on the given Nodeor Listof Nodes instances appending all the results together into a single list.
List<Node>	XPath.selectNodes(Object context, XPath sortXPath)	selectNodes evaluates the XPath expression on the given Nodeor Listof Nodes and returns the result as a List of Node s sorted by the sort XPath expression.
List<Node>	XPath.selectNodes(Object context, XPath sortXPath, boolean distinct)	selectNodes evaluates the XPath expression on the given Nodeor Listof Nodes and returns the result as a List of Node s sorted by the sort XPath expression.

Methods in org.dom4j with parameters of type Node

Modifier and Type	Method	Description
void	Branch.add(Node node)	Adds the given Node or throws IllegalAddException if the given node is not of a valid type.
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.
boolean	NodeFilter.matches(Node node)	matches returns true if the given node matches the filter condition.
boolean	XPath.matches(Node node)	matches returns true if the given node matches the XPath expression.
boolean	Branch.remove(Node node)	Removes the given Node if the node is an immediate child of this branch.
static List<Node>	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.

Method parameters in org.dom4j with type arguments of type Node

Modifier and Type	Method	Description
static List<Node>	DocumentHelper.selectNodes(String xpathFilterExpression, List<Node> nodes)	selectNodes performs the given XPath expression on the Listof Nodeinstances appending all the results together into a single list.
void	Branch.setContent(List<Node> content)	Sets the contents of this branch as a List of Node instances.
static void	DocumentHelper.sort(List<Node> list, String xpathExpression)	sort sorts the given List of Nodes using an XPath expression as a Comparator.
static void	DocumentHelper.sort(List<Node> list, String expression, boolean distinct)	sort sorts the given List of Nodes using an XPath expression as a Comparatorand optionally removing duplicates.
void	XPath.sort(List<Node> list)	sort sorts the given List of Nodes using this XPath expression as a Comparator.
void	XPath.sort(List<Node> list, boolean distinct)	sort sorts the given List of Nodes using this XPath expression as a Comparatorand optionally removing duplicates.

Constructors in org.dom4j with parameters of type Node

Constructor	Description
IllegalAddException(Branch parent, Node node, String reason)
IllegalAddException(Element parent, Node node, String reason)

Uses of Node in org.dom4j.bean

Classes in org.dom4j.bean that implement Node

Modifier and Type	Class	Description
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

Modifier and Type	Class	Description
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

Modifier and Type	Method	Description
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

Modifier and Type	Class	Description
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

Modifier and Type	Method	Description
static Node	DOMNodeHelper.appendChild(Node node, Node newChild)
static Attr	DOMNodeHelper.asDOMAttr(Node attribute)
static Element	DOMNodeHelper.asDOMElement(Node element)
static Node	DOMNodeHelper.asDOMNode(Node node)
static Node	DOMNodeHelper.cloneNode(Node node, boolean deep)
static NamedNodeMap	DOMNodeHelper.getAttributes(Node node)
static NodeList	DOMNodeHelper.getChildNodes(Node node)
static Node	DOMNodeHelper.getFirstChild(Node node)
static Node	DOMNodeHelper.getLastChild(Node node)
static String	DOMNodeHelper.getLocalName(Node node)
static String	DOMNodeHelper.getNamespaceURI(Node node)
static Node	DOMNodeHelper.getNextSibling(Node node)
static String	DOMNodeHelper.getNodeValue(Node node)
static Document	DOMNodeHelper.getOwnerDocument(Node node)
static Node	DOMNodeHelper.getParentNode(Node node)
static String	DOMNodeHelper.getPrefix(Node node)
static Node	DOMNodeHelper.getPreviousSibling(Node node)
static boolean	DOMNodeHelper.hasAttributes(Node node)
static boolean	DOMNodeHelper.hasChildNodes(Node node)
static Node	DOMNodeHelper.insertBefore(Node node, Node newChild, Node refChild)
static boolean	DOMNodeHelper.isSupported(Node n, String feature, String version)
static void	DOMNodeHelper.normalize(Node node)
static Node	DOMNodeHelper.removeChild(Node node, Node oldChild)
static Node	DOMNodeHelper.replaceChild(Node node, Node newChild, Node oldChild)
static void	DOMNodeHelper.setNodeValue(Node node, String nodeValue)
static void	DOMNodeHelper.setPrefix(Node node, String prefix)
static boolean	DOMNodeHelper.supports(Node node, String feature, String version)

Method parameters in org.dom4j.dom with type arguments of type Node

Modifier and Type	Method	Description
static NodeList	DOMNodeHelper.createNodeList(List<Node> list)

Uses of Node in org.dom4j.io

Methods in org.dom4j.io that return Node

Modifier and Type	Method	Description
Node	STAXEventReader.readNode(XMLEventReader reader)	Reads a Nodefrom the event stream.

Methods in org.dom4j.io with parameters of type Node

Modifier and Type	Method	Description
void	SAXWriter.write(Node node)	A polymorphic method to write any Node to this SAX stream
void	XMLWriter.write(Node node)	Writes the given Node.
void	STAXEventWriter.writeNode(Node n)	Writes a DOM4J Nodeto the stream.
protected void	XMLWriter.writeNode(Node 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.

Method parameters in org.dom4j.io with type arguments of type Node

Modifier and Type	Method	Description
protected void	DOMWriter.appendDOMTree(Document domDocument, Node domCurrent, List<Node> content)

Constructors in org.dom4j.io with parameters of type Node

Constructor	Description
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

Modifier and Type	Method	Description
void	Stylesheet.applyTemplates(Node node)	If input is a Node, this will processes all of the children of that node.
void	Stylesheet.applyTemplates(Node node, String mode)	Processes the input object in the given mode.
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.
Rule	RuleManager.getMatchingRule(String modeName, Node node)	Performs an XSLT processing model match for the rule which matches the given Node the best.
Rule	RuleSet.getMatchingRule(Node node)	Performs an XSLT processing model match for the rule which matches the given Node the best.
boolean	Pattern.matches(Node node)	DOCUMENT ME!
boolean	Rule.matches(Node node)	DOCUMENT ME!
void	Action.run(Node node)
void	NullAction.run(Node node)
void	Stylesheet.run(Node node)
void	Stylesheet.run(Node node, String mode)

Method parameters in org.dom4j.rule with type arguments of type Node

Modifier and Type	Method	Description
void	Stylesheet.applyTemplates(List<? extends Node> list, String mode)	Processes the input object in the given mode.
void	Stylesheet.applyTemplates(List<Node> list)	If input is a Node, this will processes all of the children of that node.
void	Stylesheet.run(List<Node> list)
void	Stylesheet.run(List<Node> list, String mode)

Uses of Node in org.dom4j.rule.pattern

Methods in org.dom4j.rule.pattern with parameters of type Node

Modifier and Type	Method	Description
boolean	DefaultPattern.matches(Node node)
boolean	NodeTypePattern.matches(Node node)

Uses of Node in org.dom4j.swing

Fields in org.dom4j.swing declared as Node

Modifier and Type	Field	Description
protected Node	LeafTreeNode.xmlNode	The dom4j Node which contains the

Methods in org.dom4j.swing that return Node

Modifier and Type	Method	Description
Node	LeafTreeNode.getXmlNode()

Methods in org.dom4j.swing that return types with arguments of type Node

Modifier and Type	Method	Description
List<Node>	XMLTableModel.getRows()

Methods in org.dom4j.swing with parameters of type Node

Modifier and Type	Method	Description
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

Constructor	Description
LeafTreeNode(TreeNode parent, Node xmlNode)
LeafTreeNode(Node xmlNode)

Uses of Node in org.dom4j.tree

Classes in org.dom4j.tree with type parameters of type Node

Modifier and Type	Class	Description
class	BackedList<T extends Node>	BackedList represents a list of content of a Branch.
class	ContentListFacade<T extends Node>	ContentListFacade represents a facade of the content of a Branch which is returned via calls to the Branch.content() method to allow users to modify the content of a Branch directly using the List interface.

Classes in org.dom4j.tree that implement Node

Modifier and Type	Class	Description
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.

Fields in org.dom4j.tree with type parameters of type Node

Modifier and Type	Field	Description
protected List<Node>	BaseElement.content	List of content nodes.

Methods in org.dom4j.tree with type parameters of type Node

Modifier and Type	Method	Description
protected <T extends Node> List<T>	AbstractBranch.createEmptyList()	A Factory Method pattern which creates an empty a BackedList implementation
protected <T extends Node> BackedList<T>	AbstractBranch.createResultList()	A Factory Method pattern which creates a BackedList implementation used to store results of a filtered content query.
protected <T extends Node> List<T>	AbstractBranch.createSingleResultList(T result)	A Factory Method pattern which creates a BackedList implementation which contains a single result

Methods in org.dom4j.tree that return Node

Modifier and Type	Method	Description
protected Node	ContentListFacade.asNode(Object object)
Node	AbstractDocument.asXPathResult(Element parent)
Node	AbstractNode.asXPathResult(Element parent)
protected Node	AbstractAttribute.createXPathResult(Element parent)
protected Node	AbstractNode.createXPathResult(Element parent)
protected Node	FlyweightCDATA.createXPathResult(Element parent)
protected Node	FlyweightComment.createXPathResult(Element parent)
protected Node	FlyweightEntity.createXPathResult(Element parent)
protected Node	FlyweightProcessingInstruction.createXPathResult(Element parent)
protected Node	FlyweightText.createXPathResult(Element parent)
Node	AbstractNode.detach()
Node	AbstractElement.getXPathResult(int index)
Node	AbstractBranch.node(int index)
Node	AbstractElement.node(int index)
Node	DefaultElement.node(int index)
Node	AbstractNode.selectSingleNode(String xpathExpression)

Methods in org.dom4j.tree that return types with arguments of type Node

Modifier and Type	Method	Description
List<Node>	AbstractBranch.content()
protected abstract List<Node>	AbstractBranch.contentList()	DOCUMENT ME!
protected List<Node>	BaseElement.contentList()
protected List<Node>	DefaultDocument.contentList()
protected List<Node>	DefaultElement.contentList()
protected List<Node>	AbstractBranch.createContentList()	A Factory Method pattern which creates a List implementation used to store content
protected List<Node>	AbstractBranch.createContentList(int size)	A Factory Method pattern which creates a List implementation used to store content
Iterator<Node>	AbstractBranch.nodeIterator()
Iterator<Node>	AbstractElement.nodeIterator()
Iterator<Node>	DefaultElement.nodeIterator()
List<Node>	AbstractNode.selectNodes(String xpathExpression)
List<Node>	AbstractNode.selectNodes(String xpathExpression, String comparisonXPathExpression)
List<Node>	AbstractNode.selectNodes(String xpathExpression, String comparisonXPathExpression, boolean removeDuplicates)

Methods in org.dom4j.tree with parameters of type Node

Modifier and Type	Method	Description
void	AbstractBranch.add(Node node)
void	AbstractElement.add(Node node)
protected void	AbstractElement.addNewNode(int index, Node node)
protected void	AbstractElement.addNewNode(Node node)	Like addNode() but does not require a parent check
protected void	DefaultElement.addNewNode(Node node)
protected abstract void	AbstractBranch.addNode(int index, Node node)
protected abstract void	AbstractBranch.addNode(Node node)
protected void	AbstractElement.addNode(int index, Node node)
protected void	AbstractElement.addNode(Node node)
protected void	DefaultDocument.addNode(int index, Node node)
protected void	DefaultDocument.addNode(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 void	AbstractDocument.childAdded(Node node)
protected void	AbstractElement.childAdded(Node node)	Called when a new child node is added to create any parent relationships
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	AbstractDocument.childRemoved(Node node)
protected void	AbstractElement.childRemoved(Node node)
int	AbstractBranch.indexOf(Node node)
int	AbstractElement.indexOf(Node node)
int	DefaultElement.indexOf(Node node)
protected void	AbstractBranch.invalidNodeTypeAddException(Node node)	Called when an invalid node has been added.
protected boolean	ElementIterator.matches(Node element)	Deprecated. DOCUMENT ME!
protected boolean	ElementNameIterator.matches(Node object)	Deprecated. DOCUMENT ME!
protected boolean	ElementQNameIterator.matches(Node object)	Deprecated. DOCUMENT ME!
boolean	AbstractBranch.remove(Node node)
boolean	AbstractElement.remove(Node node)
protected abstract boolean	AbstractBranch.removeNode(Node node)
protected boolean	AbstractElement.removeNode(Node node)
protected boolean	DefaultDocument.removeNode(Node node)
protected boolean	DefaultElement.removeNode(Node node)

Method parameters in org.dom4j.tree with type arguments of type Node

Modifier and Type	Method	Description
void	BaseElement.setContent(List<Node> content)
void	DefaultDocument.setContent(List<Node> content)
void	DefaultElement.setContent(List<Node> content)

Constructor parameters in org.dom4j.tree with type arguments of type Node

Constructor	Description
BackedList(AbstractBranch branch, List<Node> branchContent)
BackedList(AbstractBranch branch, List<Node> branchContent, int capacity)
BackedList(AbstractBranch branch, List<Node> branchContent, List<T> initialContent)
ElementIterator(Iterator<Node> proxy)	Deprecated.
ElementNameIterator(Iterator<Node> proxy, String name)	Deprecated.
ElementQNameIterator(Iterator<Node> proxy, QName qName)	Deprecated.

Uses of Node in org.dom4j.util

Classes in org.dom4j.util that implement Node

Modifier and Type	Class	Description
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.getData() 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.getData() UserDataElement.setData(Object)will get and set the values of a user data object.

Methods in org.dom4j.util with type parameters of type Node

Modifier and Type	Method	Description
protected <T extends Node> List<T>	IndexedElement.createList()	Factory method to return a list implementation for indices

Methods in org.dom4j.util with parameters of type Node

Modifier and Type	Method	Description
protected void	IndexedElement.addNode(Node node)
int	NodeComparator.compare(Node n1, Node n2)
protected boolean	IndexedElement.removeNode(Node node)

Uses of Node in org.dom4j.xpath

Methods in org.dom4j.xpath that return Node

Modifier and Type	Method	Description
Node	DefaultXPath.selectSingleNode(Object context)

Methods in org.dom4j.xpath that return types with arguments of type Node

Modifier and Type	Method	Description
List<Node>	DefaultXPath.selectNodes(Object context)
List<Node>	DefaultXPath.selectNodes(Object context, XPath sortXPath)
List<Node>	DefaultXPath.selectNodes(Object context, XPath sortXPath, boolean distinct)

Methods in org.dom4j.xpath with parameters of type Node

Modifier and Type	Method	Description
protected Object	DefaultXPath.getCompareValue(Node node)	DOCUMENT ME!
boolean	DefaultXPath.matches(Node node)
boolean	XPathPattern.matches(Node node)

Method parameters in org.dom4j.xpath with type arguments of type Node

Modifier and Type	Method	Description
protected void	DefaultXPath.removeDuplicates(List<Node> list, Map<Node,Object> sortValues)	Removes items from the list which have duplicate values
protected void	DefaultXPath.removeDuplicates(List<Node> list, Map<Node,Object> sortValues)	Removes items from the list which have duplicate values
void	DefaultXPath.sort(List<Node> list)	sort sorts the given List of Nodes using this XPath expression as a Comparator.
void	DefaultXPath.sort(List<Node> list, boolean distinct)	sort sorts the given List of Nodes using this XPath expression as a Comparatorand optionally removing duplicates.
protected void	DefaultXPath.sort(List<Node> list, Map<Node,Object> sortValues)	Sorts the list based on the sortValues for each node
protected void	DefaultXPath.sort(List<Node> list, Map<Node,Object> sortValues)	Sorts the list based on the sortValues for each node