content: /*
   *  This file is part of AndroidIDE.
   *
   *  AndroidIDE is free software: you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation, either version 3 of the License, or
   *  (at your option) any later version.
   *
   *  AndroidIDE 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 for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *   along with AndroidIDE.  If not, see <https://www.gnu.org/licenses/>.
   */
  
  /*
   * 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 jaxp.sun.org.apache.xerces.internal.impl;
  
  import jaxp.xml.stream.Location;
  import jaxp.xml.stream.XMLStreamReader;
  import jaxp.xml.stream.StreamFilter;
  import jaxp.xml.stream.XMLStreamException;
  import jaxp.xml.namespace.NamespaceContext;
  import jaxp.xml.namespace.QName;
  import jaxp.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 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 Location getLocation() {
          return fStreamReader.getLocation();
      }
  
      /**
       *
       * @return
       */
      public QName getName() {
          return fStreamReader.getName();
      }
  
      /**
       *
       * @return
       */
      public 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);
      }
  }
  