Example usage for javax.xml.stream.events XMLEvent getEventType

List of usage examples for javax.xml.stream.events XMLEvent getEventType

  1. HOME
  2. Java
  3. javax
  4. javax.xml.stream.events.*
  5. XMLEvent
  6. getEventType

Introduction

In this page you can find the example usage for javax.xml.stream.events XMLEvent getEventType.

Prototype

public int getEventType();

Source Link

Document

Returns an integer code for this event.

Usage

From source file:microsoft.exchange.webservices.data.core.EwsXmlReader.java

/**
 * Reads the specified node type./*from  ww  w  .ja  v a2  s.c o m*/
 *
 * @param keepWhiteSpace Do not remove whitespace characters if true
 * @throws ServiceXmlDeserializationException  the service xml deserialization exception
 * @throws XMLStreamException the XML stream exception
 */
private void read(boolean keepWhiteSpace) throws ServiceXmlDeserializationException, XMLStreamException {
    // The caller to EwsXmlReader.Read expects
    // that there's another node to
    // read. Throw an exception if not true.
    while (true) {
        if (!xmlReader.hasNext()) {
            throw new ServiceXmlDeserializationException("Unexpected end of XML document.");
        } else {
            XMLEvent event = xmlReader.nextEvent();
            if (event.getEventType() == XMLStreamConstants.CHARACTERS) {
                Characters characters = (Characters) event;
                if (!keepWhiteSpace)
                    if (characters.isIgnorableWhiteSpace() || characters.isWhiteSpace()) {
                        continue;
                    }
            }
            this.prevEvent = this.presentEvent;
            this.presentEvent = event;
            break;
        }
    }
}

From source file:com.msopentech.odatajclient.testservice.utils.XMLUtilities.java

private int countFeedElements(final InputStream is, final String elementName) throws XMLStreamException {
    final XMLEventReader reader = getEventReader(is);

    int count = 0;

    while (reader.hasNext()) {
        final XMLEvent event = reader.nextEvent();

        if (event.getEventType() == XMLStreamConstants.START_ELEMENT
                && elementName.equals(event.asStartElement().getName().getLocalPart())) {
            count++;/* w  w w .  j a  v a2  s.  co  m*/
        }
    }

    reader.close();
    return count;
}

From source file:com.msopentech.odatajclient.testservice.utils.XMLUtilities.java

private void addAtomElement(final InputStream content, final XMLEventWriter writer) throws Exception {
    final XMLEventReader reader = getEventReader(content);

    final XMLEventFactory eventFactory = XMLEventFactory.newInstance();
    XMLEvent newLine = eventFactory.createSpace("\n");

    try {//from  w  ww. ja va  2s.c  om
        writer.add(newLine);

        while (reader.hasNext()) {
            final XMLEvent event = reader.nextEvent();

            if (event.getEventType() != XMLStreamConstants.START_DOCUMENT
                    && event.getEventType() != XMLStreamConstants.END_DOCUMENT
                    && event.getEventType() != XMLStreamConstants.COMMENT) {
                writer.add(event);
            }
        }
        writer.add(newLine);
    } finally {
        reader.close();
        IOUtils.closeQuietly(content);
    }
}

From source file:com.msopentech.odatajclient.testservice.utils.XMLUtilities.java

