Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

org.dom4j.bean.* (6)org.dom4j.datatype.* (15)org.dom4j.dom.* (14)
org.dom4j.dtd.* (8)org.dom4j.io.* (42)org.dom4j.jaxb.* (7)
org.dom4j.rule.* (13)org.dom4j.samples.* (49)org.dom4j.swing.* (7)
org.dom4j.tree.* (44)org.dom4j.util.* (16)org.dom4j.xpath.* (20)
org.dom4j.xpp.* (1)

org.dom4j: Javadoc index of package org.dom4j.


Package Samples:

org.dom4j.rule.pattern: A org.dom4j.rule.Pattern based XML rule engine which implements the full XSLT processing model while allowing any org.dom4j.rule.Action to be fired if a pattern matches.  
org.dom4j.xpp: Defines the XML Document Object Model in Java interfaces together with some helper classes.  
org.dom4j.bean
org.dom4j.datatype
org.dom4j.dom
org.dom4j.dtd
org.dom4j.io
org.dom4j.jaxb
org.dom4j.rule
org.dom4j.swing
org.dom4j.tree
org.dom4j.util
org.dom4j.xpath
org.dom4j.samples.applets
org.dom4j.samples.bean
org.dom4j.samples.dom
org.dom4j.samples.jaxb
org.dom4j.samples.jaxp
org.dom4j.samples.performance
org.dom4j.samples.rule

Classes:

