public static <T> XMLFilter getXMLFilterForClass(final Class<T> clazz) throws SAXException { final XMLFilter filter; final XmlSchema schema = clazz.getPackage().getAnnotation(XmlSchema.class); if (schema != null) { final String namespace = schema.namespace(); if (namespace != null && !"".equals(namespace)) { LogUtils.tracef(clazz, "found namespace %s for class %s", namespace, clazz); filter = new SimpleNamespaceFilter(namespace, true); } else { filter = new SimpleNamespaceFilter("", false); } } else { filter = new SimpleNamespaceFilter("", false); } final XMLReader xmlReader = XMLReaderFactory.createXMLReader(); filter.setParent(xmlReader); return filter; }
/** * javax.xml.transform.sax.SAXTransformerFactory implementation. * Create an XMLFilter that uses the given source as the * transformation instructions. * * @param templates The source of the transformation instructions. * @return An XMLFilter object, or null if this feature is not supported. * @throws TransformerConfigurationException */ @Override public XMLFilter newXMLFilter(Templates templates) throws TransformerConfigurationException { try { return new com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter(templates); } catch (TransformerConfigurationException e1) { if (_errorListener != null) { try { _errorListener.fatalError(e1); return null; } catch (TransformerException e2) { new TransformerConfigurationException(e2); } } throw e1; } }
/** * Create an XMLFilter that uses the given source as the * transformation instructions. Uses * com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactory. */ public XMLFilter newXMLFilter(Source src) throws TransformerConfigurationException { if (_xsltcFactory == null) { createXSLTCTransformerFactory(); } if (_errorlistener != null) { _xsltcFactory.setErrorListener(_errorlistener); } if (_uriresolver != null) { _xsltcFactory.setURIResolver(_uriresolver); } Templates templates = _xsltcFactory.newTemplates(src); if (templates == null ) return null; return newXMLFilter(templates); }
public XMLFilter newXMLFilter(Templates templates) throws TransformerConfigurationException { try { return new com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter(templates); } catch(TransformerConfigurationException e1) { if (_xsltcFactory == null) { createXSLTCTransformerFactory(); } ErrorListener errorListener = _xsltcFactory.getErrorListener(); if(errorListener != null) { try { errorListener.fatalError(e1); return null; } catch( TransformerException e2) { new TransformerConfigurationException(e2); } } throw e1; } }
/** * Unit test for contentHandler setter/getter along reader as handler's * parent. * * @throws Exception If any errors occur. */ @Test public void testcase10() throws Exception { String outputFile = USER_DIR + "saxtf010.out"; String goldFile = GOLDEN_DIR + "saxtf010GF.out"; // The transformer will use a SAX parser as it's reader. XMLReader reader = XMLReaderFactory.createXMLReader(); SAXTransformerFactory saxTFactory = (SAXTransformerFactory)TransformerFactory.newInstance(); XMLFilter filter = saxTFactory.newXMLFilter(new StreamSource(XSLT_FILE)); filter.setParent(reader); filter.setContentHandler(new MyContentHandler(outputFile)); // Now, when you call transformer.parse, it will set itself as // the content handler for the parser object (it's "parent"), and // will then call the parse method on the parser. filter.parse(new InputSource(XML_FILE)); assertTrue(compareWithGold(goldFile, outputFile)); }
/** * Unit test for contentHandler setter/getter. * * @throws Exception If any errors occur. */ @Test public void testcase12() throws Exception { String outputFile = USER_DIR + "saxtf012.out"; String goldFile = GOLDEN_DIR + "saxtf012GF.out"; // The transformer will use a SAX parser as it's reader. XMLReader reader = XMLReaderFactory.createXMLReader(); InputSource is = new InputSource(new FileInputStream(XSLT_FILE)); SAXSource saxSource = new SAXSource(); saxSource.setInputSource(is); SAXTransformerFactory saxTFactory = (SAXTransformerFactory)TransformerFactory.newInstance(); XMLFilter filter = saxTFactory.newXMLFilter(saxSource); filter.setParent(reader); filter.setContentHandler(new MyContentHandler(outputFile)); // Now, when you call transformer.parse, it will set itself as // the content handler for the parser object (it's "parent"), and // will then call the parse method on the parser. filter.parse(new InputSource(XML_FILE)); assertTrue(compareWithGold(goldFile, outputFile)); }
/** * Unit test for TemplatesHandler setter/getter. * * @throws Exception If any errors occur. */ @Test public void testcase13() throws Exception { String outputFile = USER_DIR + "saxtf013.out"; String goldFile = GOLDEN_DIR + "saxtf013GF.out"; try(FileInputStream fis = new FileInputStream(XML_FILE)) { // The transformer will use a SAX parser as it's reader. XMLReader reader = XMLReaderFactory.createXMLReader(); SAXTransformerFactory saxTFactory = (SAXTransformerFactory) TransformerFactory.newInstance(); TemplatesHandler thandler = saxTFactory.newTemplatesHandler(); // I have put this as it was complaining about systemid thandler.setSystemId("file:///" + USER_DIR); reader.setContentHandler(thandler); reader.parse(XSLT_FILE); XMLFilter filter = saxTFactory.newXMLFilter(thandler.getTemplates()); filter.setParent(reader); filter.setContentHandler(new MyContentHandler(outputFile)); filter.parse(new InputSource(fis)); } assertTrue(compareWithGold(goldFile, outputFile)); }
/** * Returns the SAX XML filter applying the transform sheet to its input. * * @return The SAX XML filter. * @throws IOException */ public XMLFilter getXmlFilter() throws IOException { XMLFilter result = null; final Templates templates = getTemplates(); if (templates != null) { try { result = getSaxTransformerFactory().newXMLFilter(templates); } catch (TransformerConfigurationException tce) { throw new IOException("Transformer configuration exception. " + tce.getMessage()); } } return result; }
/** * Creates an <code>XMLFilter</code> that uses the given <code>Source</code> * as the transformation instructions. Implementation of the * {@link SAXTransformerFactory} * * @param src * - The Source of the transformation instructions. * @return An {@link XMLFilter} object, or <code>null</code> if this feature * is not supported. * @throws TransformerConfigurationException */ @Override public XMLFilter newXMLFilter (final Source src) throws TransformerConfigurationException { if (CSTX.DEBUG) if (log.isDebugEnabled ()) log.debug ("getting SAXTransformerFactory.FEATURE_XMLFILTER " + "from Source " + src.getSystemId ()); XMLFilter xFilter = null; try { final Templates templates = newTemplates (src); // get a XMLReader final XMLReader parser = Processor.createXMLReader (); xFilter = newXMLFilter (templates); xFilter.setParent (parser); return xFilter; } catch (final SAXException ex) { final TransformerConfigurationException tE = new TransformerConfigurationException (ex.getMessage (), ex); m_aDefaultErrorListener.fatalError (tE); return null; } }
protected org.kuali.rice.core.impl.config.property.Config unmarshal(Unmarshaller unmarshaller, InputStream in) throws SAXException, ParserConfigurationException, IOException, IllegalStateException, JAXBException { SAXParserFactory spf = SAXParserFactory.newInstance(); spf.setNamespaceAware(true); XMLFilter filter = new ConfigNamespaceURIFilter(); filter.setParent(spf.newSAXParser().getXMLReader()); UnmarshallerHandler handler = unmarshaller.getUnmarshallerHandler(); filter.setContentHandler(handler); filter.parse(new InputSource(in)); return (org.kuali.rice.core.impl.config.property.Config) handler.getResult(); }
@Override public XMLFilter getXMLFilter(ArgFactory arf, InputCommandFactory.InputCommand inputBase, CommandType maxType) { this.inputBase = inputBase; if (!init(parser.parse(arf.getArgs(parser.recognizedOptions().keySet())))) { return null; } CommandFactory.conditionalInit(first, inputBase, EXPECT_INPUT); JoiningXMLFilter joiner = new JoiningXMLFilter(!joinAll); if (first && inputBase.filesFrom != null) { joiner.setInputType(QueueSourceXMLFilter.InputType.indirect); if (inputBase.delim != null) { joiner.setDelimiterPattern(Pattern.compile(inputBase.delim, Pattern.LITERAL)); } } return joiner; }
@Override public XMLFilter getXMLFilter(ArgFactory arf, InitCommand inputBase, CommandType maxType) { String[] args = arf.getArgs(Collections.EMPTY_SET); if (args.length != 1) { throw new IllegalArgumentException("Command \"" + getKey() + "\" should have only one argument: dumpfile"); } this.inputBase = inputBase; File df = new File(args[0]); DumpingXMLFilter dxf = new DumpingXMLFilter(); String path = df.getPath(); if ("-".equals(path)) { dxf.setDumpStream(System.out); } else if ("-h".equals(path) || "--help".equals(path)) { return null; } else { dxf.setDumpFile(df); } return dxf; }
@Override public XMLFilter getXMLFilter(ArgFactory arf, InputCommandFactory.InputCommand inputBase, CommandType maxType) { if (txf != null) { return txf; } if (!init(parser.parse(arf.getArgs(parser.recognizedOptions().keySet())), inputBase)) { return null; } CommandFactory.conditionalInit(first, inputBase, EXPECT_INPUT); try { txf = new TXMLFilter(new StreamSource(xsl), recordIdXPath, subdivide, recordDepth); } catch (TransformerConfigurationException ex) { throw new RuntimeException(ex); } if (first && inputBase.filesFrom != null) { txf.setInputType(QueueSourceXMLFilter.InputType.indirect); if (inputBase.delim != null) { txf.setDelimiterPattern(Pattern.compile(inputBase.delim, Pattern.LITERAL)); } } return txf; }
@Override public XMLFilter getXMLFilter(ArgFactory arf, InputCommandFactory.InputCommand inputBase, CommandType maxType) { if (ret != null) { return ret; } this.inputBase = inputBase; if (!init(parser.parse(parseMainOut(arf.getArgs(parser.recognizedOptions().keySet()))), inputBase)) { return null; } if (first || !last) { throw new IllegalArgumentException(KEY + " command must be last, and must not be first"); } String inBaseSystemId = inputBase.input.getSystemId(); File inBaseFile = inBaseSystemId == null ? null : new File(inBaseSystemId); ret = new OutputXMLFilter(inBaseFile, output, baseName, suffixLength, outputExtension, noIndent, gzipOutput); return ret; }
@Override public XMLFilter getXMLFilter(ArgFactory arf, InputCommandFactory.InputCommand inputBase, CommandType maxType) { if (!init(parser.parse(arf.getArgs(parser.recognizedOptions().keySet())), inputBase)) { return null; } CommandFactory.conditionalInit(first, inputBase, EXPECT_INPUT); SAXSolrPoster ssp = new SAXSolrPoster(); ssp.setServer(new ConcurrentUpdateSolrServer(solrURL, queueSize, threadCount)); if (first && inputBase.getFilesFrom() != null) { ssp.setInputType(QueueSourceXMLFilter.InputType.indirect); if (inputBase.getDelim() != null) { ssp.setDelimiterPattern(Pattern.compile(inputBase.getDelim(), Pattern.LITERAL)); } } return ssp; }
private void createXMLReader(XMLReader paramXMLReader) { if (paramXMLReader == null) { this.xmlReader = new SaxWriter(); } else if ((paramXMLReader instanceof XMLFilter)) { for (XMLFilter localXMLFilter = (XMLFilter)paramXMLReader; (localXMLFilter.getParent() instanceof XMLFilter); localXMLFilter = (XMLFilter)localXMLFilter.getParent()); if (!(localXMLFilter.getParent() instanceof SaxWriter)) localXMLFilter.setParent(new SaxWriter()); this.xmlReader = paramXMLReader; } else { throw new UnsupportedOperationException(); } configureXMLReader(); }
/** * javax.xml.transform.sax.SAXTransformerFactory implementation. * Create an XMLFilter that uses the given source as the * transformation instructions. * * @param templates The source of the transformation instructions. * @return An XMLFilter object, or null if this feature is not supported. * @throws TransformerConfigurationException */ public XMLFilter newXMLFilter(Templates templates) throws TransformerConfigurationException { try { return new com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter(templates); } catch (TransformerConfigurationException e1) { if (_errorListener != null) { try { _errorListener.fatalError(e1); return null; } catch (TransformerException e2) { new TransformerConfigurationException(e2); } } throw e1; } }
public static <T> XMLFilter getXMLFilterForClass(final Class<T> clazz) throws SAXException { final XMLFilter filter; final XmlSchema schema = clazz.getPackage().getAnnotation(XmlSchema.class); if (schema != null) { final String namespace = schema.namespace(); if (namespace != null && !"".equals(namespace)) { LogUtils.debugf(clazz, "found namespace %s for class %s", namespace, clazz); filter = new SimpleNamespaceFilter(namespace, true); } else { filter = new SimpleNamespaceFilter("", false); } } else { filter = new SimpleNamespaceFilter("", false); } final XMLReader xmlReader = XMLReaderFactory.createXMLReader(); filter.setParent(xmlReader); return filter; }
@Test public void validateJaxbXmlAgainstSchema() throws Exception { LogUtils.debugf(this, "Validating against XSD: %s", m_schemaFile); javax.xml.bind.Unmarshaller unmarshaller = JaxbUtils.getUnmarshallerFor(getSampleClass(), null, true); final SchemaFactory factory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema"); final Schema schema = factory.newSchema(new StreamSource(m_schemaFile)); unmarshaller.setSchema(schema); unmarshaller.setEventHandler(new ValidationEventHandler() { @Override public boolean handleEvent(final ValidationEvent event) { LogUtils.debugf(this, event.getLinkedException(), "Received validation event: %s", event); return false; } }); try { final InputSource inputSource = new InputSource(new ByteArrayInputStream(m_sampleXml.getBytes())); final XMLFilter filter = JaxbUtils.getXMLFilterForClass(getSampleClass()); final SAXSource source = new SAXSource(filter, inputSource); @SuppressWarnings("unchecked") T obj = (T)unmarshaller.unmarshal(source); assertNotNull(obj); } finally { unmarshaller.setSchema(null); } }
@SuppressWarnings("unchecked") @Override public T readFrom(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws WebApplicationException { try { Unmarshaller unmarshaller = JAXBContext.newInstance(type).createUnmarshaller(); String declaredNamespaceForType = getDeclaredNamespaceForType(type); XMLFilter filter = createXmlFilter(unmarshaller, declaredNamespaceForType); return (T) (unmarshaller.unmarshal(asSource(entityStream, filter))); } catch (JAXBException e) { throw new BadRequestException(e); } }
private XMLFilter createXmlFilter(Unmarshaller unmarshaller, String namespaceToSet) throws JAXBException { try { XMLFilter filter = new XmlNamespaceInjectionFilter(createXmlReader(), namespaceToSet); filter.setContentHandler(unmarshaller.getUnmarshallerHandler()); return filter; } catch (SAXException | ParserConfigurationException e) { throw new JAXBException(e); } }
/** * Parses a RELAX NG grammar into an annotated grammar. */ private Model loadRELAXNG() throws SAXException { // build DOM forest final DOMForest forest = buildDOMForest( new RELAXNGInternalizationLogic() ); // use JAXP masquerading to validate the input document. // DOMForest -> ExtensionBindingChecker -> RNGOM XMLReaderCreator xrc = new XMLReaderCreator() { public XMLReader createXMLReader() { // foreset parser cannot change the receivers while it's working, // so we need to have one XMLFilter that works as a buffer XMLFilter buffer = new XMLFilterImpl() { @Override public void parse(InputSource source) throws IOException, SAXException { forest.createParser().parse( source, this, this, this ); } }; XMLFilter f = new ExtensionBindingChecker(Const.RELAXNG_URI,opt,errorReceiver); f.setParent(buffer); f.setEntityResolver(opt.entityResolver); return f; } }; Parseable p = new SAXParseable( opt.getGrammars()[0], errorReceiver, xrc ); return loadRELAXNG(p); }