@Override
public InputStream selectEntity(final InputStream entity, final String[] propertyNames) throws Exception {
    final XMLEventReader reader = getEventReader(entity);

    final ByteArrayOutputStream bos = new ByteArrayOutputStream();
    final XMLOutputFactory xof = XMLOutputFactory.newInstance();
    final XMLEventWriter writer = xof.createXMLEventWriter(bos);

    final List<String> found = new ArrayList<String>(Arrays.asList(propertyNames));

    boolean inProperties = false;
    boolean writeCurrent = true;
    Boolean writeNext = null;//  w  w w .  ja  va  2  s .c o  m
    String currentName = null;

    final List<String> fieldToBeSaved = new ArrayList<String>(Arrays.asList(propertyNames));

    while (reader.hasNext()) {
        final XMLEvent event = reader.nextEvent();
        if (event.getEventType() == XMLStreamConstants.START_ELEMENT
                && LINK.equals(event.asStartElement().getName().getLocalPart())
                && !fieldToBeSaved
                        .contains(event.asStartElement().getAttributeByName(new QName("title")).getValue())
                && !"edit".equals(event.asStartElement().getAttributeByName(new QName("rel")).getValue())) {
            writeCurrent = false;
        } else if (event.getEventType() == XMLStreamConstants.END_ELEMENT
                && LINK.equals(event.asEndElement().getName().getLocalPart())) {
            writeNext = true;
        } else if (event.getEventType() == XMLStreamConstants.START_ELEMENT
                && (PROPERTIES).equals(event.asStartElement().getName().getLocalPart())) {
            writeCurrent = true;
            writeNext = false;
            inProperties = true;
        } else if (event.getEventType() == XMLStreamConstants.END_ELEMENT
                && (PROPERTIES).equals(event.asEndElement().getName().getLocalPart())) {
            writeCurrent = true;
        } else if (inProperties) {
            if (event.getEventType() == XMLStreamConstants.START_ELEMENT) {
                final String elementName = event.asStartElement().getName().getLocalPart();

                for (String propertyName : propertyNames) {
                    if ((ATOM_PROPERTY_PREFIX + propertyName.trim()).equals(elementName)) {
                        writeCurrent = true;
                        found.remove(propertyName);
                        currentName = propertyName;
                    }
                }

            } else if (event.getEventType() == XMLStreamConstants.END_ELEMENT
                    && StringUtils.isNotBlank(currentName) && (ATOM_PROPERTY_PREFIX + currentName.trim())
                            .equals(event.asEndElement().getName().getLocalPart())) {
                writeNext = false;
                currentName = null;
            }

        }

        if (writeCurrent) {
            writer.add(event);
        }

        if (writeNext != null) {
            writeCurrent = writeNext;
            writeNext = null;
        }
    }

    writer.flush();
    writer.close();
    reader.close();
    IOUtils.closeQuietly(entity);

    // Do not raise any exception in order to support FC properties as well
    // if (!found.isEmpty()) {
    //     throw new Exception(String.format("Could not find a properties '%s'", found));
    // }

    return new ByteArrayInputStream(bos.toByteArray());
}

From source file:ca.uhn.fhir.parser.XmlParser.java

private void encodeXhtml(XhtmlDt theDt, XMLStreamWriter theEventWriter) throws XMLStreamException {
    if (theDt == null || theDt.getValue() == null) {
        return;/*w  w w  . j av a 2 s  . co  m*/
    }

    boolean firstElement = true;
    for (XMLEvent event : theDt.getValue()) {
        switch (event.getEventType()) {
        case XMLStreamConstants.ATTRIBUTE:
            Attribute attr = (Attribute) event;
            if (isBlank(attr.getName().getPrefix())) {
                if (isBlank(attr.getName().getNamespaceURI())) {
                    theEventWriter.writeAttribute(attr.getName().getLocalPart(), attr.getValue());
                } else {
                    theEventWriter.writeAttribute(attr.getName().getNamespaceURI(),
                            attr.getName().getLocalPart(), attr.getValue());
                }
            } else {
                theEventWriter.writeAttribute(attr.getName().getPrefix(), attr.getName().getNamespaceURI(),
                        attr.getName().getLocalPart(), attr.getValue());
            }

            break;
        case XMLStreamConstants.CDATA:
            theEventWriter.writeCData(((Characters) event).getData());
            break;
        case XMLStreamConstants.CHARACTERS:
        case XMLStreamConstants.SPACE:
            String data = ((Characters) event).getData();
            theEventWriter.writeCharacters(data);
            break;
        case XMLStreamConstants.COMMENT:
            theEventWriter.writeComment(((Comment) event).getText());
            break;
        case XMLStreamConstants.END_ELEMENT:
            theEventWriter.writeEndElement();
            break;
        case XMLStreamConstants.ENTITY_REFERENCE:
            EntityReference er = (EntityReference) event;
            theEventWriter.writeEntityRef(er.getName());
            break;
        case XMLStreamConstants.NAMESPACE:
            Namespace ns = (Namespace) event;
            theEventWriter.writeNamespace(ns.getPrefix(), ns.getNamespaceURI());
            break;
        case XMLStreamConstants.START_ELEMENT:
            StartElement se = event.asStartElement();
            if (firstElement) {
                if (StringUtils.isBlank(se.getName().getPrefix())) {
                    String namespaceURI = se.getName().getNamespaceURI();
                    if (StringUtils.isBlank(namespaceURI)) {
                        namespaceURI = "http://www.w3.org/1999/xhtml";
                    }
                    theEventWriter.writeStartElement(se.getName().getLocalPart());
                    theEventWriter.writeDefaultNamespace(namespaceURI);
                } else {
                    String prefix = se.getName().getPrefix();
                    String namespaceURI = se.getName().getNamespaceURI();
                    theEventWriter.writeStartElement(prefix, se.getName().getLocalPart(), namespaceURI);
                    theEventWriter.writeNamespace(prefix, namespaceURI);
                }
                firstElement = false;
            } else {
                if (isBlank(se.getName().getPrefix())) {
                    if (isBlank(se.getName().getNamespaceURI())) {
                        theEventWriter.writeStartElement(se.getName().getLocalPart());
                    } else {
                        if (StringUtils.isBlank(se.getName().getPrefix())) {
                            theEventWriter.writeStartElement(se.getName().getLocalPart());
                            // theEventWriter.writeDefaultNamespace(se.getName().getNamespaceURI());
                        } else {
                            theEventWriter.writeStartElement(se.getName().getNamespaceURI(),
                                    se.getName().getLocalPart());
                        }
                    }
                } else {
                    theEventWriter.writeStartElement(se.getName().getPrefix(), se.getName().getLocalPart(),
                            se.getName().getNamespaceURI());
                }
                for (Iterator<?> attrIter = se.getAttributes(); attrIter.hasNext();) {
                    Attribute next = (Attribute) attrIter.next();
                    theEventWriter.writeAttribute(next.getName().getLocalPart(), next.getValue());
                }
            }
            break;
        case XMLStreamConstants.DTD:
        case XMLStreamConstants.END_DOCUMENT:
        case XMLStreamConstants.ENTITY_DECLARATION:
        case XMLStreamConstants.NOTATION_DECLARATION:
        case XMLStreamConstants.PROCESSING_INSTRUCTION:
        case XMLStreamConstants.START_DOCUMENT:
            break;
        }

    }
}

