下面列出了javax.xml.stream.events.XMLEvent#END_DOCUMENT 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private int findNextEvent() throws XMLStreamException {
fStreamAdvancedByHasNext = false;
while(fStreamReader.hasNext()){
fCurrentEvent = fStreamReader.next();
if(fStreamFilter.accept(fStreamReader)){
fEventAccepted = true;
return fCurrentEvent;
}
}
//although it seems that IllegalStateException should be thrown when next() is called
//on a stream that has no more items, we have to assume END_DOCUMENT is always accepted
//in order to pass the TCK
if (fCurrentEvent == XMLEvent.END_DOCUMENT)
return fCurrentEvent;
else
return -1;
}
private int findNextEvent() throws XMLStreamException {
fStreamAdvancedByHasNext = false;
while(fStreamReader.hasNext()){
fCurrentEvent = fStreamReader.next();
if(fStreamFilter.accept(fStreamReader)){
fEventAccepted = true;
return fCurrentEvent;
}
}
//although it seems that IllegalStateException should be thrown when next() is called
//on a stream that has no more items, we have to assume END_DOCUMENT is always accepted
//in order to pass the TCK
if (fCurrentEvent == XMLEvent.END_DOCUMENT)
return fCurrentEvent;
else
return -1;
}
final static String getEventTypeString(int eventType) {
switch (eventType){
case XMLEvent.START_ELEMENT:
return "START_ELEMENT";
case XMLEvent.END_ELEMENT:
return "END_ELEMENT";
case XMLEvent.PROCESSING_INSTRUCTION:
return "PROCESSING_INSTRUCTION";
case XMLEvent.CHARACTERS:
return "CHARACTERS";
case XMLEvent.COMMENT:
return "COMMENT";
case XMLEvent.START_DOCUMENT:
return "START_DOCUMENT";
case XMLEvent.END_DOCUMENT:
return "END_DOCUMENT";
case XMLEvent.ENTITY_REFERENCE:
return "ENTITY_REFERENCE";
case XMLEvent.ATTRIBUTE:
return "ATTRIBUTE";
case XMLEvent.DTD:
return "DTD";
case XMLEvent.CDATA:
return "CDATA";
case XMLEvent.SPACE:
return "SPACE";
}
return "UNKNOWN_EVENT_TYPE, " + String.valueOf(eventType);
}
private static void testNextEvent(int max)
throws IOException, XMLStreamException {
System.out.println("\nTest nextEvent (" + max + ")...");
XMLEventReader reader = createXmlReader(max);
XMLEvent event;
do {
event = reader.nextEvent();
System.out.println(event);
} while (event.getEventType() != XMLEvent.END_DOCUMENT);
System.out.println("nextEvent passed\n");
}
final static String getEventTypeString(int eventType) {
switch (eventType){
case XMLEvent.START_ELEMENT:
return "START_ELEMENT";
case XMLEvent.END_ELEMENT:
return "END_ELEMENT";
case XMLEvent.PROCESSING_INSTRUCTION:
return "PROCESSING_INSTRUCTION";
case XMLEvent.CHARACTERS:
return "CHARACTERS";
case XMLEvent.COMMENT:
return "COMMENT";
case XMLEvent.START_DOCUMENT:
return "START_DOCUMENT";
case XMLEvent.END_DOCUMENT:
return "END_DOCUMENT";
case XMLEvent.ENTITY_REFERENCE:
return "ENTITY_REFERENCE";
case XMLEvent.ATTRIBUTE:
return "ATTRIBUTE";
case XMLEvent.DTD:
return "DTD";
case XMLEvent.CDATA:
return "CDATA";
case XMLEvent.SPACE:
return "SPACE";
}
return "UNKNOWN_EVENT_TYPE, " + String.valueOf(eventType);
}
/**
* @throws XMLStreamException
* @return
*/
public boolean hasNext() throws XMLStreamException {
//the scanner returns -1 when it detects a broken stream
if (fEventType == -1) return false;
//we can check in scanners if the scanner state is not set to
//terminating, we still have more events.
return fEventType != XMLEvent.END_DOCUMENT;
}
private int findNextTag() throws XMLStreamException {
fStreamAdvancedByHasNext = false;
while(fStreamReader.hasNext()){
fCurrentEvent = fStreamReader.nextTag();
if(fStreamFilter.accept(fStreamReader)){
fEventAccepted = true;
return fCurrentEvent;
}
}
if (fCurrentEvent == XMLEvent.END_DOCUMENT)
return fCurrentEvent;
else
return -1;
}
final static String getEventTypeString(int eventType) {
switch (eventType){
case XMLEvent.START_ELEMENT:
return "START_ELEMENT";
case XMLEvent.END_ELEMENT:
return "END_ELEMENT";
case XMLEvent.PROCESSING_INSTRUCTION:
return "PROCESSING_INSTRUCTION";
case XMLEvent.CHARACTERS:
return "CHARACTERS";
case XMLEvent.COMMENT:
return "COMMENT";
case XMLEvent.START_DOCUMENT:
return "START_DOCUMENT";
case XMLEvent.END_DOCUMENT:
return "END_DOCUMENT";
case XMLEvent.ENTITY_REFERENCE:
return "ENTITY_REFERENCE";
case XMLEvent.ATTRIBUTE:
return "ATTRIBUTE";
case XMLEvent.DTD:
return "DTD";
case XMLEvent.CDATA:
return "CDATA";
case XMLEvent.SPACE:
return "SPACE";
}
return "UNKNOWN_EVENT_TYPE, " + String.valueOf(eventType);
}
static public List<XMLEvent> readerToEvents(XMLEventReader reader) {
try {
if (reader == null) {
return null;
}
List<XMLEvent> events = new ArrayList<>();
while (reader.hasNext()) {
XMLEvent event = reader.nextEvent();
switch (event.getEventType()) {
case XMLEvent.START_DOCUMENT:
case XMLEvent.END_DOCUMENT:
// skip prolog and end
break;
default:
events.add(event);
break;
}
}
if (events.size() == 0) {
return null;
}
return events;
} catch (XMLStreamException e) {
throw new MarkLogicIOException(e);
}
}
final static String getEventTypeString(int eventType) {
switch (eventType) {
case XMLEvent.START_ELEMENT:
return "START_ELEMENT";
case XMLEvent.END_ELEMENT:
return "END_ELEMENT";
case XMLEvent.PROCESSING_INSTRUCTION:
return "PROCESSING_INSTRUCTION";
case XMLEvent.CHARACTERS:
return "CHARACTERS";
case XMLEvent.COMMENT:
return "COMMENT";
case XMLEvent.START_DOCUMENT:
return "START_DOCUMENT";
case XMLEvent.END_DOCUMENT:
return "END_DOCUMENT";
case XMLEvent.ENTITY_REFERENCE:
return "ENTITY_REFERENCE";
case XMLEvent.ATTRIBUTE:
return "ATTRIBUTE";
case XMLEvent.DTD:
return "DTD";
case XMLEvent.CDATA:
return "CDATA";
case XMLEvent.SPACE:
return "SPACE";
}
return "UNKNOWN_EVENT_TYPE, " + String.valueOf(eventType);
}
/**
* @throws XMLStreamException
* @return
*/
public boolean hasNext() throws XMLStreamException {
//the scanner returns -1 when it detects a broken stream
if (fEventType == -1) return false;
//we can check in scanners if the scanner state is not set to
//terminating, we still have more events.
return fEventType != XMLEvent.END_DOCUMENT;
}
/**
* @throws XMLStreamException
* @return
*/
public boolean hasNext() throws XMLStreamException {
//the scanner returns -1 when it detects a broken stream
if (fEventType == -1) return false;
//we can check in scanners if the scanner state is not set to
//terminating, we still have more events.
return fEventType != XMLEvent.END_DOCUMENT;
}
final static String getEventTypeString(int eventType) {
switch (eventType){
case XMLEvent.START_ELEMENT:
return "START_ELEMENT";
case XMLEvent.END_ELEMENT:
return "END_ELEMENT";
case XMLEvent.PROCESSING_INSTRUCTION:
return "PROCESSING_INSTRUCTION";
case XMLEvent.CHARACTERS:
return "CHARACTERS";
case XMLEvent.COMMENT:
return "COMMENT";
case XMLEvent.START_DOCUMENT:
return "START_DOCUMENT";
case XMLEvent.END_DOCUMENT:
return "END_DOCUMENT";
case XMLEvent.ENTITY_REFERENCE:
return "ENTITY_REFERENCE";
case XMLEvent.ATTRIBUTE:
return "ATTRIBUTE";
case XMLEvent.DTD:
return "DTD";
case XMLEvent.CDATA:
return "CDATA";
case XMLEvent.SPACE:
return "SPACE";
}
return "UNKNOWN_EVENT_TYPE, " + String.valueOf(eventType);
}
private int findNextTag() throws XMLStreamException {
fStreamAdvancedByHasNext = false;
while(fStreamReader.hasNext()){
fCurrentEvent = fStreamReader.nextTag();
if(fStreamFilter.accept(fStreamReader)){
fEventAccepted = true;
return fCurrentEvent;
}
}
if (fCurrentEvent == XMLEvent.END_DOCUMENT)
return fCurrentEvent;
else
return -1;
}
/** Reads the content of a text-only element. Precondition:
* the current event is START_ELEMENT. Postcondition:
* The current event is the corresponding END_ELEMENT.
* @throws XMLStreamException if the current event is not a START_ELEMENT
* or if a non text element is encountered
*/
public String getElementText() throws XMLStreamException {
//we have to keep reference to the 'last event' of the stream to be able
//to make this check - is there another way ? - nb.
if(fLastEvent.getEventType() != XMLEvent.START_ELEMENT){
throw new XMLStreamException(
"parser must be on START_ELEMENT to read next text", fLastEvent.getLocation());
}
// STag content ETag
//[43] content ::= CharData? ((element | Reference | CDSect | PI | Comment) CharData?)*
//<foo>....some long text say in KB and underlying parser reports multiple character
// but getElementText() events....</foo>
String data = null;
//having a peeked event makes things really worse -- we have to test the first event
if(fPeekedEvent != null){
XMLEvent event = fPeekedEvent ;
fPeekedEvent = null;
int type = event.getEventType();
if( type == XMLEvent.CHARACTERS || type == XMLEvent.SPACE ||
type == XMLEvent.CDATA){
data = event.asCharacters().getData();
}
else if(type == XMLEvent.ENTITY_REFERENCE){
data = ((EntityReference)event).getDeclaration().getReplacementText();
}
else if(type == XMLEvent.COMMENT || type == XMLEvent.PROCESSING_INSTRUCTION){
//ignore
} else if(type == XMLEvent.START_ELEMENT) {
throw new XMLStreamException(
"elementGetText() function expects text only elment but START_ELEMENT was encountered.", event.getLocation());
}else if(type == XMLEvent.END_ELEMENT){
return "";
}
//create the string buffer and add initial data
StringBuffer buffer = new StringBuffer();
if(data != null && data.length() > 0 ) {
buffer.append(data);
}
//get the next event -- we should stop at END_ELEMENT but it can be any thing
//things are worse when implementing this function in XMLEventReader because
//there isn't any function called getText() which can get values for
//space, cdata, characters and entity reference
//nextEvent() would also set the last event.
event = nextEvent();
while(event.getEventType() != XMLEvent.END_ELEMENT){
if( type == XMLEvent.CHARACTERS || type == XMLEvent.SPACE ||
type == XMLEvent.CDATA){
data = event.asCharacters().getData();
}
else if(type == XMLEvent.ENTITY_REFERENCE){
data = ((EntityReference)event).getDeclaration().getReplacementText();
}
else if(type == XMLEvent.COMMENT || type == XMLEvent.PROCESSING_INSTRUCTION){
//ignore
} else if(type == XMLEvent.END_DOCUMENT) {
throw new XMLStreamException("unexpected end of document when reading element text content");
} else if(type == XMLEvent.START_ELEMENT) {
throw new XMLStreamException(
"elementGetText() function expects text only elment but START_ELEMENT was encountered.", event.getLocation());
} else {
throw new XMLStreamException(
"Unexpected event type "+ type, event.getLocation());
}
//add the data to the buffer
if(data != null && data.length() > 0 ) {
buffer.append(data);
}
event = nextEvent();
}
return buffer.toString();
}//if (fPeekedEvent != null)
//if there was no peeked, delegate everything to fXMLReader
//update the last event before returning the text
data = fXMLReader.getElementText();
fLastEvent = fXMLEventAllocator.allocate(fXMLReader);
return data;
}
XMLEvent getXMLEvent(XMLStreamReader reader){
XMLEvent event = null;
//returns the current event
int eventType = reader.getEventType();
//this needs to be set before creating events
factory.setLocation(reader.getLocation());
switch(eventType){
case XMLEvent.START_ELEMENT:
{
StartElementEvent startElement = (StartElementEvent)factory.createStartElement(reader.getPrefix(),
reader.getNamespaceURI(), reader.getLocalName());
addAttributes(startElement,reader);
addNamespaces(startElement, reader);
//need to fix it along with the Reader
//setNamespaceContext(startElement,reader);
event = startElement;
break;
}
case XMLEvent.END_ELEMENT:
{
EndElementEvent endElement = (EndElementEvent)factory.createEndElement(
reader.getPrefix(), reader.getNamespaceURI(), reader.getLocalName());
addNamespaces(endElement,reader);
event = endElement ;
break;
}
case XMLEvent.PROCESSING_INSTRUCTION:
{
event = factory.createProcessingInstruction(reader.getPITarget(),reader.getPIData());
break;
}
case XMLEvent.CHARACTERS:
{
if (reader.isWhiteSpace())
event = factory.createSpace(reader.getText());
else
event = factory.createCharacters(reader.getText());
break;
}
case XMLEvent.COMMENT:
{
event = factory.createComment(reader.getText());
break;
}
case XMLEvent.START_DOCUMENT:
{
StartDocumentEvent docEvent = (StartDocumentEvent)factory.createStartDocument(
reader.getVersion(), reader.getEncoding(), reader.isStandalone());
if(reader.getCharacterEncodingScheme() != null){
docEvent.setDeclaredEncoding(true);
}else{
docEvent.setDeclaredEncoding(false);
}
event = docEvent ;
break;
}
case XMLEvent.END_DOCUMENT:{
EndDocumentEvent endDocumentEvent = new EndDocumentEvent() ;
event = endDocumentEvent ;
break;
}
case XMLEvent.ENTITY_REFERENCE:{
event = factory.createEntityReference(reader.getLocalName(),
new EntityDeclarationImpl(reader.getLocalName(),reader.getText()));
break;
}
case XMLEvent.ATTRIBUTE:{
event = null ;
break;
}
case XMLEvent.DTD:{
event = factory.createDTD(reader.getText());
break;
}
case XMLEvent.CDATA:{
event = factory.createCData(reader.getText());
break;
}
case XMLEvent.SPACE:{
event = factory.createSpace(reader.getText());
break;
}
}
return event ;
}
/** Reads the content of a text-only element. Precondition:
* the current event is START_ELEMENT. Postcondition:
* The current event is the corresponding END_ELEMENT.
* @throws XMLStreamException if the current event is not a START_ELEMENT
* or if a non text element is encountered
*/
public String getElementText() throws XMLStreamException {
//we have to keep reference to the 'last event' of the stream to be able
//to make this check - is there another way ? - nb.
if(fLastEvent.getEventType() != XMLEvent.START_ELEMENT){
throw new XMLStreamException(
"parser must be on START_ELEMENT to read next text", fLastEvent.getLocation());
}
// STag content ETag
//[43] content ::= CharData? ((element | Reference | CDSect | PI | Comment) CharData?)*
//<foo>....some long text say in KB and underlying parser reports multiple character
// but getElementText() events....</foo>
String data = null;
//having a peeked event makes things really worse -- we have to test the first event
if(fPeekedEvent != null){
XMLEvent event = fPeekedEvent ;
fPeekedEvent = null;
int type = event.getEventType();
if( type == XMLEvent.CHARACTERS || type == XMLEvent.SPACE ||
type == XMLEvent.CDATA){
data = event.asCharacters().getData();
}
else if(type == XMLEvent.ENTITY_REFERENCE){
data = ((EntityReference)event).getDeclaration().getReplacementText();
}
else if(type == XMLEvent.COMMENT || type == XMLEvent.PROCESSING_INSTRUCTION){
//ignore
} else if(type == XMLEvent.START_ELEMENT) {
throw new XMLStreamException(
"elementGetText() function expects text only elment but START_ELEMENT was encountered.", event.getLocation());
}else if(type == XMLEvent.END_ELEMENT){
return "";
}
//create the string buffer and add initial data
StringBuffer buffer = new StringBuffer();
if(data != null && data.length() > 0 ) {
buffer.append(data);
}
//get the next event -- we should stop at END_ELEMENT but it can be any thing
//things are worse when implementing this function in XMLEventReader because
//there isn't any function called getText() which can get values for
//space, cdata, characters and entity reference
//nextEvent() would also set the last event.
event = nextEvent();
while(event.getEventType() != XMLEvent.END_ELEMENT){
if( type == XMLEvent.CHARACTERS || type == XMLEvent.SPACE ||
type == XMLEvent.CDATA){
data = event.asCharacters().getData();
}
else if(type == XMLEvent.ENTITY_REFERENCE){
data = ((EntityReference)event).getDeclaration().getReplacementText();
}
else if(type == XMLEvent.COMMENT || type == XMLEvent.PROCESSING_INSTRUCTION){
//ignore
} else if(type == XMLEvent.END_DOCUMENT) {
throw new XMLStreamException("unexpected end of document when reading element text content");
} else if(type == XMLEvent.START_ELEMENT) {
throw new XMLStreamException(
"elementGetText() function expects text only elment but START_ELEMENT was encountered.", event.getLocation());
} else {
throw new XMLStreamException(
"Unexpected event type "+ type, event.getLocation());
}
//add the data to the buffer
if(data != null && data.length() > 0 ) {
buffer.append(data);
}
event = nextEvent();
}
return buffer.toString();
}//if (fPeekedEvent != null)
//if there was no peeked, delegate everything to fXMLReader
//update the last event before returning the text
data = fXMLReader.getElementText();
fLastEvent = fXMLEventAllocator.allocate(fXMLReader);
return data;
}
public boolean isEndDocument() {
return fEventType == XMLEvent.END_DOCUMENT;
}
/** Reads the content of a text-only element. Precondition:
* the current event is START_ELEMENT. Postcondition:
* The current event is the corresponding END_ELEMENT.
* @throws XMLStreamException if the current event is not a START_ELEMENT
* or if a non text element is encountered
*/
public String getElementText() throws XMLStreamException {
//we have to keep reference to the 'last event' of the stream to be able
//to make this check - is there another way ? - nb.
if(fLastEvent.getEventType() != XMLEvent.START_ELEMENT){
throw new XMLStreamException(
"parser must be on START_ELEMENT to read next text", fLastEvent.getLocation());
}
// STag content ETag
//[43] content ::= CharData? ((element | Reference | CDSect | PI | Comment) CharData?)*
//<foo>....some long text say in KB and underlying parser reports multiple character
// but getElementText() events....</foo>
String data = null;
//having a peeked event makes things really worse -- we have to test the first event
if(fPeekedEvent != null){
XMLEvent event = fPeekedEvent ;
fPeekedEvent = null;
int type = event.getEventType();
if( type == XMLEvent.CHARACTERS || type == XMLEvent.SPACE ||
type == XMLEvent.CDATA){
data = event.asCharacters().getData();
}
else if(type == XMLEvent.ENTITY_REFERENCE){
data = ((EntityReference)event).getDeclaration().getReplacementText();
}
else if(type == XMLEvent.COMMENT || type == XMLEvent.PROCESSING_INSTRUCTION){
//ignore
} else if(type == XMLEvent.START_ELEMENT) {
throw new XMLStreamException(
"elementGetText() function expects text only elment but START_ELEMENT was encountered.", event.getLocation());
}else if(type == XMLEvent.END_ELEMENT){
return "";
}
//create the string buffer and add initial data
StringBuffer buffer = new StringBuffer();
if(data != null && data.length() > 0 ) {
buffer.append(data);
}
//get the next event -- we should stop at END_ELEMENT but it can be any thing
//things are worse when implementing this function in XMLEventReader because
//there isn't any function called getText() which can get values for
//space, cdata, characters and entity reference
//nextEvent() would also set the last event.
event = nextEvent();
while(event.getEventType() != XMLEvent.END_ELEMENT){
if( type == XMLEvent.CHARACTERS || type == XMLEvent.SPACE ||
type == XMLEvent.CDATA){
data = event.asCharacters().getData();
}
else if(type == XMLEvent.ENTITY_REFERENCE){
data = ((EntityReference)event).getDeclaration().getReplacementText();
}
else if(type == XMLEvent.COMMENT || type == XMLEvent.PROCESSING_INSTRUCTION){
//ignore
} else if(type == XMLEvent.END_DOCUMENT) {
throw new XMLStreamException("unexpected end of document when reading element text content");
} else if(type == XMLEvent.START_ELEMENT) {
throw new XMLStreamException(
"elementGetText() function expects text only elment but START_ELEMENT was encountered.", event.getLocation());
} else {
throw new XMLStreamException(
"Unexpected event type "+ type, event.getLocation());
}
//add the data to the buffer
if(data != null && data.length() > 0 ) {
buffer.append(data);
}
event = nextEvent();
}
return buffer.toString();
}//if (fPeekedEvent != null)
//if there was no peeked, delegate everything to fXMLReader
//update the last event before returning the text
data = fXMLReader.getElementText();
fLastEvent = fXMLEventAllocator.allocate(fXMLReader);
return data;
}
public boolean isEndDocument() {
return fEventType == XMLEvent.END_DOCUMENT;
}