@Override public QName getName() { if (this.event.isStartElement()) { return this.event.asStartElement().getName(); } else if (this.event.isEndElement()) { return this.event.asEndElement().getName(); } else { throw new IllegalStateException(); } }
@Override public String getElementText() throws XMLStreamException { checkIfClosed(); if (this.currentEvent == null || !this.currentEvent.isStartElement()) { throw new XMLStreamException("Not at START_ELEMENT: " + this.currentEvent); } StringBuilder builder = new StringBuilder(); while (true) { XMLEvent event = nextEvent(); if (event.isEndElement()) { break; } else if (!event.isCharacters()) { throw new XMLStreamException("Unexpected non-text event: " + event); } Characters characters = event.asCharacters(); if (!characters.isIgnorableWhiteSpace()) { builder.append(event.asCharacters().getData()); } } return builder.toString(); }
@Override public final XMLEvent nextTag() throws XMLStreamException { XMLEvent event = this.nextEvent(); while ((event.isCharacters() && event.asCharacters().isWhiteSpace()) || event.isProcessingInstruction() || event.getEventType() == XMLStreamConstants.COMMENT) { event = this.nextEvent(); } if (!event.isStartElement() && event.isEndElement()) { throw new XMLStreamException("Unexpected event type '" + XMLStreamConstantsUtils.getEventName(event.getEventType()) + "' encountered. Found event: " + event, event.getLocation()); } return event; } }
@Override public String getText() { if (this.event.isCharacters()) { return this.event.asCharacters().getData(); } else if (this.event.getEventType() == XMLEvent.COMMENT) { return ((Comment) this.event).getText(); } else { throw new IllegalStateException(); } }
@Override public NamespaceContext getNamespaceContext() { if (this.event.isStartElement()) { return this.event.asStartElement().getNamespaceContext(); } else { throw new IllegalStateException(); } }
public DeleteEnvironmentConfigurationResult unmarshall(StaxUnmarshallerContext context) throws Exception { DeleteEnvironmentConfigurationResult deleteEnvironmentConfigurationResult = new DeleteEnvironmentConfigurationResult(); int originalDepth = context.getCurrentDepth(); int targetDepth = originalDepth + 1; if (context.isStartOfDocument()) targetDepth += 1; while (true) { XMLEvent xmlEvent = context.nextEvent(); if (xmlEvent.isEndDocument()) return deleteEnvironmentConfigurationResult; if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) { } else if (xmlEvent.isEndElement()) { if (context.getCurrentDepth() < originalDepth) { return deleteEnvironmentConfigurationResult; } } } }
while (this.reader.hasNext() && elementDepth >= 0) { XMLEvent event = this.reader.nextEvent(); if (!event.isStartDocument() && !event.isEndDocument() && !documentStarted) { handleStartDocument(event); documentStarted = true; switch (event.getEventType()) { case XMLStreamConstants.START_DOCUMENT: handleStartDocument(event); case XMLStreamConstants.START_ELEMENT: elementDepth++; handleStartElement(event.asStartElement()); break; case XMLStreamConstants.END_ELEMENT: elementDepth--; if (elementDepth >= 0) { handleEndElement(event.asEndElement()); case XMLStreamConstants.SPACE: case XMLStreamConstants.CDATA: handleCharacters(event.asCharacters()); break; case XMLStreamConstants.END_DOCUMENT:
/** * Returns the next XML event for the document being parsed. * * @return The next XML event for the document being parsed. * * @throws XMLStreamException */ public XMLEvent nextEvent() throws XMLStreamException { if (attributeIterator != null && attributeIterator.hasNext()) { currentEvent = (XMLEvent)attributeIterator.next(); } else { currentEvent = eventReader.nextEvent(); } if (currentEvent.isStartElement()) { attributeIterator = currentEvent.asStartElement().getAttributes(); } updateContext(currentEvent); if (eventReader.hasNext()) { XMLEvent nextEvent = eventReader.peek(); if (nextEvent != null && nextEvent.isCharacters()) { for (MetadataExpression metadataExpression : metadataExpressions) { if (testExpression(metadataExpression.expression, metadataExpression.targetDepth)) { metadata.put(metadataExpression.key, nextEvent.asCharacters().getData()); } } } } return currentEvent; }
@Override public Publisher<? extends List<XMLEvent>> apply(XMLEvent event) { if (event.isStartElement()) { if (this.barrier == Integer.MAX_VALUE) { QName startElementName = event.asStartElement().getName(); if (this.desiredName.equals(startElementName)) { this.events = new ArrayList<>(); this.barrier = this.elementDepth; } } this.elementDepth++; } if (this.elementDepth > this.barrier) { Assert.state(this.events != null, "No XMLEvent List"); this.events.add(event); } if (event.isEndElement()) { this.elementDepth--; if (this.elementDepth == this.barrier) { this.barrier = Integer.MAX_VALUE; Assert.state(this.events != null, "No XMLEvent List"); return Mono.just(this.events); } } return Mono.empty(); } }
throw new XMLStreamException("Must be on START_ELEMENT to read next text, element was null"); if (!event.isStartElement()) { throw new XMLStreamException("Must be on START_ELEMENT to read next text", event.getLocation()); while (!event.isEndDocument()) { switch (event.getEventType()) { case XMLStreamConstants.CHARACTERS: case XMLStreamConstants.SPACE: case XMLStreamConstants.CDATA: { final Characters characters = event.asCharacters(); text.append(characters.getData()); break; throw new XMLStreamException("Unexpected event type '" + XMLStreamConstantsUtils.getEventName(event.getEventType()) + "' encountered. Found event: " + event, event.getLocation());
protected String getCurrentQName() { QName qName; if(event.isEndElement()) qName = event.asEndElement().getName(); else qName = event.asStartElement().getName(); return getQName(qName.getPrefix(), qName.getLocalPart()); }
private boolean isUnopenedElementCloseEvent(XMLEvent event) { if (unopenedElements.isEmpty()) { return false; } else if (!event.isEndElement()) { return false; } else { return unopenedElements.getLast().equals(event.asEndElement().getName()); } }
private void skipElement() throws XMLStreamException { while(xmlEventReader.hasNext()){ final XMLEvent xmlEvent = xmlEventReader.nextEvent(); if (xmlEvent.isStartElement()) { skipElement(); } if (xmlEvent.isEndElement()) { return; } } }
/** * Returns the text contents of the current element being parsed. * * @return The text contents of the current element being parsed. * @throws XMLStreamException */ public String readText() throws XMLStreamException { if (isInsideResponseHeader()) { return getHeader(currentHeader); } if (currentEvent.isAttribute()) { Attribute attribute = (Attribute)currentEvent; return attribute.getValue(); } StringBuilder sb = new StringBuilder(); while (true) { XMLEvent event = eventReader.peek(); if (event.getEventType() == XMLStreamConstants.CHARACTERS) { eventReader.nextEvent(); sb.append(event.asCharacters().getData()); } else if (event.getEventType() == XMLStreamConstants.END_ELEMENT) { return sb.toString(); } else { throw new RuntimeException("Encountered unexpected event: " + event.toString()); } } }
@Override @Nullable public XMLEvent nextTag() throws XMLStreamException { checkIfClosed(); while (true) { XMLEvent event = nextEvent(); switch (event.getEventType()) { case XMLStreamConstants.START_ELEMENT: case XMLStreamConstants.END_ELEMENT: return event; case XMLStreamConstants.END_DOCUMENT: return null; case XMLStreamConstants.SPACE: case XMLStreamConstants.COMMENT: case XMLStreamConstants.PROCESSING_INSTRUCTION: continue; case XMLStreamConstants.CDATA: case XMLStreamConstants.CHARACTERS: if (!event.asCharacters().isWhiteSpace()) { throw new XMLStreamException( "Non-ignorable whitespace CDATA or CHARACTERS event: " + event); } break; default: throw new XMLStreamException("Expected START_ELEMENT or END_ELEMENT: " + event); } } }
/** * Constructs a new instance of the {@code StaxEventXmlReader} that reads from * the given {@code XMLEventReader}. The supplied event reader must be in * {@code XMLStreamConstants.START_DOCUMENT} or {@code XMLStreamConstants.START_ELEMENT} state. * @param reader the {@code XMLEventReader} to read from * @throws IllegalStateException if the reader is not at the start of a document or element */ StaxEventXMLReader(XMLEventReader reader) { try { XMLEvent event = reader.peek(); if (event != null && !(event.isStartDocument() || event.isStartElement())) { throw new IllegalStateException("XMLEventReader not at start of document or element"); } } catch (XMLStreamException ex) { throw new IllegalStateException("Could not read first element: " + ex.getMessage()); } this.reader = reader; }
private static void assertCharacters(XMLEvent event, String expectedData) { assertTrue(event.isCharacters()); assertEquals(expectedData, event.asCharacters().getData()); }
@Override public int getEventType() { return this.event.getEventType(); }
@Override public void add(XMLEvent event) throws XMLStreamException { if ((!event.isStartDocument()) && (!event.isEndDocument())) { wrappedEventWriter.add(event); } }
public T unmarshall(StaxUnmarshallerContext context) throws Exception { while (context.nextEvent().isEndDocument() == false); return null; } }