## Uses of Interface
org.dom4j.Element

Packages that use Element
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.jaxb
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.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
org.dom4j.xpp: Provides implementation classes to cleanly integrate dom4j with the XML Pull Parser XPP

Uses of Element in org.dom4j

Methods in org.dom4j that return Element
`Element` `Node.getParent()` `getParent` returns the parent `Element` if this node supports the parent relationship or null if it is the root element or does not support the parent relationship.
`Element` `ElementPath.getElement(int depth)` DOCUMENT ME!
`Element` `ElementPath.getCurrent()` DOCUMENT ME!
`Element` `Element.addAttribute(String name, String value)` Adds the attribute value of the given local name.
`Element` `Element.addAttribute(QName qName, String value)` Adds the attribute value of the given fully qualified name.
`Element` `Element.addComment(String comment)` Adds a new `Comment` node with the given text to this element.
`Element` `Element.addCDATA(String cdata)` Adds a new `CDATA` node with the given text to this element.
`Element` `Element.addEntity(String name, String text)` Adds a new `Entity` node with the given name and text to this element and returns a reference to the new node.
`Element` `Element.addNamespace(String prefix, String uri)` Adds a namespace to this element for use by its child content
`Element` `Element.addProcessingInstruction(String target, String text)` Adds a processing instruction for the given target
`Element` `Element.addProcessingInstruction(String target, Map data)` Adds a processing instruction for the given target
`Element` `Element.addText(String text)` Adds a new `Text` node with the given text to this element.
`Element` `Element.element(String name)` Returns the first element for the given local name and any namespace.
`Element` `Element.element(QName qName)` Returns the first element for the given fully qualified name.
`Element` `Element.createCopy()` Creates a deep copy of this element The new element is detached from its parent, and getParent() on the clone will return null.
`Element` `Element.createCopy(String name)` Creates a deep copy of this element with the given local name The new element is detached from its parent, and getParent() on the clone will return null.
`Element` `Element.createCopy(QName qName)` Creates a deep copy of this element with the given fully qualified name.
`static Element` `DocumentHelper.createElement(QName qname)`
`static Element` `DocumentHelper.createElement(String name)`
`static Element` `DocumentHelper.makeElement(Branch source, String path)` makeElement a helper method which navigates from the given Document or Element node to some Element using the path expression, creating any necessary elements along the way.
`Element` `DocumentFactory.createElement(QName qname)`
`Element` `DocumentFactory.createElement(String name)`
`Element` `DocumentFactory.createElement(String qualifiedName, String namespaceURI)`
`Element` `Document.getRootElement()` Returns the root `Element`for this document.
`Element` `Branch.elementByID(String elementID)` Returns the element of the given ID attribute value.
`Element` `Branch.addElement(String name)` Adds a new `Element` node with the given name to this branch and returns a reference to the new node.
`Element` `Branch.addElement(QName qname)` Adds a new `Element` node with the given `QName`to this branch and returns a reference to the new node.
`Element` `Branch.addElement(String qualifiedName, String namespaceURI)` Adds a new `Element` node with the given qualified name and namespace URI to this branch and returns a reference to the new node.

Methods in org.dom4j with parameters of type Element
`void` `VisitorSupport.visit(Element node)`
`void` `Visitor.visit(Element node)` Visits the given `Element`
`void` `Node.setParent(Element parent)` `setParent` sets the parent relationship of this node if the parent relationship is supported or does nothing if the parent relationship is not supported.
`String` `Node.getPath(Element context)` Returns the relative XPath expression which will return a node set containing the given node such as a/b/@c.
`String` `Node.getUniquePath(Element context)` Returns the relative unique XPath expression from the given context which will return a nodeset of one node which is the current node.
`Node` `Node.asXPathResult(Element parent)` `asXPathResult` returns a version of this node which is capable of being an XPath result.
`String` `Namespace.getPath(Element context)`
`String` `Namespace.getUniquePath(Element context)`
`protected Node` `Namespace.createXPathResult(Element parent)`
`void` `Element.appendAttributes(Element element)` Appends the attributes of the given element to me.
`static Document` `DocumentHelper.createDocument(Element rootElement)`
`static Attribute` `DocumentHelper.createAttribute(Element owner, QName qname, String value)`
`static Attribute` `DocumentHelper.createAttribute(Element owner, String name, String value)`
`Document` `DocumentFactory.createDocument(Element rootElement)`
`Attribute` `DocumentFactory.createAttribute(Element owner, QName qname, String value)`
`Attribute` `DocumentFactory.createAttribute(Element owner, String name, String value)`
`void` `Document.setRootElement(Element rootElement)` Sets the root element for this document
`void` `Branch.add(Element element)` Adds the given `Element` to this branch.
`boolean` `Branch.remove(Element element)` Removes the given `Element` if the node is an immediate child of this branch.