From source file:ca.uhn.fhir.parser.XmlParser.java

private <T> T doXmlLoop(XMLEventReader streamReader, ParserState<T> parserState) {
    ourLog.trace("Entering XML parsing loop with state: {}", parserState);

    try {//from   w  w  w.  j a v  a 2 s .c o m
        List<String> heldComments = new ArrayList<String>(1);

        while (streamReader.hasNext()) {
            XMLEvent nextEvent = streamReader.nextEvent();
            try {

                switch (nextEvent.getEventType()) {
                case XMLStreamConstants.START_ELEMENT: {
                    StartElement elem = nextEvent.asStartElement();

                    String namespaceURI = elem.getName().getNamespaceURI();

                    if ("extension".equals(elem.getName().getLocalPart())) {
                        Attribute urlAttr = elem.getAttributeByName(new QName("url"));
                        String url;
                        if (urlAttr == null || isBlank(urlAttr.getValue())) {
                            getErrorHandler().missingRequiredElement(new ParseLocation("extension"), "url");
                            url = null;
                        } else {
                            url = urlAttr.getValue();
                        }
                        parserState.enteringNewElementExtension(elem, url, false);
                    } else if ("modifierExtension".equals(elem.getName().getLocalPart())) {
                        Attribute urlAttr = elem.getAttributeByName(new QName("url"));
                        String url;
                        if (urlAttr == null || isBlank(urlAttr.getValue())) {
                            getErrorHandler().missingRequiredElement(new ParseLocation("modifierExtension"),
                                    "url");
                            url = null;
                        } else {
                            url = urlAttr.getValue();
                        }
                        parserState.enteringNewElementExtension(elem, url, true);
                    } else {
                        String elementName = elem.getName().getLocalPart();
                        parserState.enteringNewElement(namespaceURI, elementName);
                    }

                    if (!heldComments.isEmpty()) {
                        for (String next : heldComments) {
                            parserState.commentPre(next);
                        }
                        heldComments.clear();
                    }

                    @SuppressWarnings("unchecked")
                    Iterator<Attribute> attributes = elem.getAttributes();
                    for (Iterator<Attribute> iter = attributes; iter.hasNext();) {
                        Attribute next = iter.next();
                        parserState.attributeValue(next.getName().getLocalPart(), next.getValue());
                    }

                    break;
                }
                case XMLStreamConstants.END_DOCUMENT:
                case XMLStreamConstants.END_ELEMENT: {
                    if (!heldComments.isEmpty()) {
                        for (String next : heldComments) {
                            parserState.commentPost(next);
                        }
                        heldComments.clear();
                    }
                    parserState.endingElement();
                    //                  if (parserState.isComplete()) {
                    //                     return parserState.getObject();
                    //                  }
                    break;
                }
                case XMLStreamConstants.CHARACTERS: {
                    parserState.string(nextEvent.asCharacters().getData());
                    break;
                }
                case XMLStreamConstants.COMMENT: {
                    Comment comment = (Comment) nextEvent;
                    String commentText = comment.getText();
                    heldComments.add(commentText);
                    break;
                }
                }

                parserState.xmlEvent(nextEvent);

            } catch (DataFormatException e) {
                throw new DataFormatException("DataFormatException at [" + nextEvent.getLocation().toString()
                        + "]: " + e.getMessage(), e);
            }
        }
        return parserState.getObject();
    } catch (XMLStreamException e) {
        throw new DataFormatException(e);
    }
}

