下面列出了javax.xml.stream.XMLEventWriter#flush ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private void convertAndWriteToFile( final InputStream inputStream, final File tmpFile ) throws IOException {
try ( final LZ4BlockOutputStream out = new LZ4BlockOutputStream( new FileOutputStream( tmpFile ) ) ) {
reset();
final XMLInputFactory inputFactory = XMLInputFactory.newInstance();
inputFactory.setProperty( XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, Boolean.FALSE );
final XMLEventReader eventReader =
inputFactory.createXMLEventReader( inputStream, StandardCharsets.UTF_8.name() );
final XMLEventWriter eventWriter =
XMLOutputFactory.newInstance().createXMLEventWriter( out, StandardCharsets.UTF_8.name() );
while ( eventReader.hasNext() ) {
final XMLEvent nextEvent = eventReader.nextEvent();
convert( nextEvent, eventWriter );
}
eventReader.close();
eventWriter.flush();
eventWriter.close();
} catch ( final XMLStreamException | FactoryConfigurationError e ) {
throw new RuntimeException( e );
}
}
/**
* Test XMLStreamWriter parsing a file with an external entity reference.
*/
@Test
public void testXMLStreamWriter() {
try {
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
XMLEventWriter eventWriter = outputFactory.createXMLEventWriter(System.out);
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
String file = getClass().getResource("XMLEventWriterTest.xml").getPath();
XMLEventReader eventReader = inputFactory.createXMLEventReader(new StreamSource(new File(file)));
// adds the event to the consumer.
eventWriter.add(eventReader);
eventWriter.flush();
eventWriter.close();
// expected success
} catch (Exception exception) {
exception.printStackTrace();
Assert.fail(exception.toString());
}
}
/**
* @bug 8139584
* Verifies that the resulting XML contains the standalone setting.
*/
@Test
public void testCreateStartDocument() throws XMLStreamException {
StringWriter stringWriter = new StringWriter();
XMLOutputFactory out = XMLOutputFactory.newInstance();
XMLEventFactory eventFactory = XMLEventFactory.newInstance();
XMLEventWriter eventWriter = out.createXMLEventWriter(stringWriter);
XMLEvent event = eventFactory.createStartDocument("iso-8859-15", "1.0", true);
eventWriter.add(event);
eventWriter.flush();
Assert.assertTrue(stringWriter.toString().contains("encoding=\"iso-8859-15\""));
Assert.assertTrue(stringWriter.toString().contains("version=\"1.0\""));
Assert.assertTrue(stringWriter.toString().contains("standalone=\"yes\""));
}
/**
* @bug 8139584
* Verifies that the resulting XML contains the standalone setting.
*/
@Test
public void testCreateStartDocument_DOMWriter()
throws ParserConfigurationException, XMLStreamException {
XMLOutputFactory xof = XMLOutputFactory.newInstance();
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.newDocument();
XMLEventWriter eventWriter = xof.createXMLEventWriter(new DOMResult(doc));
XMLEventFactory eventFactory = XMLEventFactory.newInstance();
XMLEvent event = eventFactory.createStartDocument("iso-8859-15", "1.0", true);
eventWriter.add(event);
eventWriter.flush();
Assert.assertEquals(doc.getXmlEncoding(), "iso-8859-15");
Assert.assertEquals(doc.getXmlVersion(), "1.0");
Assert.assertTrue(doc.getXmlStandalone());
}
public static boolean writeEvents(List<XMLEvent> events, OutputStream out) {
if (events == null || events.size() == 0) {
return false;
}
try {
XMLOutputFactory factory = XmlFactories.getOutputFactory();
XMLEventWriter eventWriter = factory.createXMLEventWriter(out, "UTF-8");
for (XMLEvent event: events) {
eventWriter.add(event);
}
eventWriter.flush();
eventWriter.close();
return true;
} catch (XMLStreamException e) {
throw new MarkLogicIOException(e);
}
}
@Override
public void write(OutputStream out) throws IOException {
try {
XMLInputFactory inputFactory = getFactory();
if (inputFactory == null) {
throw new MarkLogicInternalException("Failed to make StAX input factory");
}
// TODO: rework to copy straight from stream reader to stream writer
XMLEventReader reader = inputFactory.createXMLEventReader(content);
XMLOutputFactory outputFactory = XMLOutputFactory.newFactory();
XMLEventWriter writer =
outputFactory.createXMLEventWriter(out, "UTF-8");
writer.add(reader);
writer.flush();
writer.close();
content.close();
} catch (XMLStreamException e) {
logger.error("Failed to parse StAX events from input stream",e);
throw new MarkLogicInternalException(e);
}
}
@Test
public void testMarshallWithFormQualifiedElement() throws Exception {
ObjectWithQualifiedElementElement testObject = new ObjectWithQualifiedElementElement();
testObject.setString1("twine");
testObject.setString2("cord");
QName elName = new QName(wrapperAnnotation.targetNamespace(),
wrapperAnnotation.localName());
MessagePartInfo part = new MessagePartInfo(elName, null);
part.setElement(true);
part.setElementQName(elName);
StringWriter stringWriter = new StringWriter();
XMLOutputFactory opFactory = XMLOutputFactory.newInstance();
opFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
XMLEventWriter writer = opFactory.createXMLEventWriter(stringWriter);
JAXBEncoderDecoder.marshall(context.createMarshaller(), testObject, part, writer);
writer.flush();
writer.close();
String xmlResult = stringWriter.toString();
// the following is a bit of a crock, but, to tell the truth, this test case most exists
// so that it could be examined inside the debugger to see how JAXB works.
assertTrue(xmlResult.contains(":string2>cord</ns"));
}
@Override
public InputStream deleteProperty(final InputStream src, final List<String> path) throws Exception {
final XMLEventReader reader = getEventReader(src);
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
final XMLEventWriter writer = getEventWriter(bos);
final XMLEventReader changesReader =
new XMLEventReaderWrapper(IOUtils.toInputStream(
String.format("<%s m:null=\"true\" />", path.get(path.size() - 1)), Constants.ENCODING));
writer.add(changesReader);
changesReader.close();
writer.add(reader);
reader.close();
IOUtils.closeQuietly(src);
writer.flush();
writer.close();
return new ByteArrayInputStream(bos.toByteArray());
}
public XmlOutputStreamFilter(final OutputStream outputStream, final XmlEventTransformer eventTransformer) throws IOException {
super();
pipedInputStream = new PipedInputStream(this);
Callable<Boolean> output = new Callable<Boolean>() {
public Boolean call() {
try {
XMLEventReader eventReader = new com.fasterxml.aalto.stax.InputFactoryImpl()
.createXMLEventReader(pipedInputStream);
XMLEventWriter eventWriter = new com.fasterxml.aalto.stax.OutputFactoryImpl()
.createXMLEventWriter(outputStream);
XMLEvent event = null;
while (eventReader.hasNext()) {
event = eventReader.nextEvent();
event = eventTransformer.transform(event);
eventWriter.add(event);
eventWriter.flush();
}
eventReader.close();
eventWriter.flush();
eventWriter.close();
outputStream.flush();
outputStream.close();
} catch (XMLStreamException | IOException e) {
throw new IllegalStateException(e);
}
return true;
}
};
future = Executors.newSingleThreadExecutor().submit(output);
}
@Test
public void testMarshallWithoutQNameInfo() throws Exception {
GreetMe obj = new GreetMe();
obj.setRequestType("Hello");
ByteArrayOutputStream baos = new ByteArrayOutputStream();
XMLOutputFactory opFactory = XMLOutputFactory.newInstance();
opFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
XMLEventWriter writer = opFactory.createXMLEventWriter(baos);
//STARTDOCUMENT/ENDDOCUMENT is not required
//writer.add(eFactory.createStartDocument("utf-8", "1.0"));
JAXBEncoderDecoder.marshall(context.createMarshaller(), obj, null, writer);
//writer.add(eFactory.createEndDocument());
writer.flush();
writer.close();
//System.out.println(baos.toString());
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
XMLInputFactory ipFactory = XMLInputFactory.newInstance();
XMLEventReader reader = ipFactory.createXMLEventReader(bais);
Unmarshaller um = context.createUnmarshaller();
Object val = um.unmarshal(reader, GreetMe.class);
assertTrue(val instanceof JAXBElement);
val = ((JAXBElement<?>)val).getValue();
assertTrue(val instanceof GreetMe);
assertEquals(obj.getRequestType(),
((GreetMe)val).getRequestType());
}
public InputStream addAtomInlinecount(final InputStream feed, final int count) throws Exception {
final XMLEventReader reader = getEventReader(feed);
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
final XMLEventWriter writer = getEventWriter(bos);
try {
final XMLElement feedElement =
extractElement(reader, writer, Collections.<String> singletonList("feed"), 0, 1, 1).getValue();
writer.add(feedElement.getStart());
addAtomElement(IOUtils.toInputStream(String.format("<m:count>%d</m:count>", count), Constants.ENCODING), writer);
writer.add(feedElement.getContentReader());
writer.add(feedElement.getEnd());
while (reader.hasNext()) {
writer.add(reader.nextEvent());
}
} finally {
writer.flush();
writer.close();
reader.close();
IOUtils.closeQuietly(feed);
}
return new ByteArrayInputStream(bos.toByteArray());
}
private TempBlob transformXmlMetadata(final TempBlob artifact,
final Repository repository,
final String file,
final String extension,
final XmlStreamTransformer transformer) throws IOException {
Path tempFile = createTempFile("", ".xml");
// This is required in the case that the input stream is a jar to allow us to extract a single file
Path artifactsTempFile = createTempFile("", ".xml");
try {
try (InputStream xmlIn = xmlInputStream(artifact, file + "." + "xml", extension, artifactsTempFile);
OutputStream xmlOut = xmlOutputStream(file + "." + "xml", extension, tempFile)) {
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
inputFactory.setProperty(SUPPORT_DTD, false);
inputFactory.setProperty(IS_SUPPORTING_EXTERNAL_ENTITIES, false);
XMLOutputFactory outputFactory = XMLOutputFactory.newFactory();
XMLEventReader reader = null;
XMLEventWriter writer = null;
//try-with-resources will be better here, but XMLEventReader and XMLEventWriter are not AutoCloseable
try {
reader = inputFactory.createXMLEventReader(xmlIn);
writer = outputFactory.createXMLEventWriter(xmlOut);
transformer.transform(reader, writer);
writer.flush();
}
finally {
if (reader != null) {
reader.close();
}
if (writer != null) {
writer.close();
}
}
}
catch (XMLStreamException ex) {
log.error("Failed to rewrite metadata for file with extension {} and blob {} with reason: {} ",
ex, artifact.getBlob().getId(), ex);
return artifact;
}
return convertFileToTempBlob(tempFile, repository);
}
finally {
delete(tempFile);
delete(artifactsTempFile);
}
}
/**
* Inspired by CR 6245284 Sun Stax /sjsxp.jar does not behave properly
* during merge of xml files.
*/
@Test
public void testMerge() {
try {
// Create the XML input factory
XMLInputFactory factory = XMLInputFactory.newInstance();
// Create XML event reader 1
InputStream inputStream1 = new FileInputStream(new File(XMLEventWriterTest.class.getResource("merge-1.xml").toURI()));
XMLEventReader r1 = factory.createXMLEventReader(inputStream1);
// Create XML event reader 2
InputStream inputStream2 = new FileInputStream(new File(XMLEventWriterTest.class.getResource("merge-2.xml").toURI()));
XMLEventReader r2 = factory.createXMLEventReader(inputStream2);
// Create the output factory
XMLOutputFactory xmlof = XMLOutputFactory.newInstance();
// Create XML event writer
XMLEventWriter xmlw = xmlof.createXMLEventWriter(System.out);
// Read to first <product> element in document 1
// and output to result document
QName bName = new QName("b");
while (r1.hasNext()) {
// Read event to be written to result document
XMLEvent event = r1.nextEvent();
if (event.getEventType() == XMLEvent.END_ELEMENT) {
// Start element - stop at <product> element
QName name = event.asEndElement().getName();
if (name.equals(bName)) {
QName zName = new QName("z");
boolean isZr = false;
while (r2.hasNext()) {
// Read event to be written to result document
XMLEvent event2 = r2.nextEvent();
// Output event
if (event2.getEventType() == XMLEvent.START_ELEMENT && event2.asStartElement().getName().equals(zName)) {
isZr = true;
}
if (xmlw != null && isZr) {
xmlw.add(event2);
}
// stop adding events after </z>
// i.e. do not write END_DOCUMENT :)
if (isZr && event2.getEventType() == XMLEvent.END_ELEMENT && event2.asEndElement().getName().equals(zName)) {
isZr = false;
}
}
xmlw.flush();
}
}
// Output event
if (xmlw != null) {
xmlw.add(event);
}
}
// Read to first <product> element in document 1
// without writing to result document
xmlw.close();
// expected success
} catch (Exception ex) {
ex.printStackTrace();
Assert.fail(ex.toString());
}
}
private static String sanitizeAndEncode(byte[] inputXmlBytes)
throws XMLStreamException, UnsupportedEncodingException {
XMLEventReader xmlEventReader =
XML_INPUT_FACTORY.createXMLEventReader(new ByteArrayInputStream(inputXmlBytes));
if (!xmlEventReader.hasNext()) {
return "";
}
XMLEvent firstEvent = xmlEventReader.nextEvent();
checkState(firstEvent.isStartDocument(), "Missing StartDocument");
// Get input encoding for use in XMLEventWriter creation, so that sanitized XML preserves the
// encoding declaration. According to XML spec, UTF-8 is to be used unless input declares
// otherwise. Epp officially allows UTF-8 and UTF-16.
String inputEncoding =
Optional.ofNullable(((StartDocument) firstEvent).getCharacterEncodingScheme())
.orElse(StandardCharsets.UTF_8.name());
ByteArrayOutputStream outputXmlBytes = new ByteArrayOutputStream();
XMLEventWriter xmlEventWriter =
XML_OUTPUT_FACTORY.createXMLEventWriter(outputXmlBytes, inputEncoding);
xmlEventWriter.add(firstEvent);
while (xmlEventReader.hasNext()) {
XMLEvent xmlEvent = xmlEventReader.nextEvent();
xmlEventWriter.add(xmlEvent);
if (isStartEventForSensitiveData(xmlEvent)) {
QName startEventName = xmlEvent.asStartElement().getName();
while (xmlEventReader.hasNext()) {
XMLEvent event = xmlEventReader.nextEvent();
if (event.isCharacters()) {
Characters characters = event.asCharacters();
event = XML_EVENT_FACTORY.createCharacters(maskSensitiveData(characters.getData()));
}
xmlEventWriter.add(event);
if (isMatchingEndEvent(event, startEventName)) {
// The inner while-loop is guaranteed to break here for any valid XML.
// If matching event is missing, xmlEventReader will throw XMLStreamException.
break;
}
}
}
}
xmlEventWriter.flush();
return outputXmlBytes.toString(inputEncoding);
}
private String adjustXmlForGroups(String xml) {
if (StringUtils.isBlank(xml)) return null;
// special processing for assignments in order to deserialize groups correctly
// see https://stackoverflow.com/questions/47199799/jackson-xml-tag-and-attribute-with-the-same-name
// see https://github.com/FasterXML/jackson-dataformat-xml/issues/65
try (InputStream in = new ByteArrayInputStream(xml.getBytes());
OutputStream out = new ByteArrayOutputStream()) {
XMLEventReader reader = XMLInputFactory.newInstance().createXMLEventReader(in);
XMLEventWriter writer = XMLOutputFactory.newInstance().createXMLEventWriter(out);
XMLEventFactory eventFactory = XMLEventFactory.newInstance();
List<XMLEvent> groupEvents = new ArrayList<>();
while (reader.hasNext()) {
XMLEvent event = reader.nextEvent();
if (event.isStartElement() && "group".equals(event.asStartElement().getName().getLocalPart())) {
for (; !event.isEndElement(); event = reader.nextEvent()) {
groupEvents.add(event);
}
groupEvents.add(event);
} else if (event.isEndElement() && "assignment".equals(event.asEndElement().getName().getLocalPart())) {
writer.add(eventFactory.createStartElement("", "", "groups"));
for (XMLEvent e : groupEvents) {
writer.add(e);
}
writer.add(eventFactory.createEndElement("", "", "groups"));
writer.add(event);
} else {
writer.add(event);
}
}
writer.flush();
String adjustedXml = out.toString();
log.debug("adjusted groups in xml: {}", adjustedXml);
return adjustedXml;
} catch (XMLStreamException xse) {
log.warn("xml parsing error while adjusting for groups, {}\n{}", xse.getMessage(), xml);
} catch (IOException ioe) {
log.warn("could not adjust xml for groups, {}\n{}", ioe.getMessage(), xml);
}
return null;
}
/**
* {@inheritDoc }
*/
@Override
protected InputStream addLinks(
final String entitySetName, final String entitykey, final InputStream is, final Set<String> links)
throws Exception {
// -----------------------------------------
// 0. Build reader and writer
// -----------------------------------------
final XMLEventReader reader = getEventReader(is);
final XMLEventFactory eventFactory = XMLEventFactory.newInstance();
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
final XMLEventWriter writer = getEventWriter(bos);
// -----------------------------------------
final Map.Entry<Integer, XMLElement> entry =
extractElement(reader, writer, Collections.singletonList("entry"), 0, 1, 1);
writer.add(entry.getValue().getStart());
final Map<String, NavigationProperty> navigationProperties = metadata.getNavigationProperties(entitySetName);
// add for links
for (String link : links) {
final Set<Attribute> attributes = new HashSet<Attribute>();
attributes.add(eventFactory.createAttribute(new QName("title"), link));
attributes.add(eventFactory.createAttribute(new QName("href"),
Commons.getLinksURI(entitySetName, entitykey, link)));
attributes.add(eventFactory.createAttribute(new QName("rel"),
Constants.get(ConstantKey.ATOM_LINK_REL) + link));
attributes.add(eventFactory.createAttribute(new QName("type"),
navigationProperties.get(link).isEntitySet()
? Constants.get(ConstantKey.ATOM_LINK_FEED)
: Constants.get(ConstantKey.ATOM_LINK_ENTRY)));
writer.add(eventFactory.createStartElement(
new QName(Constants.get(ConstantKey.LINK)), attributes.iterator(), null));
writer.add(eventFactory.createEndElement(new QName(Constants.get(ConstantKey.LINK)), null));
}
writer.add(entry.getValue().getContentReader());
writer.add(entry.getValue().getEnd());
writer.add(reader);
IOUtils.closeQuietly(is);
writer.flush();
writer.close();
reader.close();
return new ByteArrayInputStream(bos.toByteArray());
}
@Override
public InputStream addEditLink(
final InputStream content, final String title, final String href)
throws Exception {
final ByteArrayOutputStream copy = new ByteArrayOutputStream();
IOUtils.copy(content, copy);
IOUtils.closeQuietly(content);
XMLEventReader reader = getEventReader(new ByteArrayInputStream(copy.toByteArray()));
ByteArrayOutputStream bos = new ByteArrayOutputStream();
XMLEventWriter writer = getEventWriter(bos);
final String editLinkElement = String.format("<link rel=\"edit\" title=\"%s\" href=\"%s\" />", title, href);
try {
// check edit link existence
extractElement(reader, writer, Collections.<String> singletonList(Constants.get(ConstantKey.LINK)),
Collections.<Map.Entry<String, String>> singletonList(
new AbstractMap.SimpleEntry<String, String>("rel", "edit")), false, 0, -1, -1);
addAtomElement(IOUtils.toInputStream(editLinkElement, Constants.ENCODING), writer);
writer.add(reader);
} catch (Exception e) {
reader.close();
reader = getEventReader(new ByteArrayInputStream(copy.toByteArray()));
bos = new ByteArrayOutputStream();
writer = getEventWriter(bos);
final XMLElement entryElement =
extractElement(reader, writer, Collections.<String> singletonList("entry"), 0, 1, 1).getValue();
writer.add(entryElement.getStart());
addAtomElement(IOUtils.toInputStream(editLinkElement, Constants.ENCODING), writer);
writer.add(entryElement.getContentReader());
writer.add(entryElement.getEnd());
writer.add(reader);
writer.flush();
writer.close();
} finally {
reader.close();
}
return new ByteArrayInputStream(bos.toByteArray());
}
@Override
protected InputStream replaceLink(
final InputStream toBeChanged, final String linkName, final InputStream replacement)
throws Exception {
final XMLEventReader reader = getEventReader(toBeChanged);
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
final XMLEventWriter writer = getEventWriter(bos);
final XMLEventFactory eventFactory = XMLEventFactory.newInstance();
XMLEvent newLine = eventFactory.createSpace("\n");
try {
final XMLElement linkElement =
extractElement(reader, writer,
Collections.<String> singletonList(Constants.get(ConstantKey.LINK)),
Collections.<Map.Entry<String, String>> singletonList(
new SimpleEntry<String, String>("title", linkName)), false, 0, -1, -1).getValue();
writer.add(linkElement.getStart());
// ------------------------------------------
// write inline ...
// ------------------------------------------
writer.add(newLine);
writer.add(eventFactory.createStartElement("m", null, "inline"));
addAtomElement(replacement, writer);
writer.add(eventFactory.createEndElement("m", null, "inline"));
writer.add(newLine);
// ------------------------------------------
writer.add(linkElement.getEnd());
writer.add(reader);
writer.flush();
writer.close();
} finally {
reader.close();
IOUtils.closeQuietly(toBeChanged);
}
return new ByteArrayInputStream(bos.toByteArray());
}
private String adjustXmlForGroups(String xml) {
if (StringUtils.isBlank(xml)) return null;
// special processing for assignments in order to deserialize groups correctly
// see https://stackoverflow.com/questions/47199799/jackson-xml-tag-and-attribute-with-the-same-name
// see https://github.com/FasterXML/jackson-dataformat-xml/issues/65
try (InputStream in = new ByteArrayInputStream(xml.getBytes());
OutputStream out = new ByteArrayOutputStream()) {
XMLEventReader reader = XMLInputFactory.newInstance().createXMLEventReader(in);
XMLEventWriter writer = XMLOutputFactory.newInstance().createXMLEventWriter(out);
XMLEventFactory eventFactory = XMLEventFactory.newInstance();
List<XMLEvent> groupEvents = new ArrayList<>();
while (reader.hasNext()) {
XMLEvent event = reader.nextEvent();
if (event.isStartElement() && "group".equals(event.asStartElement().getName().getLocalPart())) {
for (; !event.isEndElement(); event = reader.nextEvent()) {
groupEvents.add(event);
}
groupEvents.add(event);
} else if (event.isEndElement() && "assignment".equals(event.asEndElement().getName().getLocalPart())) {
writer.add(eventFactory.createStartElement("", "", "groups"));
for (XMLEvent e : groupEvents) {
writer.add(e);
}
writer.add(eventFactory.createEndElement("", "", "groups"));
writer.add(event);
} else {
writer.add(event);
}
}
writer.flush();
String adjustedXml = out.toString();
log.debug("adjusted groups in xml: {}", adjustedXml);
return adjustedXml;
} catch (XMLStreamException xse) {
log.warn("xml parsing error while adjusting for groups, {}\n{}", xse.getMessage(), xml);
} catch (IOException ioe) {
log.warn("could not adjust xml for groups, {}\n{}", ioe.getMessage(), xml);
}
return null;
}
/**
* Overwrite the package attribute of {@code <manifest>} in an AndroidManifest.xml file.
*
* @param manifest The input manifest.
* @param customPackage The package to write to the manifest.
* @param output The output manifest to generate.
* @return The output manifest if generated or the input manifest if no overwriting is required.
*/
/* TODO(apell): switch from custom xml parsing to Gradle merger with NO_PLACEHOLDER_REPLACEMENT
* set when android common is updated to version 2.5.0.
*/
public Path writeManifestPackage(Path manifest, String customPackage, Path output) {
if (Strings.isNullOrEmpty(customPackage)) {
return manifest;
}
try {
Files.createDirectories(output.getParent());
XMLEventReader reader =
XMLInputFactory.newInstance()
.createXMLEventReader(Files.newInputStream(manifest), UTF_8.name());
XMLEventWriter writer =
XMLOutputFactory.newInstance()
.createXMLEventWriter(Files.newOutputStream(output), UTF_8.name());
XMLEventFactory eventFactory = XMLEventFactory.newInstance();
while (reader.hasNext()) {
XMLEvent event = reader.nextEvent();
if (event.isStartElement()
&& event.asStartElement().getName().toString().equalsIgnoreCase("manifest")) {
StartElement element = event.asStartElement();
@SuppressWarnings("unchecked")
Iterator<Attribute> attributes = element.getAttributes();
ImmutableList.Builder<Attribute> newAttributes = ImmutableList.builder();
while (attributes.hasNext()) {
Attribute attr = attributes.next();
if (attr.getName().toString().equalsIgnoreCase("package")) {
newAttributes.add(eventFactory.createAttribute("package", customPackage));
} else {
newAttributes.add(attr);
}
}
writer.add(
eventFactory.createStartElement(
element.getName(), newAttributes.build().iterator(), element.getNamespaces()));
} else {
writer.add(event);
}
}
writer.flush();
} catch (XMLStreamException | FactoryConfigurationError | IOException e) {
throw new ManifestProcessingException(e);
}
return output;
}