private Object deserializeInstance(
IndentedLogger indentedLogger,
boolean isReadonly,
boolean isHandleXInclude,
ConnectionResult connectionResult)
throws Exception {
final Object resultingDocument;
// Create resulting instance whether entire instance is replaced or not, because this:
// 1. Wraps a Document within a DocumentInfo if needed
// 2. Performs text nodes adjustments if needed
try {
if (!isReadonly) {
// Resulting instance must not be read-only
// TODO: What about configuring validation? And what default to choose?
resultingDocument =
TransformerUtils.readDom4j(
connectionResult.getResponseInputStream(),
connectionResult.resourceURI,
isHandleXInclude,
true);
if (indentedLogger.isDebugEnabled())
indentedLogger.logDebug("", "deserializing to mutable instance");
} else {
// Resulting instance must be read-only
// TODO: What about configuring validation? And what default to choose?
// NOTE: isApplicationSharedHint is always false when get get here.
// isApplicationSharedHint="true" is handled above.
resultingDocument =
TransformerUtils.readTinyTree(
XPathCache.getGlobalConfiguration(),
connectionResult.getResponseInputStream(),
connectionResult.resourceURI,
isHandleXInclude,
true);
if (indentedLogger.isDebugEnabled())
indentedLogger.logDebug("", "deserializing to read-only instance");
}
} catch (Exception e) {
throw new XFormsSubmissionException(
submission,
e,
"xforms:submission: exception while reading XML response.",
"processing instance replacement",
new XFormsSubmitErrorEvent(
containingDocument,
submission,
XFormsSubmitErrorEvent.ErrorType.PARSE_ERROR,
connectionResult));
}
return resultingDocument;
}
/** Transform a SAX Source to a TinyTree. */
public static DocumentInfo readTinyTree(
Configuration configuration, Source source, boolean handleXInclude) {
final TinyBuilder treeBuilder = new TinyBuilder();
try {
if (handleXInclude) {
// Insert XIncludeContentHandler
final TransformerXMLReceiver identityHandler = getIdentityTransformerHandler(configuration);
identityHandler.setResult(treeBuilder);
final XMLReceiver receiver =
new XIncludeProcessor.XIncludeXMLReceiver(
null,
identityHandler,
null,
new TransformerURIResolver(XMLUtils.ParserConfiguration.PLAIN));
TransformerUtils.sourceToSAX(source, receiver);
} else {
final Transformer identity = getIdentityTransformer(configuration);
identity.transform(source, treeBuilder);
}
} catch (TransformerException e) {
throw new OXFException(e);
}
return (DocumentInfo) treeBuilder.getCurrentRoot();
}
public static org.dom4j.Document createDocument(DebugXML debugXML) {
final TransformerXMLReceiver identity = TransformerUtils.getIdentityTransformerHandler();
final LocationDocumentResult result = new LocationDocumentResult();
identity.setResult(result);
final ContentHandlerHelper helper =
new ContentHandlerHelper(
new ForwardingXMLReceiver(identity) {
@Override
public void startDocument() {}
@Override
public void endDocument() {}
});
try {
identity.startDocument();
debugXML.toXML(helper);
identity.endDocument();
} catch (SAXException e) {
throw new OXFException(e);
}
return result.getDocument();
}
public void serialize(PipelineContext pipelineContext, URL url) {
try {
if (OXFHandler.PROTOCOL.equals(url.getProtocol())) {
// NOTE: This is probably done as an optimization. Is this really necessary?
final OutputStream os = ResourceManagerWrapper.instance().getOutputStream(url.getFile());
try {
final TransformerXMLReceiver identity = TransformerUtils.getIdentityTransformerHandler();
identity.setResult(new StreamResult(os));
readInputAsSAX(pipelineContext, INPUT_DATA, identity);
} finally {
// Clean up
if (os != null) os.close();
}
} else {
// Open the URL
final URLConnection conn = url.openConnection();
try {
conn.setDoOutput(true);
conn.connect();
final OutputStream os = conn.getOutputStream();
try {
// Create an identity transformer and start the transformation
final TransformerXMLReceiver identity =
TransformerUtils.getIdentityTransformerHandler();
identity.setResult(new StreamResult(os));
readInputAsSAX(pipelineContext, INPUT_DATA, identity);
} finally {
// Clean up
if (os != null) os.close();
}
} finally {
// Clean up
if (conn instanceof HttpURLConnection) ((HttpURLConnection) conn).disconnect();
}
}
} catch (Exception e) {
throw new OXFException(e);
}
}
public static String domToString(Node node) {
try {
Transformer transformer = TransformerUtils.getXMLIdentityTransformer();
DOMSource source = new DOMSource(node);
StringBuilderWriter writer = new StringBuilderWriter();
transformer.transform(source, new StreamResult(writer));
return writer.toString();
} catch (TransformerException e) {
throw new OXFException(e);
}
}
private XMLReceiver getDebugReceiver(final IndentedLogger indentedLogger) {
final TransformerXMLReceiver identity = TransformerUtils.getIdentityTransformerHandler();
final StringBuilderWriter writer = new StringBuilderWriter();
identity.setResult(new StreamResult(writer));
return new ForwardingXMLReceiver(identity) {
@Override
public void endDocument() throws SAXException {
super.endDocument();
// Log out at end of document
indentedLogger.logDebug("", "static state input", "input", writer.toString());
}
};
}
/**
* Transform a SAXStore into a DOM document
*
* @param saxStore input SAXStore
* @return DOM document
*/
public static org.w3c.dom.Document saxStoreToDomDocument(SAXStore saxStore) {
try {
// Convert to dom4j and then to DOM
return TransformerUtils.dom4jToDomDocument(saxStoreToDom4jDocument(saxStore));
} catch (TransformerException e) {
throw new OXFException(e);
}
// NOTE: The more straight and efficient implementation below doesn't seem to work
// final TransformerHandler identity = getIdentityTransformerHandler();
// final DOMResult domResult = new DOMResult();
// identity.setResult(domResult);
// try {
// saxStore.replay(identity);
// } catch (SAXException e) {
// throw new OXFException(e);
// }
// return domResult.getNode().getOwnerDocument();
}
public Item evaluateItem(XPathContext xpathContext) throws XPathException {
// Get parameters
final Item item = argument[0].evaluateItem(xpathContext);
final String excludeResultPrefixes =
argument.length >= 2 ? argument[1].evaluateAsString(xpathContext).toString() : null;
final boolean readonly =
argument.length >= 3
&& ExpressionTool.effectiveBooleanValue(argument[2].iterate(xpathContext));
// Make sure it is a NodeInfo
if (!(item instanceof NodeInfo)) {
return null;
}
// Get Element
final Element rootElement;
if (item instanceof NodeWrapper) {
final Object node = ((NodeWrapper) item).getUnderlyingNode();
rootElement = (Element) node;
} else {
final NodeInfo nodeInfo = (NodeInfo) item;
final Document document = TransformerUtils.tinyTreeToDom4j2(nodeInfo);
rootElement = document.getRootElement();
}
// Convert to Document or DocumentInfo
final Object result =
extractDocument(
xpathContext.getConfiguration(), rootElement, excludeResultPrefixes, readonly);
// Return DocumentInfo
if (result instanceof Document)
return new DocumentWrapper(
(Document) result,
null,
getContainingDocument(xpathContext).getStaticState().getXPathConfiguration());
else return (DocumentInfo) result;
}
public static Object extractDocument(
Configuration configuration,
Element element,
String excludeResultPrefixes,
boolean readonly) {
Object instanceDocument;
final Document tempDocument;
// Extract document and adjust namespaces
// TODO: Implement exactly as per XSLT 2.0
// TODO: Must implement namespace fixup, the code below can break serialization
if ("#all".equals(excludeResultPrefixes)) {
// Special #all
tempDocument = Dom4jUtils.createDocumentCopyElement(element);
} else if (excludeResultPrefixes != null && excludeResultPrefixes.trim().length() != 0) {
// List of prefixes
final StringTokenizer st = new StringTokenizer(excludeResultPrefixes);
final Map<String, String> prefixesToExclude = new HashMap<String, String>();
while (st.hasMoreTokens()) {
prefixesToExclude.put(st.nextToken(), "");
}
tempDocument = Dom4jUtils.createDocumentCopyParentNamespaces(element, prefixesToExclude);
} else {
// No exclusion
tempDocument = Dom4jUtils.createDocumentCopyParentNamespaces(element);
}
// Produce DOM or TinyTree
if (!readonly) {
instanceDocument = tempDocument;
} else {
instanceDocument = TransformerUtils.dom4jToTinyTree(configuration, tempDocument);
}
return instanceDocument;
}
/** Compute a digest for a SAX source. */
public static byte[] getDigest(Source source) {
final DigestContentHandler digester = new DigestContentHandler();
TransformerUtils.sourceToSAX(source, digester);
return digester.getResult();
}
public StaticStateBits(
PipelineContext pipelineContext,
ExternalContext externalContext,
IndentedLogger indentedLogger,
String existingStaticStateDigest) {
final boolean computeDigest = isLogStaticStateInput || existingStaticStateDigest == null;
indentedLogger.startHandleOperation(
"", "reading input", "existing digest", existingStaticStateDigest);
final TransformerXMLReceiver documentReceiver =
TransformerUtils.getIdentityTransformerHandler();
final LocationDocumentResult documentResult = new LocationDocumentResult();
documentReceiver.setResult(documentResult);
final XMLUtils.DigestContentHandler digestReceiver =
computeDigest ? new XMLUtils.DigestContentHandler("MD5") : null;
final XMLReceiver extractorOutput;
if (isLogStaticStateInput) {
extractorOutput =
computeDigest
? new TeeXMLReceiver(
documentReceiver, digestReceiver, getDebugReceiver(indentedLogger))
: new TeeXMLReceiver(documentReceiver, getDebugReceiver(indentedLogger));
} else {
extractorOutput =
computeDigest ? new TeeXMLReceiver(documentReceiver, digestReceiver) : documentReceiver;
}
// Read the input through the annotator and gather namespace mappings
//
// Output of annotator is:
//
// o annotated page template (TODO: this should not include model elements)
// o extractor
//
// Output of extractor is:
//
// o static state document
// o optionally: digest
// o optionally: debug output
//
readInputAsSAX(
pipelineContext,
INPUT_ANNOTATED_DOCUMENT,
new XFormsAnnotatorContentHandler(
annotatedTemplate,
new XFormsExtractorContentHandler(extractorOutput, metadata),
metadata));
this.staticStateDocument = documentResult.getDocument();
this.staticStateDigest =
computeDigest ? NumberUtils.toHexString(digestReceiver.getResult()) : null;
assert !isLogStaticStateInput
|| existingStaticStateDigest == null
|| this.staticStateDigest.equals(existingStaticStateDigest);
indentedLogger.endHandleOperation("computed digest", this.staticStateDigest);
}