From source file:nl.nn.adapterframework.validation.XSD.java

public void init() throws ConfigurationException {
    if (noNamespaceSchemaLocation != null) {
        url = ClassUtils.getResourceURL(classLoader, noNamespaceSchemaLocation);
        if (url == null) {
            throw new ConfigurationException("Cannot find [" + noNamespaceSchemaLocation + "]");
        }//from  ww  w .  j a va  2s .  c  o m
        resourceTarget = noNamespaceSchemaLocation;
        toString = noNamespaceSchemaLocation;
    } else {
        if (resource != null) {
            url = ClassUtils.getResourceURL(classLoader, resource);
            if (url == null) {
                throw new ConfigurationException("Cannot find [" + resource + "]");
            }
            resourceTarget = resource;
            toString = resource;
            if (resourceInternalReference != null) {
                resourceTarget = resourceTarget + "-" + resourceInternalReference + ".xsd";
                toString = toString + "!" + resourceInternalReference;
            }
        } else if (sourceXsds == null) {
            throw new ConfigurationException(
                    "None of noNamespaceSchemaLocation, resource or mergedResources is specified");
        } else {
            resourceTarget = "[";
            toString = "[";
            boolean first = true;
            for (XSD xsd : sourceXsds) {
                if (first) {
                    first = false;
                } else {
                    resourceTarget = resourceTarget + ", ";
                    toString = toString + ", ";
                }
                resourceTarget = resourceTarget + xsd.getResourceTarget().replaceAll("/", "_");
                toString = toString + xsd.toString();
            }
            resourceTarget = resourceTarget + "].xsd";
            toString = toString + "]";
        }
        if (parentLocation == null) {
            this.parentLocation = "";
        }
    }
    try {
        InputStream in = getInputStream();
        XMLEventReader er = XmlUtils.INPUT_FACTORY.createXMLEventReader(in, XmlUtils.STREAM_FACTORY_ENCODING);
        int elementDepth = 0;
        while (er.hasNext()) {
            XMLEvent e = er.nextEvent();
            switch (e.getEventType()) {
            case XMLStreamConstants.START_ELEMENT:
                elementDepth++;
                StartElement el = e.asStartElement();
                if (el.getName().equals(SchemaUtils.SCHEMA)) {
                    Attribute a = el.getAttributeByName(SchemaUtils.TNS);
                    if (a != null) {
                        xsdTargetNamespace = a.getValue();
                    }
                    Iterator<Namespace> nsIterator = el.getNamespaces();
                    while (nsIterator.hasNext() && StringUtils.isEmpty(xsdDefaultNamespace)) {
                        Namespace ns = nsIterator.next();
                        if (StringUtils.isEmpty(ns.getPrefix())) {
                            xsdDefaultNamespace = ns.getNamespaceURI();
                        }
                    }
                } else if (el.getName().equals(SchemaUtils.IMPORT)) {
                    Attribute a = el.getAttributeByName(SchemaUtils.NAMESPACE);
                    if (a != null) {
                        boolean skip = false;
                        ArrayList ans = null;
                        if (StringUtils.isNotEmpty(getImportedNamespacesToIgnore())) {
                            ans = new ArrayList(Arrays.asList(getImportedNamespacesToIgnore().split(",")));
                        }
                        if (StringUtils.isNotEmpty(a.getValue()) && ans != null) {
                            if (ans.contains(a.getValue())) {
                                skip = true;
                            }
                        }
                        if (!skip) {
                            importedNamespaces.add(a.getValue());
                        }
                    }
                } else if (el.getName().equals(SchemaUtils.ELEMENT)) {
                    if (elementDepth == 2) {
                        rootTags.add(el.getAttributeByName(SchemaUtils.NAME).getValue());
                    }
                }
                break;
            case XMLStreamConstants.END_ELEMENT:
                elementDepth--;
                break;
            }
        }
        this.targetNamespace = xsdTargetNamespace;
        if (namespace == null) {
            // In case WsdlXmlValidator doesn't have schemaLocation
            namespace = xsdTargetNamespace;
        }
    } catch (IOException e) {
        String message = "IOException reading XSD";
        LOG.error(message, e);
        throw new ConfigurationException(message, e);
    } catch (XMLStreamException e) {
        String message = "XMLStreamException reading XSD";
        LOG.error(message, e);
        throw new ConfigurationException(message, e);
    }
}