Constructors in org.dom4j with parameters of type Element
`IllegalAddException(Element parent, Node node, String reason)`

Uses of Element in org.dom4j.bean

Classes in org.dom4j.bean that implement Element
`class` `BeanElement` `BeanElement` uses a Java Bean to store its attributes.

Methods in org.dom4j.bean that return Element
`Element` `BeanElement.addAttribute(String name, String value)`
`Element` `BeanElement.addAttribute(QName qName, String value)`
`Element` `BeanDocumentFactory.createElement(QName qname)`
`Element` `BeanDocumentFactory.createElement(QName qname, Attributes attributes)`
`Element` `BeanAttribute.getParent()`

Methods in org.dom4j.bean with parameters of type Element
`Attribute` `BeanDocumentFactory.createAttribute(Element owner, QName qname, String value)`

Uses of Element in org.dom4j.datatype

Classes in org.dom4j.datatype that implement Element
`class` `DatatypeElement` `DatatypeElement` represents an Element which supports the XML Schema Data Types specification.

Methods in org.dom4j.datatype that return Element
`Element` `DatatypeElementFactory.createElement(QName qname)`
`Element` `DatatypeElement.addText(String text)`
`Element` `DatatypeAttribute.getParent()`

Methods in org.dom4j.datatype with parameters of type Element
`Attribute` `DatatypeElementFactory.createAttribute(Element owner, QName qname, String value)`
`Attribute` `DatatypeDocumentFactory.createAttribute(Element owner, QName qname, String value)`
`void` `DatatypeAttribute.setParent(Element parent)`

Uses of Element in org.dom4j.dom

Classes in org.dom4j.dom that implement Element
`class` `DOMElement` `DOMElement` implements an XML element which supports the W3C DOM API.

Methods in org.dom4j.dom that return Element
`Element` `DOMDocumentFactory.createElement(QName qname)`
`Element` `DOMDocumentFactory.createElement(QName qname, int attributeCount)`

Methods in org.dom4j.dom with parameters of type Element
`Attribute` `DOMDocumentFactory.createAttribute(Element owner, QName qname, String value)`

Constructors in org.dom4j.dom with parameters of type Element
`DOMText(Element parent, String text)`
`DOMProcessingInstruction(Element parent, String target, String val)`
`DOMNamespace(Element parent, String prefix, String uri)`
`DOMEntityReference(Element parent, String name, String text)`
`DOMComment(Element parent, String text)`
`DOMCDATA(Element parent, String text)`
`DOMAttribute(Element parent, QName qname, String value)`

Uses of Element in org.dom4j.io

Methods in org.dom4j.io that return Element
`Element` `STAXEventReader.readElement(javax.xml.stream.XMLEventReader eventReader)` Reads a DOM4J Element from the provided event stream.
`Element` `STAXEventReader.createElement(javax.xml.stream.events.StartElement startEvent)` Constructs a new DOM4J Element from the provided StartElement event.
`Element` `ElementModifier.modifyElement(Element element)` Called by an event based processor when an elements closing tag is encountered.

