@Override public void writeAttribute(String namespaceURI, String localName, String value) throws XMLStreamException { this.eventWriter.add(this.eventFactory.createAttribute(new QName(namespaceURI, localName), value)); }
@Override public void close() throws XMLStreamException { wrappedEventWriter.close(); }
XMLEventFactory eventFactory = XMLEventFactory.newInstance(); XMLEvent dtd = eventFactory .createDTD("<!DOCTYPE Employee SYSTEM \"xmlValidate.dtd\">"); XMLInputFactory inFactory = XMLInputFactory.newInstance(); XMLOutputFactory outFactory = XMLOutputFactory.newInstance(); XMLEventReader reader = inFactory .createXMLEventReader(new StreamSource( "xmlValidate.xml")); reader = new DTDReplacer(reader, dtd); XMLEventWriter writer = outFactory.createXMLEventWriter(System.out); writer.add(reader); writer.flush(); // TODO error and proper stream handling
public void endDocument(boolean fragment) throws IOException, SAXException, XMLStreamException { if(!fragment) { out.add(ef.createEndDocument()); out.flush(); } super.endDocument(fragment); }
/** Write a new element with the specified name and text * @return the end element */ private XMLEvent getAddedEvent(XMLEvent event, XMLEventWriter writer, String elementName, String text) throws XMLStreamException { StartElement oldStartEvent = event.asStartElement(); StartElement newStartEvent = xmlEventFactory.createStartElement(new QName(elementName), null, oldStartEvent.getNamespaces()); writer.add(newStartEvent); writer.add(xmlEventFactory.createCharacters(text)); return xmlEventFactory.createEndElement(newStartEvent.getName(), newStartEvent.getNamespaces()); }
XMLEventFactory events = XMLEventFactory.newInstance(); QName bar = new QName("urn:bar", "bar"); XMLOutputFactory factory = XMLOutputFactory.newInstance(); factory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, true); XMLEventWriter writer = factory.createXMLEventWriter(System.out); writer.add(events.createStartDocument()); writer.setDefaultNamespace("urn:bar"); writer.add(events.createStartElement(bar, null, null)); writer.add(events.createEndDocument()); writer.flush();
/** * Removes the first encountered paragraph from a fragment of xhtml if it is the first tag. * * @param xml xml * @return stripped xml * @throws XMLStreamException ex */ public String stripFirstParagraph(String xml) throws XMLStreamException { StringWriter outputWriter = new StringWriter(); XMLEventWriter eventWriter = xmlOutputFactory.createXMLEventWriter(outputWriter); XMLEventReader eventReader = xmlEventReaderFactory.createStorageXmlEventReader(new StringReader(xml)); if (!eventReader.hasNext()) return xml; if (!eventReader.peek().isStartElement() || !"p".equals(eventReader.peek().asStartElement().getName().getLocalPart())) return xml; XMLEventReader bodyEventReader = xmlEventReaderFactory.createXmlFragmentBodyEventReader(eventReader); try { eventWriter.add(bodyEventReader); } finally { bodyEventReader.close(); } eventWriter.add(eventReader); eventWriter.flush(); return outputWriter.toString(); }
public void writeEndElement() throws XMLStreamException { if (depth <= 0) { // erroneous // Let this.out throw the exception: out.add(factory.createEndElement(new QName("unknown"), null)); } else { out.add(stack[depth - 1]); // If that succeeded: --depth; stack[depth] = null; // to enable garbage collection } }
XMLEventFactory EVT_FACTORY; XMLEventReader reader; XMLEventWriter writer; QName numberQName = new QName("number"); QName factorsQName = new QName("factors"); while(reader.hasNext()) { XMLEvent e = reader.nextEvent(); if(e.isAttribute() && ((Attribute)e).getName().equals(numberQName)) { String v = ((Attribute)e).getValue(); String factors = factorize(Integer.parseInt(v)); XMLEvent factorsAttr = EVT_FACTORY.createAttribute(factorsQName, factors); writer.add(factorsAttr); } // pass through writers.add(e); }
/** * Skip over the current element. * @param name the name of the current element. */ private void skipElement (String name) throws XMLStreamException { while ( reader.hasNext() ) { XMLEvent event = reader.nextEvent(); if ( writer != null ) { writer.add(event); } switch ( event.getEventType() ) { case XMLEvent.END_ELEMENT: if ( name.equals(event.asEndElement().getName().getLocalPart()) ) { return; } } } }
@Override public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { try { // writes the start of element xmlEventWriter.add(eventFactory.createStartElement(new QName(qName), new AttributeIterator(attributes), new NamespaceIterator(namespacesStack))); } catch (XMLStreamException e) { convertToSAXException("Error occurred when writing element start.", e); } }
XMLInputFactory inFactory = XMLInputFactory.newInstance(); XMLEventReader eventReader = inFactory.createXMLEventReader(new FileInputStream("1.xml")); XMLOutputFactory factory = XMLOutputFactory.newInstance(); XMLEventWriter writer = factory.createXMLEventWriter(new FileWriter(file)); XMLEventFactory eventFactory = XMLEventFactory.newInstance(); while (eventReader.hasNext()) { XMLEvent event = eventReader.nextEvent(); writer.add(event); if (event.getEventType() == XMLEvent.START_ELEMENT) { if (event.asStartElement().getName().toString().equalsIgnoreCase("book")) { writer.add(eventFactory.createStartElement("", null, "index")); writer.add(eventFactory.createEndElement("", null, "index")); } } } writer.close();
XMLEventWriter eventWriter; XMLEventFactory eventFactory; XMLOutputFactory outputFactory = XMLOutputFactory.newInstance(); XMLInputFactory inputFactory = XMLInputFactory.newInstance(); eventWriter = outputFactory.createXMLEventWriter(new FileOutputStream("testMerge1.xml")); eventFactory = XMLEventFactory.newInstance(); XMLEvent newLine = eventFactory.createDTD("\n"); // Create and write Start Tag StartDocument startDocument = eventFactory.createStartDocument(); eventWriter.add(startDocument); eventWriter.add(newLine); StartElement configStartElement = eventFactory.createStartElement("","","TestCaseBlock"); eventWriter.add(configStartElement); eventWriter.add(newLine); String[] filenames = new String[]{"test1.xml", "test2.xml","test3.xml"}; for(String filename:filenames){ XMLEventReader test = inputFactory.createXMLEventReader(filename, new FileInputStream(filename)); while(test.hasNext()){ XMLEvent event= test.nextEvent(); //avoiding start(<?xml version="1.0"?>) and end of the documents; if (event.getEventType()!= XMLEvent.START_DOCUMENT && event.getEventType() != XMLEvent.END_DOCUMENT) eventWriter.add(event); eventWriter.add(newLine); test.close(); } eventWriter.add(eventFactory.createEndElement("", "", "TestCaseBlock")); eventWriter.add(newLine); eventWriter.add(eventFactory.createEndDocument()); eventWriter.close();
public Document parse(InputStream input) throws IOException { try { XMLStreamReader streamReader = inputFactory.createXMLStreamReader(input); XMLInputFactory readerFactory = XMLInputFactory.newInstance(); XMLEventReader eventReader = readerFactory.createXMLEventReader(streamReader); XMLOutputFactory outputFactory = XMLOutputFactory.newInstance(); XMLEventWriter eventWriter = outputFactory.createXMLEventWriter(baos); eventWriter.add(eventReader); eventWriter.close();
XMLOutputFactory xmlOutFactory = XMLOutputFactory.newFactory(); XMLEventWriter xmlEventWriter = xmlOutFactory.createXMLEventWriter(outputWriter); XMLEventFactory xmlEventFactory = XMLEventFactory.newFactory(); xmlEventWriter.add(xmlEventFactory.createStartDocument()); xmlEventWriter.add(xmlEventFactory.createStartElement("", null, "rootSet")); XMLInputFactory xmlInFactory = XMLInputFactory.newFactory(); for (File rootFile : rootFiles) { XMLEventReader xmlEventReader = xmlInFactory.createXMLEventReader(new StreamSource(rootFile)); XMLEvent event = xmlEventReader.nextEvent(); while (event.getEventType() != XMLEvent.START_ELEMENT) { event = xmlEventReader.nextEvent(); xmlEventWriter.add(event); event = xmlEventReader.nextEvent(); } while (event.getEventType() != XMLEvent.END_DOCUMENT); xmlEventReader.close(); xmlEventWriter.add(xmlEventFactory.createEndElement("", null, "rootSet")); xmlEventWriter.add(xmlEventFactory.createEndDocument()); xmlEventWriter.close(); outputWriter.close();
public void endCDATA() throws SAXException { eventFactory.setLocation(getCurrentLocation()); try { writer.add(eventFactory.createCData(CDATABuffer.toString())); } catch (XMLStreamException e) { throw new SAXException(e); } super.endCDATA(); }
public boolean run(InputStream input, OutputStream output, GlobalContext context, Controller<GlobalContext> controller) throws XMLStreamException { XMLInputFactory inFactory = XMLInputFactory.newInstance(); XMLEventReader eventReader = inFactory.createXMLEventReader(input); XMLOutputFactory factory = XMLOutputFactory.newInstance(); factory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, true); XMLEventWriter writer = factory.createXMLEventWriter(output); boolean result = run(eventReader, writer, context, controller); writer.close(); return result; }
StringWriter sw = new StringWriter(); XMLOutputFactory of = XMLOutputFactory.newInstance(); XMLEventWriter xw = null; XMLInputFactory f = XMLInputFactory.newInstance(); XMLEventReader xr = f.createXMLEventReader(new FileInputStream("test.xml")); while (xr.hasNext()) { XMLEvent e = xr.nextEvent(); if (e.isStartElement() && ((StartElement) e).getName().getLocalPart().equals("tagINeed")) { xw = of.createXMLEventWriter(sw); } else if (e.isEndElement() && ((EndElement) e).getName().getLocalPart().equals("tagINeed")) { break; } else if (xw != null) { xw.add(e); } } xw.close(); System.out.println(sw);
public String getModifiedContent() throws XMLStreamException, IOException { StringWriter sw = new StringWriter(); XMLEventWriter xmlEventWriter = XMLOutputFactory.newInstance().createXMLEventWriter(sw); xmlReader = createXMLReader(); while (xmlReader.hasNext()) { XMLEvent e = xmlReader.nextEvent(); if (isTableColumnEvent(e)) { e = rewriteNameAttribute(e); } else if (isExcelFormula(e)) { xmlEventWriter.add(e); e = xmlReader.nextEvent(); if (e.isCharacters()) { e = eventFactory.createCharacters(updateTextualReferencesInParsedCharacterData(e.asCharacters())); } } xmlEventWriter.add(e); } return sw.toString(); }
XMLInputFactory factory = XMLInputFactory.newInstance(); XMLEventReader reader =factory.createXMLEventReader(new FileReader("input.xml")); XMLEventWriter writer = XMLOutputFactory.newInstance().createXMLEventWriter(new FileWriter("out.xml")); String toggleMe = "element2"; String regEx = "<!--(.*)-->"; while(reader.hasNext()) { XMLEvent event = reader.nextEvent(); if(event.getEventType() == XMLStreamConstants.COMMENT) { if(event.toString().contains(toggleMe)) { String xmlElement = event.toString().replaceAll(regEx, "$1"); XMLEventReader elementReader = factory.createFilteredReader(factory.createXMLEventReader(new StringReader(xmlElement)), new DocElementEventFilter()); while(elementReader.hasNext()) { writer.add(elementReader.nextEvent()); } }else { writer.add(event); } } else { writer.add(event); } } writer.flush(); writer.close(); reader.close();