From source file:nl.nn.adapterframework.validation.XSD.java

public Set<XSD> getXsdsRecursive(Set<XSD> xsds, boolean ignoreRedefine) throws ConfigurationException {
    try {// w  ww.  j  a v  a  2  s  .  c om
        InputStream in = getInputStream();
        if (in == null)
            return null;
        XMLEventReader er = XmlUtils.INPUT_FACTORY.createXMLEventReader(in, XmlUtils.STREAM_FACTORY_ENCODING);
        while (er.hasNext()) {
            XMLEvent e = er.nextEvent();
            switch (e.getEventType()) {
            case XMLStreamConstants.START_ELEMENT:
                StartElement el = e.asStartElement();
                if (el.getName().equals(SchemaUtils.IMPORT) || el.getName().equals(SchemaUtils.INCLUDE)
                        || (el.getName().equals(SchemaUtils.REDEFINE) && !ignoreRedefine)) {
                    Attribute schemaLocationAttribute = el.getAttributeByName(SchemaUtils.SCHEMALOCATION);
                    Attribute namespaceAttribute = el.getAttributeByName(SchemaUtils.NAMESPACE);
                    String namespace = this.namespace;
                    boolean addNamespaceToSchema = this.addNamespaceToSchema;
                    if (el.getName().equals(SchemaUtils.IMPORT)) {
                        if (namespaceAttribute == null && StringUtils.isEmpty(xsdDefaultNamespace)
                                && StringUtils.isNotEmpty(xsdTargetNamespace)) {
                            //TODO: concerning import without namespace when in head xsd default namespace doesn't exist and targetNamespace does)
                            namespace = null;
                        } else {
                            if (namespaceAttribute != null) {
                                namespace = namespaceAttribute.getValue();
                            } else {
                                namespace = targetNamespace;
                            }
                        }
                    }
                    if (schemaLocationAttribute != null) {
                        boolean skip = false;
                        if (el.getName().equals(SchemaUtils.IMPORT) && namespaceAttribute == null) {
                            if (StringUtils.isNotEmpty(xsdDefaultNamespace)
                                    && StringUtils.isNotEmpty(xsdTargetNamespace)) {
                                //ignore import without namespace when in head xsd default namespace and targetNamespace exists)
                                skip = true;
                            }
                        }
                        if (!skip) {
                            String sl = schemaLocationAttribute.getValue();
                            ArrayList aslti = null;
                            if (StringUtils.isNotEmpty(getImportedSchemaLocationsToIgnore())) {
                                aslti = new ArrayList(
                                        Arrays.asList(getImportedSchemaLocationsToIgnore().split(",")));
                            }
                            if (StringUtils.isNotEmpty(sl) && aslti != null) {
                                if (isUseBaseImportedSchemaLocationsToIgnore()) {
                                    sl = FilenameUtils.getName(sl);
                                }
                                if (aslti.contains(sl)) {
                                    skip = true;
                                }
                            }
                        }
                        if (!skip) {
                            ArrayList ans = null;
                            if (StringUtils.isNotEmpty(getImportedNamespacesToIgnore())) {
                                ans = new ArrayList(Arrays.asList(getImportedNamespacesToIgnore().split(",")));
                            }
                            if (StringUtils.isNotEmpty(namespace) && ans != null) {
                                if (ans.contains(namespace)) {
                                    skip = true;
                                }
                            }
                        }
                        if (!skip) {
                            XSD x = new XSD();
                            x.setClassLoader(classLoader);
                            x.setNamespace(namespace);
                            x.setResource(getResourceBase() + schemaLocationAttribute.getValue());
                            x.setAddNamespaceToSchema(addNamespaceToSchema);
                            x.setImportedSchemaLocationsToIgnore(getImportedSchemaLocationsToIgnore());
                            x.setUseBaseImportedSchemaLocationsToIgnore(
                                    isUseBaseImportedSchemaLocationsToIgnore());
                            x.setImportedNamespacesToIgnore(getImportedNamespacesToIgnore());
                            x.setParentLocation(getResourceBase());
                            x.setRootXsd(false);
                            x.init();
                            if (xsds.add(x)) {
                                x.getXsdsRecursive(xsds, ignoreRedefine);
                            }
                        }
                    }
                }
                break;
            }
        }
    } catch (IOException e) {
        String message = "IOException reading XSD";
        LOG.error(message, e);
        throw new ConfigurationException(message, e);
    } catch (XMLStreamException e) {
        String message = "XMLStreamException reading XSD";
        LOG.error(message, e);
        throw new ConfigurationException(message, e);
    }
    return xsds;
}

