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:StaxEvent.java

public static void main(String[] args) throws Exception {
    StaxEvent ms = new StaxEvent();

    XMLEventReader reader = XMLInputFactory.newInstance()
            .createXMLEventReader(new java.io.FileInputStream("yourXML.xml"));
    XMLEventWriter writer = XMLOutputFactory.newInstance().createXMLEventWriter(System.out);

    while (reader.hasNext()) {
        XMLEvent event = (XMLEvent) reader.next();

        if (event.getEventType() == event.CHARACTERS) {
            writer.add(ms.getNewCharactersEvent(event.asCharacters()));
        } else {//from w  w  w .  ja  va  2 s.c o m
            writer.add(event);
        }
    }
    writer.flush();
}

From source file:Main.java

public static void main(String[] args) throws Exception {
    File source = new File(args[0]);
    File target = new File(source + ".new");

    XMLInputFactory inputFactory = XMLInputFactory.newInstance();
    XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
    InputStream in = new FileInputStream(source);
    XMLEventReader reader = inputFactory.createXMLEventReader(in);

    OutputStream out = new FileOutputStream(target);
    XMLEventWriter writer = outputFactory.createXMLEventWriter(out);
    XMLEvent event;

    boolean deleteSection = false;
    while (reader.hasNext()) {
        event = reader.nextEvent();/* ww w  .j a  v  a  2  s .  co  m*/
        if (event.getEventType() == XMLStreamConstants.START_ELEMENT
                && event.asStartElement().getName().toString().equalsIgnoreCase("companies")) {
            deleteSection = true;
            continue;
        } else if (event.getEventType() == XMLStreamConstants.END_ELEMENT
                && (event.asEndElement().getName().toString().equalsIgnoreCase("companies"))) {
            deleteSection = false;
            continue;
        } else if (deleteSection) {
            continue;
        } else {
            writer.add(event);
        }
    }
}

From source file:Main.java

private static String flattenXmlRecord(final String xmlRecord) throws XMLStreamException {
    StringBuilder flatXmlRecord = new StringBuilder();
    XMLEventReader eventReader = inFactory.createXMLEventReader(new StringReader(xmlRecord));
    while (eventReader.hasNext()) {
        XMLEvent event = eventReader.nextEvent();
        if (event.getEventType() != XMLEvent.START_ELEMENT) {
            continue;
        }//from w ww.ja  v  a  2s  .  c o m
        String elementName = event.asStartElement().getName().getLocalPart();
        event = eventReader.nextEvent();
        if (event.getEventType() != XMLEvent.CHARACTERS) {
            continue;
        }
        if (event.asCharacters().getData().trim().isEmpty()) {
            continue;
        }
        flatXmlRecord.append(elementName + ", " + event.asCharacters().getData() + "\n");

    }
    return flatXmlRecord.toString();
}

From source file:Main.java

public static boolean isComment(XMLEvent e) {
    if (e.getEventType() == XMLEvent.COMMENT) {
        return true;
    }//from  www  . java 2  s  .com
    return false;
}

From source file:Main.java

/**
 * Copy an XML event stream.//  w ww  .  j a  v  a  2s . c om
 * @param reader The event reader.
 * @param writer The event writer.
 * @param omitDoc if true, ignore start/end document events.
 * @throws XMLStreamException For errors writing to the XML event writer.
 */
public static void copyXMLEventStream(final XMLEventReader reader, final XMLEventWriter writer,
        final boolean omitDoc) throws XMLStreamException {
    if (omitDoc) {
        while (reader.hasNext()) {
            final XMLEvent event = reader.nextEvent();
            final int type = event.getEventType();
            if ((type != XMLStreamConstants.START_DOCUMENT) && (type != XMLStreamConstants.END_DOCUMENT)) {
                writer.add(event);
            }
        }
    } else {
        writer.add(reader);
    }
    writer.flush();
}

From source file:Main.java

/**
 * //from   ww w. j  a  v a  2 s  . co m
 * @param is
 * @param os
 * @param elementNames
 * @throws XMLStreamException
 * @throws FactoryConfigurationError
 * @throws UnsupportedEncodingException
 */
