Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## 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)`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

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