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

dom4j API

previous page next page
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 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!
 

Overview  Package  Class   Use  Tree  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    
Copyright © 2001-2005 MetaStuff Ltd.. All Rights Reserved.

previous page start next page