Methods in org.dom4j.io with parameters of type Element
`void` `XMLWriter.write(Element element)` Writes the ``Element``, including its ``Attribute`` s, and its value, and all its content (child nodes) to the current Writer.
`void` `XMLWriter.writeOpen(Element element)` Writes the opening tag of an `Element`, including its `Attribute`s but without its content.
`void` `XMLWriter.writeClose(Element element)` Writes the closing tag of an `Element`
`protected void` `XMLWriter.writeElement(Element element)`
`protected boolean` `XMLWriter.isElementSpacePreserved(Element element)` Determines if element is a special case of XML elements where it contains an xml:space attribute of "preserve".
`protected void` `XMLWriter.writeElementContent(Element element)` Outputs the content of the given element.
`protected void` `XMLWriter.writeAttributes(Element element)` Writes the attributes of the given element
`void` `STAXEventWriter.writeElement(Element elem)` Writes a DOM4J `Element`node and its children to the stream.
`javax.xml.stream.events.StartElement` `STAXEventWriter.createStartElement(Element elem)` Constructs a STAX `StartElement`event from a DOM4J `Element`.
`javax.xml.stream.events.EndElement` `STAXEventWriter.createEndElement(Element elem)` Constructs a STAX `EndElement`event from a DOM4J `Element`.
`Attribute` `STAXEventReader.createAttribute(Element elem, javax.xml.stream.events.Attribute attr)` Constructs a new DOM4J Attribute from the provided StAX Attribute event.
`void` `SAXWriter.write(Element element)` Generates SAX events for the given Element and all its content
`void` `SAXWriter.writeOpen(Element element)` Writes the opening tag of an `Element`, including its `Attribute`s but without its content.
`void` `SAXWriter.writeClose(Element element)` Writes the closing tag of an `Element`
`protected void` `SAXWriter.write(Element element, NamespaceStack namespaceStack)`
`protected AttributesImpl` `SAXWriter.startPrefixMapping(Element element, NamespaceStack namespaceStack)` Fires a SAX startPrefixMapping event for all the namespaceStack which have just come into scope
`protected void` `SAXWriter.startElement(Element element, AttributesImpl namespaceAttributes)`
`protected void` `SAXWriter.endElement(Element element)`
`protected Attributes` `SAXWriter.createAttributes(Element element, Attributes namespaceAttributes)`
`protected void` `SAXContentHandler.addDeclaredNamespaces(Element element)` Add all namespaces declared before the startElement() SAX event to the current element so that they are available to child elements and attributes
`protected void` `SAXContentHandler.addAttributes(Element element, Attributes attributes)` Add all the attributes to the given elements
`protected void` `HTMLWriter.writeElement(Element element)` This override handles any elements that should not remove whitespace, such as <PRE>, <SCRIPT>, <STYLE>, and <TEXTAREA>.
`Element` `ElementModifier.modifyElement(Element element)` Called by an event based processor when an elements closing tag is encountered.
`protected void` `DOMWriter.appendDOMTree(Document domDocument, Node domCurrent, Element element)`

Uses of Element in org.dom4j.jaxb

Methods in org.dom4j.jaxb with parameters of type Element
`void` `JAXBWriter.writeElement(Element element)` Writes the specified `Element`to the document.
`void` `JAXBWriter.writeCloseElement(Element element)` Writes the closing tag of the specified `Element`to the document.
`void` `JAXBWriter.writeOpenElement(Element element)` Writes the opening tag of the specified `Element`to the document.

Uses of Element in org.dom4j.rule

Methods in org.dom4j.rule with parameters of type Element
`void` `Mode.applyTemplates(Element element)`

Uses of Element in org.dom4j.swing

Methods in org.dom4j.swing with parameters of type Element
`static XMLTableDefinition` `XMLTableDefinition.load(Element definition)` Loads an XML table definition from an XML definition document

Constructors in org.dom4j.swing with parameters of type Element
`XMLTableModel(Element tableDefinition, Object source)` Creates a TableModel from an XML table definition document and an XML source

Uses of Element in org.dom4j.tree