From source file:org.apache.hadoop.gateway.filter.rewrite.impl.xml.XmlFilterReader.java

private void processEvent(XMLEvent event)
        throws ParserConfigurationException, XPathExpressionException, IOException, XMLStreamException {
    int type = event.getEventType();
    switch (type) {
    case XMLEvent.START_DOCUMENT:
        processStartDocument((StartDocument) event);
        break;//from w  ww .j a v a2  s  .c o  m
    case XMLEvent.END_DOCUMENT:
        processEndDocument();
        break;
    case XMLEvent.START_ELEMENT:
        if (parser.peek().getEventType() == XMLEvent.END_ELEMENT)
            isEmptyElement = true;
        processStartElement(event.asStartElement());
        break;
    case XMLEvent.END_ELEMENT:
        processEndElement(event.asEndElement());
        isEmptyElement = false;
        break;
    case XMLEvent.CHARACTERS:
    case XMLEvent.CDATA:
    case XMLEvent.SPACE:
        processCharacters(event.asCharacters());
        break;
    case XMLEvent.COMMENT:
        processComment((Comment) event);
        break;
    case XMLEvent.DTD:
    case XMLEvent.NAMESPACE:
    case XMLEvent.ATTRIBUTE:
    case XMLEvent.ENTITY_REFERENCE:
    case XMLEvent.ENTITY_DECLARATION:
    case XMLEvent.NOTATION_DECLARATION:
    case XMLEvent.PROCESSING_INSTRUCTION:
    default:
        // Fail if we run into any of these for now.
        throw new IllegalStateException(Integer.toString(type));
    }
}

From source file:org.apache.hadoop.hdfs.tools.offlineImageViewer.OfflineImageReconstructor.java

/**
 * Read the next tag start or end event.
 *
 * @param expected     The name of the next tag we expect.
 *                     We will validate that the tag has this name,
 *                     unless this string is enclosed in braces.
 * @param allowEnd     If true, we will also end events.
 *                     If false, end events cause an exception.
 *
 * @return             The next tag start or end event.
 *//*w  w w.  j a va 2s. c  o m*/
private XMLEvent expectTag(String expected, boolean allowEnd) throws IOException {
    XMLEvent ev = null;
    while (true) {
        try {
            ev = events.nextEvent();
        } catch (XMLStreamException e) {
            throw new IOException("Expecting " + expected + ", but got XMLStreamException", e);
        }
        switch (ev.getEventType()) {
        case XMLEvent.ATTRIBUTE:
            throw new IOException("Got unexpected attribute: " + ev);
        case XMLEvent.CHARACTERS:
            if (!ev.asCharacters().isWhiteSpace()) {
                throw new IOException("Got unxpected characters while " + "looking for " + expected + ": "
                        + ev.asCharacters().getData());
            }
            break;
        case XMLEvent.END_ELEMENT:
            if (!allowEnd) {
                throw new IOException("Got unexpected end event " + "while looking for " + expected);
            }
            return ev;
        case XMLEvent.START_ELEMENT:
            if (!expected.startsWith("[")) {
                if (!ev.asStartElement().getName().getLocalPart().equals(expected)) {
                    throw new IOException("Failed to find <" + expected + ">; " + "got "
                            + ev.asStartElement().getName().getLocalPart() + " instead.");
                }
            }
            return ev;
        default:
            // Ignore other event types like comment, etc.
            if (LOG.isTraceEnabled()) {
                LOG.trace("Skipping XMLEvent of type " + ev.getEventType() + "(" + ev + ")");
            }
            break;
        }
    }
}