public static void stripElements(final InputStream is, final OutputStream os,
        final Collection<String> elementNames)
        throws XMLStreamException, UnsupportedEncodingException, FactoryConfigurationError {
    final XMLEventReader xmlEventReader = XMLInputFactory.newInstance()
            .createXMLEventReader(new InputStreamReader(is, Charset.defaultCharset().name()));
    final XMLEventWriter xmlEventWriter = XMLOutputFactory.newInstance().createXMLEventWriter(os);

    String elementName = null;

    while (xmlEventReader.peek() != null) {
        final XMLEvent event = (XMLEvent) xmlEventReader.next();

        switch (event.getEventType()) {
        case XMLStreamConstants.START_DOCUMENT:
        case XMLStreamConstants.END_DOCUMENT: {
            // Ignore.
            break;
        }
        case XMLStreamConstants.START_ELEMENT: {
            final StartElement startElement = event.asStartElement();
            final QName name = startElement.getName();

            if (elementNames.contains(name.getLocalPart())) {
                elementName = name.getLocalPart();
            }

            if (elementName == null) {
                xmlEventWriter.add(event);
            }

            break;
        }
        case XMLStreamConstants.END_ELEMENT: {
            final EndElement endElement = event.asEndElement();
            final QName name = endElement.getName();

            if (elementName == null) {
                xmlEventWriter.add(event);
            } else if (elementName.equals(name.getLocalPart())) {
                elementName = null;
            }

            break;
        }
        default: {
            if (elementName == null) {
                xmlEventWriter.add(event);
            }
        }
        }
    }

    xmlEventWriter.flush();
}

From source file:Main.java

/**
 * /*from w w  w  . j  a  v  a 2s. com*/
 * @param elementName
 * @param attributeValue
 * @param is
 * @return Collection
 * @throws XMLStreamException
 * @throws FactoryConfigurationError
 * @throws UnsupportedEncodingException
 */
public static Collection<String> getElementValues(final String elementName, final String attributeValue,
        final InputStream is)
        throws XMLStreamException, UnsupportedEncodingException, FactoryConfigurationError {
    final Collection<String> elementValues = new ArrayList<>();
    final XMLEventReader xmlEventReader = XMLInputFactory.newInstance()
            .createXMLEventReader(new InputStreamReader(is, Charset.defaultCharset().name()));
    final StringBuffer characters = new StringBuffer();
    boolean read = false;

    while (xmlEventReader.peek() != null) {
        final XMLEvent event = (XMLEvent) xmlEventReader.next();

        switch (event.getEventType()) {
        case XMLStreamConstants.START_DOCUMENT:
        case XMLStreamConstants.END_DOCUMENT: {
            // Ignore.
            break;
        }
        case XMLStreamConstants.START_ELEMENT: {
            read = elementName.equals(event.asStartElement().getName().getLocalPart());

            if (read && attributeValue != null) {
                read = false;

                for (Iterator<Attribute> iterator = event.asStartElement().getAttributes(); iterator
                        .hasNext();) {
                    Attribute attribute = iterator.next();

                    if (attribute.getValue().equals(attributeValue)) {
                        read = true;
                        break;
                    }
                }
            }

            break;
        }
        case XMLStreamConstants.CHARACTERS: {
            if (read) {
                characters.append(event.asCharacters().getData());
            }
            break;
        }
        case XMLStreamConstants.END_ELEMENT: {
            if (read) {
                elementValues.add(characters.toString());
                characters.setLength(0);
            }

            read = false;
            break;
        }
        default: {
            // Ignore
            break;
        }
        }
    }

    return elementValues;
}

From source file:Main.java

/**
 * /*ww  w .j a  v a  2 s  .  com*/
 * @param elementName
 * @param is
 * @param onlyValues
 * @return Collection
 * @throws XMLStreamException
 * @throws UnsupportedEncodingException
 */
