/*
* 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);
}
}