/**
* Returns the result of an XSL Transformation as a JDOM document.
*
* <p>If the result of the transformation is a list of nodes, this method attempts to convert it
* into a JDOM document. If successful, any subsequent call to {@link #getResult} will return an
* empty list.
*
* <p><strong>Warning</strong>: The XSLT 1.0 specification states that the output of an XSL
* transformation is not a well-formed XML document but a list of nodes. Applications should thus
* use {@link #getResult} instead of this method or at least expect <code>null</code> documents to
* be returned.
*
* @return the transformation result as a JDOM document or <code>null</code> if the result of the
* transformation can not be converted into a well-formed document.
* @see #getResult
*/
public Document getDocument() {
Document doc = null;
// Retrieve result from the document builder if not set.
this.retrieveResult();
if (result instanceof Document) {
doc = (Document) result;
} else {
if ((result instanceof List) && (queried == false)) {
// Try to create a document from the result nodes
try {
JDOMFactory f = this.getFactory();
if (f == null) {
f = new DefaultJDOMFactory();
}
doc = f.document(null);
doc.setContent((List) result);
result = doc;
} catch (RuntimeException ex1) {
// Some of the result nodes are not valid children of a
// Document node. => return null.
}
}
}
queried = true;
return (doc);
}
/**
* Pushes an element onto the tree under construction. Allows subclasses to put content under a
* dummy root element which is useful for building content that would otherwise be a non-well
* formed document.
*
* @param element root element under which content will be built
*/
protected void pushElement(Element element) {
if (atRoot) {
document.setRootElement(element); // XXX should we use a factory call?
atRoot = false;
} else {
factory.addContent(currentElement, element);
}
currentElement = element;
}
/**
* This will output the <code>JDOM Document</code>, firing off the SAX events that have been
* registered.
*
* @param document <code>JDOM Document</code> to output.
* @throws JDOMException if any error occurred.
*/
public void output(Document document) throws JDOMException {
if (document == null) {
return;
}
// contentHandler.setDocumentLocator()
documentLocator(document);
// contentHandler.startDocument()
startDocument();
// Fire DTD events
if (this.reportDtdEvents) {
dtdEvents(document);
}
// Handle root element, as well as any root level
// processing instructions and comments
Iterator i = document.getContent().iterator();
while (i.hasNext()) {
Object obj = i.next();
// update locator
locator.setNode(obj);
if (obj instanceof Element) {
// process root element and its content
element(document.getRootElement(), new NamespaceStack());
} else if (obj instanceof ProcessingInstruction) {
// contentHandler.processingInstruction()
processingInstruction((ProcessingInstruction) obj);
} else if (obj instanceof Comment) {
// lexicalHandler.comment()
comment(((Comment) obj).getText());
}
}
// contentHandler.endDocument()
endDocument();
}
/**
* This method tells you the line of the XML file being parsed. For an in-memory document, it's
* meaningless. The location is only valid for the current parsing lifecycle, but the document has
* already been parsed. Therefore, it returns -1 for both line and column numbers.
*
* @param document JDOM <code>Document</code>.
*/
private void documentLocator(Document document) {
locator = new JDOMLocator();
String publicID = null;
String systemID = null;
if (document != null) {
DocType docType = document.getDocType();
if (docType != null) {
publicID = docType.getPublicID();
systemID = docType.getSystemID();
}
}
locator.setPublicId(publicID);
locator.setSystemId(systemID);
locator.setLineNumber(-1);
locator.setColumnNumber(-1);
contentHandler.setDocumentLocator(locator);
}
/**
* This parses a DTD declaration to fire the related events towards the registered handlers.
*
* @param document <code>JDOM Document</code> the DocType is to process.
*/
private void dtdEvents(Document document) throws JDOMException {
DocType docType = document.getDocType();
// Fire DTD-related events only if handlers have been registered.
if ((docType != null) && ((dtdHandler != null) || (declHandler != null))) {
// Build a dummy XML document that only references the DTD...
String dtdDoc = new XMLOutputter().outputString(docType);
try {
// And parse it to fire DTD events.
createDTDParser().parse(new InputSource(new StringReader(dtdDoc)));
// We should never reach this point as the document is
// ill-formed; it does not have any root element.
} catch (SAXParseException e) {
// Expected exception: There's no root element in document.
} catch (SAXException e) {
throw new JDOMException("DTD parsing error", e);
} catch (IOException e) {
throw new JDOMException("DTD parsing error", e);
}
}
}
/**
* This signifies that the reading of the DTD is complete.
*
* @throws SAXException
*/
public void endDTD() throws SAXException {
document.getDocType().setInternalSubset(internalSubset.toString());
inDTD = false;
inInternalSubset = false;
}
/**
* This reports the occurrence of an actual element. It will include the element's attributes,
* with the exception of XML vocabulary specific attributes, such as <code>
* xmlns:[namespace prefix]</code> and <code>xsi:schemaLocation</code>.
*
* @param namespaceURI <code>String</code> namespace URI this element is associated with, or an
* empty <code>String</code>
* @param localName <code>String</code> name of element (with no namespace prefix, if one is
* present)
* @param qName <code>String</code> XML 1.0 version of element name: [namespace
* prefix]:[localName]
* @param atts <code>Attributes</code> list for this element
* @throws SAXException when things go wrong
*/
public void startElement(String namespaceURI, String localName, String qName, Attributes atts)
throws SAXException {
if (suppress) return;
Element element = null;
if ((namespaceURI != null) && (!namespaceURI.equals(""))) {
String prefix = "";
// Determine any prefix on the Element
if (!qName.equals(localName)) {
int split = qName.indexOf(":");
prefix = qName.substring(0, split);
}
Namespace elementNamespace = Namespace.getNamespace(prefix, namespaceURI);
element = factory.element(localName, elementNamespace);
} else {
element = factory.element(localName);
}
// Take leftover declared namespaces and add them to this element's
// map of namespaces
if (declaredNamespaces.size() > 0) {
transferNamespaces(element);
}
// Handle attributes
for (int i = 0, len = atts.getLength(); i < len; i++) {
Attribute attribute = null;
String attLocalName = atts.getLocalName(i);
String attQName = atts.getQName(i);
int attType = getAttributeType(atts.getType(i));
// Bypass any xmlns attributes which might appear, as we got
// them already in startPrefixMapping().
// This is sometimes necessary when SAXHandler is used with
// another source than SAXBuilder, as with JDOMResult.
if (attQName.startsWith("xmlns:") || attQName.equals("xmlns")) {
continue;
}
// First clause per http://markmail.org/message/2p245ggcjst27xe6
// patch from Mattias Jiderhamn
if ("".equals(attLocalName) && attQName.indexOf(":") == -1) {
attribute = factory.attribute(attQName, atts.getValue(i), attType);
} else if (!attQName.equals(attLocalName)) {
String attPrefix = attQName.substring(0, attQName.indexOf(":"));
Namespace attNs = Namespace.getNamespace(attPrefix, atts.getURI(i));
attribute = factory.attribute(attLocalName, atts.getValue(i), attType, attNs);
} else {
attribute = factory.attribute(attLocalName, atts.getValue(i), attType);
}
factory.setAttribute(element, attribute);
}
flushCharacters();
if (atRoot) {
document.setRootElement(element); // XXX should we use a factory call?
atRoot = false;
} else {
factory.addContent(getCurrentElement(), element);
}
currentElement = element;
}
public void startDocument() {
if (locator != null) {
document.setBaseURI(locator.getSystemId());
}
}
