Java example source code file (XMLStreamFilterImpl.java)

This example Java source code file (XMLStreamFilterImpl.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

illegalstateexception, object, qname, string, the, xml, xmlstreamexception, xmlstreamfilterimpl, xmlstreamreader

The XMLStreamFilterImpl.java Java example source code

/*
 * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package com.sun.org.apache.xerces.internal.impl;

import javax.xml.XMLConstants;
import javax.xml.stream.Location;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.StreamFilter;
import javax.xml.stream.XMLStreamException;
import javax.xml.namespace.QName;
import javax.xml.stream.events.XMLEvent;


/**
 *
 * @author Joe Wang:
 * This is a rewrite of the original class. The focus is on removing caching, and make the filtered
 * stream reader more compatible with those in other implementations. Note however, that this version
 * will not solve all the issues related to the undefined condition in the spec. The priority is
 * to pass the TCK. Issues arising due to the requirement, that is, (1) should it initiate at BEGIN_DOCUMENT
 * or an accepted event; (2) should hasNext() advance the underlining stream in order to find an acceptable
 * event, would have to wait until 1.1 of StAX in which the filtered stream reader would be defined more clearly.
 */

public class XMLStreamFilterImpl implements javax.xml.stream.XMLStreamReader {

    private StreamFilter fStreamFilter = null;
    private XMLStreamReader fStreamReader = null;
    private int fCurrentEvent;
    private boolean fEventAccepted = false;

    /**the very issue around a long discussion. but since we must pass the TCK, we have to allow
     * hasNext() to advance the underlining stream in order to find the next acceptable event
     */
    private boolean fStreamAdvancedByHasNext = false;
    /** Creates a new instance of XMLStreamFilterImpl */

    public XMLStreamFilterImpl(XMLStreamReader reader,StreamFilter filter){
        fStreamReader = reader;
        this.fStreamFilter = filter;

        //this is debatable to initiate at an acceptable event,
        //but it's neccessary in order to pass the TCK and yet avoid skipping element
        try {
            if (fStreamFilter.accept(fStreamReader)) {
                fEventAccepted = true;
            } else {
                findNextEvent();
            }
        }catch(XMLStreamException xs){
            System.err.println("Error while creating a stream Filter"+xs);
        }
    }

    /**
     *
     * @param sf
     */
    protected void setStreamFilter(StreamFilter sf){
        this.fStreamFilter = sf;
    }

    /**
     *
     * @return
     * @throws XMLStreamException
     */
    public int next() throws XMLStreamException {
        if (fStreamAdvancedByHasNext && fEventAccepted) {
            fStreamAdvancedByHasNext = false;
            return fCurrentEvent;
        }
        int event = findNextEvent();
        if (event != -1) {
            return event;
        }

        throw new IllegalStateException("The stream reader has reached the end of the document, or there are no more "+
                                    " items to return");
    }
    /**
     *
     * @throws XMLStreamException
     * @return
     */
    public int nextTag() throws XMLStreamException {
        if (fStreamAdvancedByHasNext && fEventAccepted &&
                (fCurrentEvent == XMLEvent.START_ELEMENT || fCurrentEvent == XMLEvent.START_ELEMENT)) {
            fStreamAdvancedByHasNext = false;
            return fCurrentEvent;
        }

        int event = findNextTag();
        if (event != -1) {
            return event;
        }
        throw new IllegalStateException("The stream reader has reached the end of the document, or there are no more "+
                                    " items to return");
    }

    /**
     *
     * @throws XMLStreamException
     * @return
     */
    public boolean hasNext() throws XMLStreamException {
        if (fStreamReader.hasNext()) {
            if (!fEventAccepted) {
                if ((fCurrentEvent = findNextEvent()) == -1) {
                    return false;
                } else {
                    fStreamAdvancedByHasNext = true;
                }
            }
            return true;
        }
        return false;
    }

    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 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;
    }
    /**
     *
     * @throws XMLStreamException
     */
    public void close() throws XMLStreamException {
        fStreamReader.close();
    }

    /**
     *
     * @return
     */
    public int getAttributeCount() {
        return fStreamReader.getAttributeCount();
    }

    /**
     *
     * @param index
     * @return
     */
    public QName getAttributeName(int index) {
        return fStreamReader.getAttributeName(index);
    }

    /**
     *
     * @param index
     * @return
     */
    public String getAttributeNamespace(int index) {
        return fStreamReader.getAttributeNamespace(index);
    }

    /**
     *
     * @param index
     * @return
     */
    public String getAttributePrefix(int index) {
        return fStreamReader.getAttributePrefix(index);
    }

    /**
     *
     * @param index
     * @return
     */
    public String getAttributeType(int index) {
        return fStreamReader.getAttributeType(index);
    }

    /**
     *
     * @param index
     * @return
     */
    public String getAttributeValue(int index) {
        return fStreamReader.getAttributeValue(index);
    }

    /**
     *
     * @param namespaceURI
     * @param localName
     * @return
     */
    public String getAttributeValue(String namespaceURI, String localName) {
        return fStreamReader.getAttributeValue(namespaceURI,localName);
    }

    /**
     *
     * @return
     */
    public String getCharacterEncodingScheme() {
        return fStreamReader.getCharacterEncodingScheme();
    }

    /**
     *
     * @throws XMLStreamException
     * @return
     */
    public String getElementText() throws XMLStreamException {
        return fStreamReader.getElementText();
    }

    /**
     *
     * @return
     */
    public String getEncoding() {
        return fStreamReader.getEncoding();
    }

    /**
     *
     * @return
     */
    public int getEventType() {
        return fStreamReader.getEventType();
    }

    /**
     *
     * @return
     */
    public String getLocalName() {
        return fStreamReader.getLocalName();
    }

    /**
     *
     * @return
     */
    public javax.xml.stream.Location getLocation() {
        return fStreamReader.getLocation();
    }

    /**
     *
     * @return
     */
    public javax.xml.namespace.QName getName() {
        return fStreamReader.getName();
    }

    /**
     *
     * @return
     */
    public javax.xml.namespace.NamespaceContext getNamespaceContext() {
        return fStreamReader.getNamespaceContext();
    }

    /**
     *
     * @return
     */
    public int getNamespaceCount() {
        return fStreamReader.getNamespaceCount();
    }

    /**
     *
     * @param index
     * @return
     */
    public String getNamespacePrefix(int index) {
        return fStreamReader.getNamespacePrefix(index);
    }

    /**
     *
     * @return
     */
    public String getNamespaceURI() {
        return fStreamReader.getNamespaceURI();
    }

    /**
     *
     * @param index
     * @return
     */
    public String getNamespaceURI(int index) {
        return fStreamReader.getNamespaceURI(index);
    }

    /**
     *
     * @param prefix
     * @return
     */
    public String getNamespaceURI(String prefix) {
        return fStreamReader.getNamespaceURI(prefix);
    }

    /**
     *
     * @return
     */
    public String getPIData() {
        return fStreamReader.getPIData();
    }

    /**
     *
     * @return
     */
    public String getPITarget() {
        return fStreamReader.getPITarget();
    }

    /**
     *
     * @return
     */
    public String getPrefix() {
        return fStreamReader.getPrefix();
    }

    /**
     *
     * @param name
     * @throws IllegalArgumentException
     * @return
     */
    public Object getProperty(java.lang.String name) throws java.lang.IllegalArgumentException {
        return fStreamReader.getProperty(name);
    }

    /**
     *
     * @return
     */
    public String getText() {
        return fStreamReader.getText();
    }

    /**
     *
     * @return
     */
    public char[] getTextCharacters() {
        return fStreamReader.getTextCharacters();
    }

    /**
     *
     * @param sourceStart
     * @param target
     * @param targetStart
     * @param length
     * @throws XMLStreamException
     * @return
     */
    public int getTextCharacters(int sourceStart, char[] target, int targetStart, int length) throws XMLStreamException {
        return fStreamReader.getTextCharacters(sourceStart, target,targetStart,length);
    }

    /**
     *
     * @return
     */
    public int getTextLength() {
        return fStreamReader.getTextLength();
    }

    /**
     *
     * @return
     */
    public int getTextStart() {
        return fStreamReader.getTextStart();
    }

    /**
     *
     * @return
     */
    public String getVersion() {
        return fStreamReader.getVersion();
    }

    /**
     *
     * @return
     */
    public boolean hasName() {
        return fStreamReader.hasName();
    }

    /**
     *
     * @return
     */
    public boolean hasText() {
        return fStreamReader.hasText();
    }

    /**
     *
     * @return
     * @param index
     */
    public boolean isAttributeSpecified(int index) {
        return fStreamReader.isAttributeSpecified(index);
    }

    /**
     *
     * @return
     */
    public boolean isCharacters() {
        return fStreamReader.isCharacters();
    }

    /**
     *
     * @return
     */
    public boolean isEndElement() {
        return fStreamReader.isEndElement();
    }

    /**
     *
     * @return
     */
    public boolean isStandalone() {
        return fStreamReader.isStandalone();
    }

    /**
     *
     * @return
     */
    public boolean isStartElement() {
        return fStreamReader.isStartElement();
    }

    /**
     *
     * @return
     */
    public boolean isWhiteSpace() {
        return fStreamReader.isWhiteSpace();
    }


    /**
     *
     * @param type
     * @param namespaceURI
     * @param localName
     * @throws XMLStreamException
     */
    public void require(int type, String namespaceURI, String localName) throws XMLStreamException {
        fStreamReader.require(type,namespaceURI,localName);
    }

    /**
     *
     * @return
     */
    public boolean standaloneSet() {
        return fStreamReader.standaloneSet();
    }

    /**
     *
     * @param index
     * @return
     */
    public String getAttributeLocalName(int index){
        return fStreamReader.getAttributeLocalName(index);
    }
}