public static Collection<String> getElements(final String elementName, final InputStream is,
        final boolean onlyValues) throws XMLStreamException, UnsupportedEncodingException {
    final Collection<String> elements = new ArrayList<>();
    final ByteArrayOutputStream os = new ByteArrayOutputStream();
    final XMLEventReader reader = XMLInputFactory.newInstance()
            .createXMLEventReader(new InputStreamReader(is, Charset.defaultCharset().name()));
    final XMLEventWriter writer = XMLOutputFactory.newInstance()
            .createXMLEventWriter(new OutputStreamWriter(os, Charset.defaultCharset().name()));
    boolean read = false;
    String characters = null;

    while (reader.peek() != null) {
        final XMLEvent event = (XMLEvent) reader.next();

        switch (event.getEventType()) {
        case XMLStreamConstants.START_DOCUMENT:
        case XMLStreamConstants.END_DOCUMENT: {
            // Ignore.
            break;
        }
        case XMLStreamConstants.START_ELEMENT: {
            read = read || elementName.equals(event.asStartElement().getName().getLocalPart());

            if (read && !onlyValues) {
                writer.add(event);
            }

            break;
        }
        case XMLStreamConstants.ATTRIBUTE: {
            if (read && !onlyValues) {
                writer.add(event);
            }
            break;
        }
        case XMLStreamConstants.CHARACTERS: {
            if (read && !onlyValues) {
                writer.add(event);
            }
            characters = event.asCharacters().getData();
            break;
        }
        case XMLStreamConstants.END_ELEMENT: {
            if (read && !onlyValues) {
                writer.add(event);
            }
            if (elementName.equals(event.asEndElement().getName().getLocalPart())) {
                writer.flush();

                if (characters != null) {
                    elements.add(characters);
                }

                os.reset();
                read = false;
            }
            break;
        }
        default: {
            // Ignore
            break;
        }
        }
    }

    return elements;
}

From source file:Main.java

/**
 * Compares two {@link XMLEvent} instances. This method delegates actual
 * matching to the appropriate overloaded method.
 * /*from  w  w  w.j  ava  2 s  .  co m*/
 * @param a
 *            The first event.
 * @param b
 *            The second event.
 * @return <code>true</code> if the events match, <code>false</code>
 *         otherwise.
 */
public static boolean eventsMatch(XMLEvent a, XMLEvent b) {

    if (a == b) {

        return true;

    } else if (a == null || b == null) {

        return false;

    } else if (a.getEventType() == b.getEventType()) {

        switch (a.getEventType()) {

        case XMLEvent.START_ELEMENT:
            return eventsMatch(a.asStartElement(), b.asStartElement());

        case XMLEvent.END_ELEMENT:
            return eventsMatch(a.asEndElement(), b.asEndElement());

        case XMLEvent.CDATA:
        case XMLEvent.SPACE:
        case XMLEvent.CHARACTERS:
            return eventsMatch(a.asCharacters(), b.asCharacters());

        case XMLEvent.COMMENT:
            return eventsMatch((Comment) a, (Comment) b);

        case XMLEvent.ENTITY_REFERENCE:
            return eventsMatch((EntityReference) a, (EntityReference) b);

        case XMLEvent.ATTRIBUTE:
            return eventsMatch((Attribute) a, (Attribute) b);

        case XMLEvent.NAMESPACE:
            return eventsMatch((Namespace) a, (Namespace) b);

        case XMLEvent.START_DOCUMENT:
            return eventsMatch((StartDocument) a, (StartDocument) b);

        case XMLEvent.END_DOCUMENT:
            return eventsMatch((EndDocument) a, (EndDocument) b);

        case XMLEvent.PROCESSING_INSTRUCTION:
            return eventsMatch((ProcessingInstruction) a, (ProcessingInstruction) b);

        case XMLEvent.DTD:
            return eventsMatch((DTD) a, (DTD) b);

        case XMLEvent.ENTITY_DECLARATION:
            return eventsMatch((EntityDeclaration) a, (EntityDeclaration) b);

        case XMLEvent.NOTATION_DECLARATION:
            return eventsMatch((NotationDeclaration) a, (NotationDeclaration) b);

        }

    }

    return false;

}

From source file:Main.java

public boolean accept(XMLEvent event) {
    return accept(event.getEventType());
}