Classes in org.dom4j.tree that implement Element
`class` `AbstractElement` `AbstractElement` 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` `DefaultElement` `DefaultElement` is the default DOM4J default implementation of an XML element.

Methods in org.dom4j.tree that return Element
`Element` `DefaultText.getParent()`
`Element` `DefaultProcessingInstruction.getParent()`
`Element` `DefaultNamespace.getParent()`
`Element` `DefaultEntity.getParent()`
`Element` `DefaultElement.getParent()`
`Element` `DefaultElement.element(String name)`
`Element` `DefaultElement.element(QName qName)`
`Element` `DefaultElement.element(String name, Namespace namespace)`
`Element` `DefaultDocument.getRootElement()`
`Element` `DefaultComment.getParent()`
`Element` `DefaultCDATA.getParent()`
`Element` `DefaultAttribute.getParent()`
`Element` `BaseElement.getParent()`
`Element` `AbstractNode.getParent()`
`Element` `AbstractElement.element(String name)`
`Element` `AbstractElement.element(QName qName)`
`Element` `AbstractElement.element(String name, Namespace namespace)`
`Element` `AbstractElement.addAttribute(String name, String value)`
`Element` `AbstractElement.addAttribute(QName qName, String value)`
`Element` `AbstractElement.addCDATA(String cdata)`
`Element` `AbstractElement.addComment(String comment)`
`Element` `AbstractElement.addElement(String name)`
`Element` `AbstractElement.addEntity(String name, String text)`
`Element` `AbstractElement.addNamespace(String prefix, String uri)`
`Element` `AbstractElement.addProcessingInstruction(String target, String data)`
`Element` `AbstractElement.addProcessingInstruction(String target, Map data)`
`Element` `AbstractElement.addText(String text)`
`Element` `AbstractElement.createCopy()` This returns a deep clone of this element.
`Element` `AbstractElement.createCopy(String name)`
`Element` `AbstractElement.createCopy(QName qName)`
`protected Element` `AbstractElement.createElement(String name)`
`protected Element` `AbstractElement.createElement(QName qName)`
`Element` `AbstractDocument.addElement(String name)`
`Element` `AbstractDocument.addElement(String qualifiedName, String namespaceURI)`
`Element` `AbstractDocument.addElement(QName qName)`
`Element` `AbstractBranch.addElement(String name)`
`Element` `AbstractBranch.addElement(String qualifiedName, String namespaceURI)`
`Element` `AbstractBranch.addElement(QName qname)`
`Element` `AbstractBranch.addElement(String name, String prefix, String uri)`
`Element` `AbstractBranch.elementByID(String elementID)`

Methods in org.dom4j.tree with parameters of type Element
`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)`
`void` `DefaultText.setParent(Element parent)`
`void` `DefaultProcessingInstruction.setParent(Element parent)`
`void` `DefaultNamespace.setParent(Element parent)`
`void` `DefaultEntity.setParent(Element parent)`
`void` `DefaultElement.setParent(Element parent)`
`protected void` `DefaultDocument.rootElementAdded(Element element)`
`void` `DefaultComment.setParent(Element parent)`
`void` `DefaultCDATA.setParent(Element parent)`
`void` `DefaultAttribute.setParent(Element parent)`
`void` `BaseElement.setParent(Element parent)`
`String` `AbstractProcessingInstruction.getPath(Element context)`
`String` `AbstractProcessingInstruction.getUniquePath(Element context)`
`void` `AbstractNode.setParent(Element parent)`
`Node` `AbstractNode.asXPathResult(Element parent)`
`protected Node` `AbstractNode.createXPathResult(Element parent)`
`String` `AbstractEntity.getPath(Element context)`
`String` `AbstractEntity.getUniquePath(Element context)`
`String` `AbstractElement.getPath(Element context)`
`String` `AbstractElement.getUniquePath(Element context)`
`void` `AbstractElement.add(Element element)`
`boolean` `AbstractElement.remove(Element element)`
`void` `AbstractElement.appendAttributes(Element element)`
`String` `AbstractDocumentType.getPath(Element context)`
`String` `AbstractDocumentType.getUniquePath(Element context)`
`String` `AbstractDocument.getPath(Element context)`
`String` `AbstractDocument.getUniquePath(Element context)`
`void` `AbstractDocument.setRootElement(Element rootElement)`
`void` `AbstractDocument.add(Element element)`
`boolean` `AbstractDocument.remove(Element element)`
`Node` `AbstractDocument.asXPathResult(Element parent)`
`protected void` `AbstractDocument.checkAddElementAllowed(Element element)`
`protected abstract void` `AbstractDocument.rootElementAdded(Element rootElement)` Called to set the root element variable
`String` `AbstractComment.getPath(Element context)`
`String` `AbstractComment.getUniquePath(Element context)`
`String` `AbstractCharacterData.getPath(Element context)`
`String` `AbstractCharacterData.getUniquePath(Element context)`
`void` `AbstractBranch.add(Element element)`
`boolean` `AbstractBranch.remove(Element element)`
`protected String` `AbstractBranch.elementID(Element element)` DOCUMENT ME!
`String` `AbstractAttribute.getPath(Element context)`
`String` `AbstractAttribute.getUniquePath(Element context)`
`protected Node` `AbstractAttribute.createXPathResult(Element parent)`

Constructors in org.dom4j.tree with parameters of type Element
`DefaultText(Element parent, String text)` DOCUMENT ME!
`DefaultProcessingInstruction(Element parent, String target, String values)` This will create a new PI with the given target and values
`DefaultNamespace(Element parent, String prefix, String uri)` DOCUMENT ME!
`DefaultEntity(Element parent, String name, String text)` Creates the `Entity` with the specified name and text.
`DefaultDocument(Element rootElement)`
`DefaultDocument(Element rootElement, DocumentType docType)`
`DefaultDocument(String name, Element rootElement, DocumentType docType)`
`DefaultComment(Element parent, String text)` DOCUMENT ME!
`DefaultCDATA(Element parent, String text)` DOCUMENT ME!
`DefaultAttribute(Element parent, QName qname, String value)`
`DefaultAttribute(Element parent, String name, String value, Namespace namespace)` Creates the `Attribute` with the specified local name, value and `Namespace`.

Uses of Element in org.dom4j.util

Classes in org.dom4j.util that implement Element
`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` `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 that return Element
`Element` `XMLErrorHandler.getErrors()`
`protected Element` `UserDataElement.createElement(String name)`
`protected Element` `UserDataElement.createElement(QName qName)`
`Element` `UserDataDocumentFactory.createElement(QName qname)`
`Element` `ProxyDocumentFactory.createElement(QName qname)`
`Element` `ProxyDocumentFactory.createElement(String name)`
`Element` `NonLazyDocumentFactory.createElement(QName qname)`
`Element` `IndexedElement.element(String name)`
`Element` `IndexedElement.element(QName qName)`
`protected Element` `IndexedElement.asElement(Object object)`
`Element` `IndexedDocumentFactory.createElement(QName qname)`
`Element` `IndexedDocumentFactory.createElement(QName qname, int attributeCount)`