HTMLWriter: HTMLWriter takes a DOM4J tree and formats it to a stream as HTML. This formatter is similar to XMLWriter but it outputs the text of CDATA and Entity sections rather than the serialised format as in XML, it has an XHTML mode, it retains whitespace in certain elements such as <PRE>, and it supports certain elements which have no corresponding close tag such as for <BR> and <P>. The OutputFormat passed in to the constructor is checked for isXHTML() and isExpandEmptyElements(). See OutputFormat for details. Here are the rules for this class based on an OutputFormat, "format", passed ...
ConcurrentReaderHashMap: A version of Hashtable that supports mostly-concurrent reading, but exclusive writing. Because reads are not limited to periods without writes, a concurrent reader policy is weaker than a classic reader/writer policy, but is generally faster and allows more concurrency. This class is a good choice especially for tables that are mainly created by one thread during the start-up phase of a program, and from then on, are mainly read (with perhaps occasional additions or removals) in many threads. If you also need concurrency among writes, consider instead using ConcurrentHashMap. Successful retrievals ...
SAXReader: SAXReader creates a DOM4J tree from SAX parsing events. The actual SAX parser that is used by this class is configurable so you can use your favourite SAX parser if you wish. DOM4J comes configured with its own SAX parser so you do not need to worry about configuring the SAX parser. To explicitly configure the SAX parser that is used via Java code you can use a constructor or use the setXMLReader(XMLReader) 55 or setXMLReaderClassName(String) 55 methods. If the parser is not specified explicitly then the standard SAX policy of using the org.xml.sax.driver system property is used to determine the ...
XMLWriter: XMLWriter takes a DOM4J tree and formats it to a stream as XML. It can also take SAX events too so can be used by SAX clients as this object implements the org.xml.sax.ContentHandler and org.xml.sax.ext.LexicalHandler interfaces. as well. This formatter performs typical document formatting. The XML declaration and processing instructions are always on their own lines. An OutputFormat object can be used to define how whitespace is handled when printing and allows various configuration options, such as to allow suppression of the XML declaration, the encoding declaration or whether empty documents ...
SAXEventRecorder: Records SAX events such that they may be "replayed" at a later time. Provides an alternative serialization approach when externalizing a DOM4J document. Rather than serializing a document as text and re-parsing, the sax events may be serialized instead. Example usage: SAXEventRecorder recorder = new SAXEventRecorder(); SAXWriter saxWriter = new SAXWriter(recorder, recorder); saxWriter.write(document); out.writeObject(recorder); ... SAXEventRecorder recorder = (SAXEventRecorder)in.readObject(); SAXContentHandler saxContentHandler = new SAXContentHandler(); recorder.replay(saxContentHandler); Document ...
AttributeDeclTest: Tests the AttributeDeclTest.MyTestAttributeDecl functionality. Tests each of the property access methods and the serialization mechanisms. Correct parsing is tested by DocTypeTest . There are several key variations that need to be tested both here and in DocTypeTest , which is responsible for testing correct parsing of the DocumentType . Those variations include the different valueDefault and value variations so that we can test for correct acceptance and correct rejection of attribute declarations.
DefaultPattern: DefaultPattern a default implementation of Pattern which can take any XPath implementation or NodeFilter for defining the pattern. WARNING this implementation causes a worst case, brute force XSLT rule evaluation to be performed. Wherever possible the methods getPriority() 55 , getMatchType() 55 and getMatchesNodeName() 55 should be overloaded to allow more rule filtering to occur.
ContentListFacade: ContentListFacade represents a facade of the content of a org.dom4j.Branch which is returned via calls to the Branch.content() > Branch.content() 55 method to allow users to modify the content of a org.dom4j.Branch directly using the java.util.List interface. This list is backed by the branch such that changes to the list will be reflected in the branch and changes to the branch will be reflected in this list.
Visitor: Visitor is used to implement the Visitor pattern in DOM4J. An object of this interface can be passed to a Node which will then call its typesafe methods. Please refer to the Gang of Four book of Design Patterns for more details on the Visitor pattern. This site has further discussion on design patterns and links to the GOF book. This link describes the Visitor pattern in detail.
SAXModifier: The SAXModifier reads, modifies and writes XML documents using SAX. Registered ElementModifier objects can provide modifications to (part of) the xml tree, while the document is still being processed. This makes it possible to change large xml documents without having them in memory. The modified document is written when the XMLWriter is specified.
SAXModifyElementHandler: This org.dom4j.ElementHandler is used to trigger ElementModifier objects in order to modify (parts of) the Document on the fly. When an element is completely parsed, a copy is handed to the associated (if any) ElementModifier that on his turn returns the modified element that has to come in the tree.
DispatchHandler: DispatchHandler implements the ElementHandler interface and provides a means to register multiple ElementHandler instances to be used by an event based processor. This is a special ElementHandler in that it's onStart and onEnd implementation methods are called for every element encountered during the parse. It then delegates to other ElementHandler instances registered with it to process the elements encountered.
Element: Element interface defines an XML element. An element can have declared namespaces, attributes, child nodes and textual content. Some of this interface is optional. Some implementations may be read-only and not support being modified. Some implementations may not support the parent relationship and methods such as Node.getParent() 55 or .
FlyweightEntity: FlyweightEntity is a Flyweight pattern implementation of a singly linked, read-only XML entity. This node could be shared across documents and elements though it does not support the parent relationship. Often this node needs to be created and then the text content added later (for example in SAX) so this implementation allows a call to providing the entity has no text already.
UserDataAttribute: UserDataAttribute support the adornment of a user data object on an Element or Attribute instance such that the methods setData(Object) 55 will get and set the values of a user data object. This can be useful for developers wishing to create XML trees and adorn the trees with user defined objects.
UserDataElement: UserDataElement support the adornment of a user data object on an Element or Attribute instance such that the methods setData(Object) 55 will get and set the values of a user data object. This can be useful for developers wishing to create XML trees and adorn the trees with user defined objects.
UserDataDocumentFactory: UserDataDocumentFactory is a factory of XML objects which support the adornment of a user data object on an Element or Attribute instance such that the methods getData() and setData() will get and set the values of a user data object. This can be useful for developers wishing to create XML trees and adorn the trees with user defined objects.
SAXModifyReader: The SAXModifier parses, updates and writes an XML document. The input that is parsed is directly written to the specified output, unless the current xml element has an associated ElementHandler. The org.dom4j.ElementHandler objects make it possible to update the document on the fly, without having read tje complete document.
SAXDOMDemo: This sample program parses an XML document as a DOM4J tree using SAX, it then creates a W3C DOM tree which is then used as input for creating a new DOM4J tree which is then output to SAX which is then parsed into another DOM4J tree which is then output as XML. This is clearly not terribly useful but demonstrates how to convert from SAX DOM4J and DOM4J DOM and DOM4J text
ProxyDocumentFactory: ProxyDocumentFactory implements a proxy to a DocumentFactory which is useful for implementation inheritence, allowing the pipelining of various factory implementations. For example an EncodingDocumentFactory which takes care of encoding strings outside of allowable XML ranges could be used with a DatatypeDocumentFactory which is XML Schema Data Type aware.
JAXBModifier: Reads an XML document using SAX and writes its content to the provided org.dom4j.io.XMLWriter . Modifications must be provided by JAXBObjectModifier objects, which are called prior to writing the XML fragment they are registered for.
ElementStack: ElementStack is used internally inside the SAXContentHandler to maintain a stack of org.dom4j.Element instances. It opens an integration possibility allowing derivations to prune the tree when a node is complete.
ProcessingInstruction: ProcessingInstruction defines an XML processing instruction. The Node.getName() 55 method will return the target of the PI and the Node.getText() 55 method will return the data from all of the instructions.
PruningElementStack: PruningElementStack is a stack of org.dom4j.Element instances which will prune the tree when a path expression is reached. This is useful for parsing very large documents where children of the root element can be processed individually rather than keeping them all in memory at the same time.
ElementPath: This interface is used by ElementHandler instances to retrieve information about the current path hierarchy they are to process. It's primary use is to retrieve the current Element being processed.

Home | Contact Us | Privacy Policy | Terms of Service