/** * Uses a Vector of TransformerHandlers to pipe XML input document through a series of 1 or more * transformations. Called by {@link #pipeDocument}. * * @param vTHandler Vector of Transformation Handlers (1 per stylesheet). * @param source absolute URI to XML input * @param target absolute path to transformation output. */ public void usePipe(Vector vTHandler, String source, String target) throws TransformerException, TransformerConfigurationException, FileNotFoundException, IOException, SAXException, SAXNotRecognizedException { XMLReader reader = XMLReaderFactory.createXMLReader(); TransformerHandler tHFirst = (TransformerHandler) vTHandler.firstElement(); reader.setContentHandler(tHFirst); reader.setProperty("http://xml.org/sax/properties/lexical-handler", tHFirst); for (int i = 1; i < vTHandler.size(); i++) { TransformerHandler tHFrom = (TransformerHandler) vTHandler.elementAt(i - 1); TransformerHandler tHTo = (TransformerHandler) vTHandler.elementAt(i); tHFrom.setResult(new SAXResult(tHTo)); } TransformerHandler tHLast = (TransformerHandler) vTHandler.lastElement(); Transformer trans = tHLast.getTransformer(); Properties outputProps = trans.getOutputProperties(); Serializer serializer = SerializerFactory.getSerializer(outputProps); FileOutputStream out = new FileOutputStream(target); try { serializer.setOutputStream(out); tHLast.setResult(new SAXResult(serializer.asContentHandler())); reader.parse(source); } finally { // Always clean up the FileOutputStream, // even if an exception was thrown in the try block if (out != null) out.close(); } }
public boolean run(Collection<SubversionSCM.External> externals, Result changeLog) throws IOException, InterruptedException { boolean changelogFileCreated = false; final SVNClientManager manager = SubversionSCM.createSvnClientManager(); try { SVNLogClient svnlc = manager.getLogClient(); TransformerHandler th = createTransformerHandler(); th.setResult(changeLog); SVNXMLLogHandler logHandler = new SVNXMLLogHandler(th); // work around for http://svnkit.com/tracker/view.php?id=175 th.setDocumentLocator(DUMMY_LOCATOR); logHandler.startDocument(); for (ModuleLocation l : scm.getLocations(build)) { changelogFileCreated |= buildModule(l.getURL(), svnlc, logHandler); } for (SubversionSCM.External ext : externals) { changelogFileCreated |= buildModule(getUrlForPath(build.getWorkspace().child(ext.path)), svnlc, logHandler); } if (changelogFileCreated) { logHandler.endDocument(); } return changelogFileCreated; } finally { manager.dispose(); } }
/** * Builds a Tika-compatible SAX content handler, which will be used to generate+capture the XHTML */ private ContentHandler buildContentHandler(Writer output, RenderingContext context) { // Create the main transformer SAXTransformerFactory factory = (SAXTransformerFactory) SAXTransformerFactory.newInstance(); TransformerHandler handler; try { handler = factory.newTransformerHandler(); } catch (TransformerConfigurationException e) { throw new RenditionServiceException("SAX Processing isn't available - " + e); } handler.getTransformer().setOutputProperty(OutputKeys.INDENT, "yes"); handler.setResult(new StreamResult(output)); handler.getTransformer().setOutputProperty(OutputKeys.METHOD, "xml"); // Change the image links as they go past String dirName = null, imgPrefix = null; if (context.getParamWithDefault(PARAM_IMAGES_SAME_FOLDER, false)) { imgPrefix = getImagesPrefixName(context); } else { dirName = getImagesDirectoryName(context); } ContentHandler contentHandler = new TikaImageRewritingContentHandler(handler, dirName, imgPrefix); // If required, wrap it to only return the body boolean bodyOnly = context.getParamWithDefault(PARAM_BODY_CONTENTS_ONLY, false); if (bodyOnly) { contentHandler = new BodyContentHandler(contentHandler); } // All done return contentHandler; }
@Override protected void marshalToOutputStream( Marshaller ms, Object obj, OutputStream os, Annotation[] anns, MediaType mt) throws Exception { Templates t = createTemplates(getOutTemplates(anns, mt), outParamsMap, outProperties); if (t == null && supportJaxbOnly) { super.marshalToOutputStream(ms, obj, os, anns, mt); return; } TransformerHandler th = null; try { th = factory.newTransformerHandler(t); } catch (TransformerConfigurationException ex) { TemplatesImpl ti = (TemplatesImpl) t; th = factory.newTransformerHandler(ti.getTemplates()); this.trySettingProperties(th, ti); } Result result = new StreamResult(os); if (systemId != null) { result.setSystemId(systemId); } th.setResult(result); if (getContext() == null) { th.startDocument(); } ms.marshal(obj, th); if (getContext() == null) { th.endDocument(); } }
@Override public ContentHandler getSAXHandler() throws IOException, ServletException { this.handlerUsed = true; // Set the content-type for the output assignContentType(this.getTransformCtx()); TransformerHandler tHandler; try { SAXTransformerFactory saxTFact = (SAXTransformerFactory) TransformerFactory.newInstance(); tHandler = saxTFact.newTransformerHandler(this.getCompiled()); } catch (TransformerConfigurationException ex) { throw new ServletException(ex); } // Populate any params which might have been set if (this.getTransformCtx().getTransformParams() != null) populateParams(tHandler.getTransformer(), this.getTransformCtx().getTransformParams()); if (this.getNext().isLast()) tHandler.setResult(new StreamResult(this.getNext().getResponse().getOutputStream())); else tHandler.setResult(new SAXResult(this.getNext().getSAXHandler())); return tHandler; }
private static void serializeEntry(TransformerHandler hd, Entry entry) throws SAXException { AttributesImpl entryAttributes = new AttributesImpl(); for (Iterator<String> it = entry.getAttributes().iterator(); it.hasNext(); ) { String key = it.next(); entryAttributes.addAttribute("", "", key, "", entry.getAttributes().getValue(key)); } hd.startElement("", "", ENTRY_ELEMENT, entryAttributes); StringList tokens = entry.getTokens(); for (Iterator<String> it = tokens.iterator(); it.hasNext(); ) { hd.startElement("", "", TOKEN_ELEMENT, new AttributesImpl()); String token = it.next(); hd.characters(token.toCharArray(), 0, token.length()); hd.endElement("", "", TOKEN_ELEMENT); } hd.endElement("", "", ENTRY_ELEMENT); }
/** * Creates a new generator. * * @param providers the list of page providers to use. * @param dest the destination directory. * @param url the public url corresponding to the the destination directory. * @throws IOException if the files could not be written. */ public SitemapGenerator(final Collection<PageProvider> providers, final File dest, final URI url) throws IOException { LOG.info("Initializing..."); this.uri = url; this.providers = providers; this.location = dest; this.writer = new FileWriter(new File(location, "sitemap_index.xml")); final StreamResult streamResult = new StreamResult(writer); try { tf.setAttribute("indent-number", 2); this.transformerHandler = tf.newTransformerHandler(); final Transformer serializer = transformerHandler.getTransformer(); serializer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); // serializer.setOutputProperty(OutputKeys.METHOD, "xml"); serializer.setOutputProperty(OutputKeys.INDENT, "yes"); transformerHandler.setResult(streamResult); } catch (TransformerConfigurationException e) { throw new RuntimeException(e); } }
@Override public void run(@NotNull ProgressIndicator indicator) { try { SAXTransformerFactory transformerFactory = (SAXTransformerFactory) TransformerFactory.newInstance(); TransformerHandler handler = transformerFactory.newTransformerHandler(); handler.getTransformer().setOutputProperty(OutputKeys.INDENT, "yes"); handler .getTransformer() .setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4"); final String configurationNameIncludedDate = PathUtil.suggestFileName(myConfiguration.getName()) + " - " + new SimpleDateFormat(HISTORY_DATE_FORMAT).format(new Date()); myOutputFile = new File( AbstractImportTestsAction.getTestHistoryRoot(myProject), configurationNameIncludedDate + ".xml"); FileUtilRt.createParentDirs(myOutputFile); handler.setResult(new StreamResult(new FileWriter(myOutputFile))); final SMTestProxy.SMRootTestProxy root = myRoot; final RunConfiguration configuration = myConfiguration; if (root != null && configuration != null) { TestResultsXmlFormatter.execute(root, configuration, myConsoleProperties, handler); } } catch (ProcessCanceledException e) { throw e; } catch (Exception e) { LOG.info("Export to history failed", e); } }
/** {@inheritDoc} */ @Override public void write(ProjectFile projectFile, OutputStream stream) throws IOException { try { if (CONTEXT == null) { throw CONTEXT_EXCEPTION; } // // The Primavera schema defines elements as nillable, which by // default results in // JAXB generating elements like this <element xsl:nil="true"/> // whereas Primavera itself simply omits these elements. // // The XSLT stylesheet below transforms the XML generated by JAXB on // the fly to remove any nil elements. // TransformerFactory transFact = TransformerFactory.newInstance(); TransformerHandler handler = ((SAXTransformerFactory) transFact) .newTransformerHandler( new StreamSource(new ByteArrayInputStream(NILLABLE_STYLESHEET.getBytes()))); handler.setResult(new StreamResult(stream)); Transformer transformer = handler.getTransformer(); transformer.setOutputProperty(OutputKeys.INDENT, "yes"); transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2"); m_projectFile = projectFile; m_calendar = Calendar.getInstance(); Marshaller marshaller = CONTEXT.createMarshaller(); marshaller.setProperty(Marshaller.JAXB_SCHEMA_LOCATION, ""); m_factory = new ObjectFactory(); m_apibo = m_factory.createAPIBusinessObjects(); writeProjectProperties(); writeCalendars(); writeResources(); writeTasks(); writeAssignments(); DatatypeConverter.setParentFile(m_projectFile); marshaller.marshal(m_apibo, handler); } catch (JAXBException ex) { throw new IOException(ex.toString()); } catch (TransformerConfigurationException ex) { throw new IOException(ex.toString()); } finally { m_projectFile = null; m_factory = null; m_apibo = null; m_project = null; m_wbsSequence = 0; m_relationshipObjectID = 0; m_calendar = null; } }
public void create(Properties ctx, TransformerHandler document) throws SAXException { int AD_Column_ID = Env.getContextAsInt(ctx, X_AD_Column.COLUMNNAME_AD_Column_ID); AttributesImpl atts = new AttributesImpl(); X_AD_Column m_Column = new X_AD_Column(ctx, AD_Column_ID, getTrxName(ctx)); createColumnBinding(atts, m_Column); document.startElement("", "", "column", atts); document.endElement("", "", "column"); }
public void create(Properties ctx, TransformerHandler document) throws SAXException { int AD_Ref_List_ID = Env.getContextAsInt(ctx, X_AD_Ref_List.COLUMNNAME_AD_Ref_List_ID); X_AD_Ref_List m_Ref_List = new X_AD_Ref_List(ctx, AD_Ref_List_ID, getTrxName(ctx)); AttributesImpl atts = new AttributesImpl(); createRefListBinding(atts, m_Ref_List); document.startElement("", "", "referencelist", atts); document.endElement("", "", "referencelist"); }
public void create(Properties ctx, TransformerHandler document) throws SAXException { int AD_Workflow_ID = Env.getContextAsInt(ctx, X_AD_Workflow.COLUMNNAME_AD_Workflow_ID); int AD_Role_ID = Env.getContextAsInt(ctx, X_AD_Role.COLUMNNAME_AD_Role_ID); AttributesImpl atts = new AttributesImpl(); createWorkflowAccessBinding(atts, AD_Workflow_ID, AD_Role_ID); document.startElement("", "", "workflowaccess", atts); document.endElement("", "", "workflowaccess"); }
public final ContentHandler createContentHandler() { try { TransformerHandler handler = saxtf.newTransformerHandler(templates); handler.setResult(new SAXResult(outputHandler)); return handler; } catch (TransformerConfigurationException ex) { throw new RuntimeException(ex.toString()); } }
@Override public void create(Properties ctx, TransformerHandler document) throws SAXException { String SQLStatement = Env.getContext(ctx, X_AD_Package_Exp_Detail.COLUMNNAME_SQLStatement); String DBType = Env.getContext(ctx, X_AD_Package_Exp_Detail.COLUMNNAME_DBType); AttributesImpl atts = new AttributesImpl(); createSQLStatmentBinding(atts, SQLStatement, DBType); document.startElement("", "", "SQLStatement", atts); document.endElement("", "", "SQLStatement"); }
/** * Writes the root start tag to the result. * * @throws SAXException */ protected void writeStartDocument() { try { AttributesImpl atts = new AttributesImpl(); handler.startDocument(); handler.startElement(Constants.MARCXML_NS_URI, COLLECTION, COLLECTION, atts); } catch (SAXException e) { throw new MarcException("SAX error occured while writing start document", e); } }
// TransformerHandler public void setResult(Result result) throws IllegalArgumentException { Check.notNull(result); if (result instanceof SAXResult) { setTarget((SAXResult) result); } else { TransformerHandler th = saxHelper.newIdentityTransformerHandler(); th.setResult(result); setTarget(new SAXResult(th)); } }
private void addElement(final String element, final String string) throws SAXException { final AttributesImpl noAttributes = new AttributesImpl(); transformerHandler.startElement("", "", element, noAttributes); if (string != null) { transformerHandler.characters(string.toCharArray(), 0, string.length()); } transformerHandler.endElement("", "", element); }
public void create(Properties ctx, TransformerHandler document) throws SAXException { int AD_Form_ID = Env.getContextAsInt(ctx, "AD_Form_ID"); if (forms.contains(AD_Form_ID)) return; forms.add(AD_Form_ID); X_AD_Form m_Form = new X_AD_Form(ctx, AD_Form_ID, null); AttributesImpl atts = new AttributesImpl(); createFormBinding(atts, m_Form); document.startElement("", "", "form", atts); document.endElement("", "", "form"); }
/** * Writes the root end tag to the result. * * @throws SAXException */ protected void writeEndDocument() { try { if (indent) handler.ignorableWhitespace("\n".toCharArray(), 0, 1); handler.endElement(Constants.MARCXML_NS_URI, COLLECTION, COLLECTION); handler.endPrefixMapping(""); handler.endDocument(); } catch (SAXException e) { throw new MarcException("SAX error occured while writing end document", e); } }
void generateSuccessNode(int searchNodeId) { try { AttributesImpl atts = new AttributesImpl(); atts.addAttribute("", "", "id", "CDATA", "" + searchNodeId); hdTree.startElement("", "", "succ", atts); hdTree.endElement("", "", "succ"); } catch (SAXException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
public void finish() throws IOException { if (!finished) { try { transformerHandler.endElement(NS, "", "urlset"); transformerHandler.endDocument(); this.writer.close(); finished = true; } catch (SAXException e) { throw new RuntimeException(e); } } }
/** * Returns a transformer handler that serializes incoming SAX events to XHTML or HTML (depending * the given method) using the given output encoding. * * @see <a href="https://issues.apache.org/jira/browse/TIKA-277">TIKA-277</a> * @param output output stream * @param method "xml" or "html" * @param encoding output encoding, or <code>null</code> for the platform default * @return {@link System#out} transformer handler * @throws TransformerConfigurationException if the transformer can not be created */ private static TransformerHandler getTransformerHandler( OutputStream output, String method, String encoding, boolean prettyPrint) throws TransformerConfigurationException { SAXTransformerFactory factory = (SAXTransformerFactory) SAXTransformerFactory.newInstance(); TransformerHandler handler = factory.newTransformerHandler(); handler.getTransformer().setOutputProperty(OutputKeys.METHOD, method); handler.getTransformer().setOutputProperty(OutputKeys.INDENT, prettyPrint ? "yes" : "no"); if (encoding != null) { handler.getTransformer().setOutputProperty(OutputKeys.ENCODING, encoding); } handler.setResult(new StreamResult(output)); return handler; }
/** * Return a new {@link TransformerHandler} based on a given precompiled {@link Templates}. The * handler {@link Transformer}'s {@link ErrorListener} is set to {@link TransformerErrorListener} * to raise exceptions and give proper warnings. */ public TransformerHandler newTransformerHandler(Templates template) throws TransformerConfigurationException { final TransformerHandler handler = this.tFactory.newTransformerHandler(template); /* * We want to raise transformer exceptions on <xml:message terminate="true">, so * we add a custom listener. Also, various XSLT processors react in different ways * to transformation errors -- some of them report error as recoverable, some of * them report error as unrecoverable. */ handler.getTransformer().setErrorListener(new TransformerErrorListener()); return handler; }
public void executedAtExit(Store store, int solutionsNo) { try { hdTree.endElement("", "", "tree"); hdTree.endDocument(); hdVis.endElement("", "", "visualization"); hdVis.endDocument(); } catch (SAXException e) { e.printStackTrace(); } }
void generateTrycNode(int searchNodeId, int parentNode, PrimitiveConstraint c) { try { AttributesImpl atts = new AttributesImpl(); atts.addAttribute("", "", "id", "CDATA", "" + searchNodeId); atts.addAttribute("", "", "parent", "CDATA", "" + parentNode); atts.addAttribute("", "", "choice", "CDATA", c.toString()); hdTree.startElement("", "", "tryc", atts); hdTree.endElement("", "", "tryc"); } catch (SAXException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
protected void prepareHTMLView(InputStream older, InputStream newer) throws Exception { InputSource oldSource = new InputSource(older); InputSource newSource = new InputSource(newer); HtmlCleaner cleaner = new HtmlCleaner(); Locale locale = Locale.getDefault(); String prefix = "diff"; DomTreeBuilder oldHandler; DomTreeBuilder newHandler; try { oldHandler = new DomTreeBuilder(); cleaner.cleanAndParse(oldSource, oldHandler); newHandler = new DomTreeBuilder(); cleaner.cleanAndParse(newSource, newHandler); } catch (Exception e) { throw new UsecaseException("Error while parsing document for diffing: ", e); } TextNodeComparator leftComparator = new TextNodeComparator(oldHandler, locale); TextNodeComparator rightComparator = new TextNodeComparator(newHandler, locale); SAXTransformerFactory tf = (SAXTransformerFactory) TransformerFactory.newInstance(); TransformerHandler result = tf.newTransformerHandler(); ByteArrayOutputStream out = new ByteArrayOutputStream(); Result domResult = new StreamResult(out); result.setResult(domResult); ContentHandler htmlDiff = result; // Document content filtering // XslFilter filter = new XslFilter(); // ContentHandler postProcess = filter.xsl(result, "htmldiff.xsl"); try { startDiffDocument(htmlDiff); SimpleDiffOutput output = new SimpleDiffOutput(htmlDiff, prefix); BodyNode diffNode = HTMLDiffer.diff(leftComparator, rightComparator); output.toHTML(diffNode); finishDiffDocument(htmlDiff); setParameter( "html-output", DocumentBuilderFactory.newInstance() .newDocumentBuilder() .parse(new ByteArrayInputStream(out.toByteArray()))); } catch (Exception e) { throw new UsecaseException("Failed translating diff document to xml: ", e); } }
/** * Returns a transformer handler that serializes incoming SAX events to XHTML or HTML (depending * the given method) using the given output encoding. * * @param encoding output encoding, or <code>null</code> for the platform default */ private static TransformerHandler getTransformerHandler( OutputStream out, String method, String encoding) throws TransformerConfigurationException { TransformerHandler transformerHandler = SAX_TRANSFORMER_FACTORY.newTransformerHandler(); Transformer transformer = transformerHandler.getTransformer(); transformer.setOutputProperty(OutputKeys.METHOD, method); transformer.setOutputProperty(OutputKeys.INDENT, "yes"); if (encoding != null) { transformer.setOutputProperty(OutputKeys.ENCODING, encoding); } transformerHandler.setResult(new StreamResult(new PrintStream(out))); return transformerHandler; }
public State(UnmarshallingContext context) throws SAXException { result = dom.createUnmarshaller(context); handler.setResult(result); // emulate the start of documents try { handler.setDocumentLocator(context.getLocator()); handler.startDocument(); declarePrefixes(context, context.getAllDeclaredPrefixes()); } catch (SAXException e) { context.handleError(e); throw e; } }
protected void setHandler(Result result, Source stylesheet) throws MarcException { try { TransformerFactory factory = TransformerFactory.newInstance(); if (!factory.getFeature(SAXTransformerFactory.FEATURE)) throw new UnsupportedOperationException("SAXTransformerFactory is not supported"); SAXTransformerFactory saxFactory = (SAXTransformerFactory) factory; if (stylesheet == null) handler = saxFactory.newTransformerHandler(); else handler = saxFactory.newTransformerHandler(stylesheet); handler.getTransformer().setOutputProperty(OutputKeys.METHOD, "xml"); handler.setResult(result); } catch (Exception e) { throw new MarcException(e.getMessage(), e); } }
void generateFailNode(int searchNodeId, int parentNode, String name, int size, int value) { try { AttributesImpl atts = new AttributesImpl(); atts.addAttribute("", "", "id", "CDATA", "" + searchNodeId); atts.addAttribute("", "", "parent", "CDATA", "" + parentNode); atts.addAttribute("", "", "name", "CDATA", name); atts.addAttribute("", "", "size", "CDATA", "" + size); atts.addAttribute("", "", "value", "CDATA", "" + value); hdTree.startElement("", "", "fail", atts); hdTree.endElement("", "", "fail"); } catch (SAXException e) { // TODO Auto-generated catch block e.printStackTrace(); } }