Methods in org.dom4j.util with parameters of type Element
`void` `XMLErrorHandler.setErrors(Element errors)`
`protected void` `XMLErrorHandler.addException(Element element, SAXParseException e)` Adds the given parse exception information to the given element instance
`Attribute` `UserDataDocumentFactory.createAttribute(Element owner, QName qname, String value)`
`Document` `ProxyDocumentFactory.createDocument(Element rootElement)`
`Attribute` `ProxyDocumentFactory.createAttribute(Element owner, QName qname, String value)`
`Attribute` `ProxyDocumentFactory.createAttribute(Element owner, String name, String value)`
`int` `NodeComparator.compare(Element n1, Element n2)`
`protected void` `IndexedElement.addToElementIndex(Element element)`
`protected void` `IndexedElement.addToElementIndex(Object key, Element value)`
`protected void` `IndexedElement.removeFromElementIndex(Element element)`
`protected void` `IndexedElement.removeFromElementIndex(Object key, Element value)`
`static boolean` `AttributeHelper.booleanValue(Element element, String attributeName)`
`static boolean` `AttributeHelper.booleanValue(Element element, QName attributeQName)`

Constructors in org.dom4j.util with parameters of type Element
`XMLErrorHandler(Element errors)`

Uses of Element in org.dom4j.xpath

Constructors in org.dom4j.xpath with parameters of type Element
`DefaultNamespaceContext(Element element)`

Uses of Element in org.dom4j.xpp

Methods in org.dom4j.xpp that return Element
`Element` `ProxyXmlStartTag.getElement()`

Constructors in org.dom4j.xpp with parameters of type Element
`ProxyXmlStartTag(Element element)`

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