xmlstreamreaderimpl.java

java1.6众多例子参考

    
    /**
     * @return
     */
    public String getNamespaceURI() {
        //doesn't take care of Attribute as separte event
        if(fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT){
            return fScanner.getElementQName().uri ;
        }
        return null ;
    }//getNamespaceURI
    
    /** Get the data section of a processing instruction
     * @return the data or null
     */
    
    public String getPIData() {
        if( fEventType == XMLEvent.PROCESSING_INSTRUCTION){
            return fScanner.getPIData().toString();
        }
        else throw new java.lang.IllegalStateException("Current state of the parser is " + getEventTypeString(fEventType) +
        " But Expected state is " + XMLEvent.PROCESSING_INSTRUCTION  ) ;
    }//getPIData
    
    
    /** Get the target of a processing instruction
     * @return the target or null
     */
    public String getPITarget() {
        if( fEventType == XMLEvent.PROCESSING_INSTRUCTION){
            return fScanner.getPITarget();
        }
        else throw new java.lang.IllegalStateException("Current state of the parser is " + getEventTypeString(fEventType) +
        " But Expected state is " + XMLEvent.PROCESSING_INSTRUCTION  ) ;
        
    }//getPITarget
    
    
    /**
     * @return
     */
    public String getPrefix() {
        //doesn't take care of Attribute as separte event
        if(fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT){
            return fScanner.getElementQName().prefix ;
        }
        return null ;
    }//getPrefix()
    
    
    
    /**
     * @return
     */
    public char[] getTextCharacters() {
        if( fEventType == XMLEvent.CHARACTERS || fEventType == XMLEvent.COMMENT
                 || fEventType == XMLEvent.CDATA || fEventType == XMLEvent.SPACE){
             return fScanner.getCharacterData().ch;
         } else{
             throw new IllegalStateException("Current state = " + getEventTypeString(fEventType)
             + " is not among the states " + getEventTypeString(XMLEvent.CHARACTERS) + " , "
                     + getEventTypeString(XMLEvent.COMMENT) + " , " + getEventTypeString(XMLEvent.CDATA)
                     + " , " + getEventTypeString(XMLEvent.SPACE) +" valid for getTextCharacters() " ) ;
         }
    }
    
    /**
     * @return
     */
    public int getTextLength() {
        if( fEventType == XMLEvent.CHARACTERS || fEventType == XMLEvent.COMMENT
                 || fEventType == XMLEvent.CDATA || fEventType == XMLEvent.SPACE){
             return fScanner.getCharacterData().length;
         } else{
             throw new IllegalStateException("Current state = " + getEventTypeString(fEventType) 
             + " is not among the states " + getEventTypeString(XMLEvent.CHARACTERS) + " , " 
                     + getEventTypeString(XMLEvent.COMMENT) + " , " + getEventTypeString(XMLEvent.CDATA) 
                     + " , " + getEventTypeString(XMLEvent.SPACE) +" valid for getTextLength() " ) ;
         }
        
   }
    
    /**
     * @return
     */
    public int getTextStart() {
        if( fEventType == XMLEvent.CHARACTERS || fEventType == XMLEvent.COMMENT || fEventType == XMLEvent.CDATA || fEventType == XMLEvent.SPACE){
             return  fScanner.getCharacterData().offset;
         } else{
             throw new IllegalStateException("Current state = " + getEventTypeString(fEventType)
             + " is not among the states " + getEventTypeString(XMLEvent.CHARACTERS) + " , "
                     + getEventTypeString(XMLEvent.COMMENT) + " , " + getEventTypeString(XMLEvent.CDATA)
                     + " , " + getEventTypeString(XMLEvent.SPACE) +" valid for getTextStart() " ) ;
         }
    }
    
    /**
     * @return
     */
    public String getValue() {
        if(fEventType == XMLEvent.PROCESSING_INSTRUCTION){
            return fScanner.getPIData().toString();
        } else if(fEventType == XMLEvent.COMMENT){
            return fScanner.getComment();
        } else if(fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT){
            return fScanner.getElementQName().localpart ;
        } else if(fEventType == XMLEvent.CHARACTERS){
            return fScanner.getCharacterData().toString();
        }
        return null;
    }//getValue()
    
    /** Get the XML language version of the current document being parsed */
    public String getVersion() {
        return fEntityScanner.getXMLVersion(); 
    }
    
    /**
     * @return
     */
    public boolean hasAttributes() {
        return fScanner.getAttributeIterator().getLength() > 0 ? true : false ;
    }
    
    /** this Funtion returns true if the current event has name */
    public boolean hasName() {
        if(fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT
        || fEventType == XMLEvent.ENTITY_REFERENCE || fEventType == XMLEvent.PROCESSING_INSTRUCTION) {
            return true;
        }  else {
            return false;
        }
    }//hasName()
    
    /**
     * @throws XMLStreamException
     * @return
     */
    public boolean hasNext() throws XMLStreamException {
        //we can check in scanners if the scanner state is not set to 
        //terminating, we still have more events.
        return fEventType != XMLEvent.END_DOCUMENT;
    }
    
    /**
     * @return
     */
    public boolean hasValue() {
        if(fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.END_ELEMENT
        || fEventType == XMLEvent.ENTITY_REFERENCE || fEventType == XMLEvent.PROCESSING_INSTRUCTION
        || fEventType == XMLEvent.COMMENT || fEventType == XMLEvent.CHARACTERS) {
            return true;
        } else {
            return false;
        }
        
    }
    
    /**
     * @return
     */
    public boolean isEndElement() {
        return fEventType == XMLEvent.END_ELEMENT;
    }
    
    /**
     * @return
     */
    public boolean isStandalone() {
        return fScanner.isStandAlone();
    }
    
    /**
     * @return
     */
    public boolean isStartElement() {
        return fEventType == XMLEvent.START_ELEMENT;
    }
    
    /**
     *  Returns true if the cursor points to a character data event that consists of all whitespace
     *  Application calling this method needs to cache the value and avoid calling this method again
     *  for the same event.
     * @return
     */
    public boolean isWhiteSpace() {
        if(isCharacters() || (fEventType == XMLStreamConstants.CDATA)){
            char [] ch = this.getTextCharacters();
            final int start = this.getTextStart();
            final int end = start + this.getTextLength();
            for (int i = start; i < end; i++){
                if(!XMLChar.isSpace(ch[i])){
                    return false;
                }
            }
            return true;
        }
        return false;
    }
    
    
    
    /**
     * @throws XMLStreamException
     * @return
     */
    public int next() throws XMLStreamException {

        try {
            fEventType = fScanner.next();

            if (versionStr == null) {
                versionStr = getVersion();
            }

            if (fEventType == XMLStreamConstants.START_DOCUMENT
                    && versionStr != null
                    && versionStr.equals("1.1")) {
                switchToXML11Scanner();
            }

            return fEventType;
        } catch (IOException ex) {
            // if this error occured trying to resolve the external DTD subset
            // and IS_VALIDATING == false, then this is not an XML error
            if (fScanner.fScannerState == fScanner.SCANNER_STATE_DTD_EXTERNAL) {
                Boolean isValidating = (Boolean) fPropertyManager.getProperty(
                        XMLInputFactory.IS_VALIDATING);
                if (isValidating != null
                        && !isValidating.booleanValue()) {
                    // ignore the error, set scanner to known state                    
                    fEventType = XMLEvent.DTD;
                    fScanner.setScannerState(fScanner.SCANNER_STATE_PROLOG);
                    fScanner.setDriver(fScanner.fPrologDriver);
                    if (fDTDDecl == null
                            || fDTDDecl.length() == 0) {
                        fDTDDecl = "<!-- "
                                + "Exception scanning External DTD Subset.  "
                                + "True contents of DTD cannot be determined.  "
                                + "Processing will continue as XMLInputFactory.IS_VALIDATING == false."
                                + " -->";
                    }
                    return XMLEvent.DTD;
                }
            }

            // else real error
            throw new XMLStreamException(ex.getMessage(), getLocation(), ex);
        } catch (XNIException ex) {
            throw new XMLStreamException(
                    ex.getMessage(),
                    getLocation(),
                    ex.getException());
        }
    } //next()

    private void switchToXML11Scanner() throws IOException{
        
        int oldEntityDepth = fScanner.fEntityDepth;
        com.sun.org.apache.xerces.internal.xni.NamespaceContext oldNamespaceContext = fScanner.fNamespaceContext;
        
        fScanner = new XML11NSDocumentScannerImpl();
        
        //get the new scanner state to old scanner's previous state
        fScanner.reset(fPropertyManager);
        fScanner.setPropertyManager(fPropertyManager);
        fEntityScanner = (XMLEntityScanner)fEntityManager.getEntityScanner()  ;
        fEntityManager.fCurrentEntity.mayReadChunks = true;
        fScanner.setScannerState(XMLEvent.START_DOCUMENT);
        
        fScanner.fEntityDepth = oldEntityDepth;
        fScanner.fNamespaceContext = oldNamespaceContext;
        fEventType = fScanner.next();
    }
    
    
    
    final static String getEventTypeString(int eventType) {
        switch (eventType){
            case XMLEvent.START_ELEMENT:
                return "START_ELEMENT";
            case XMLEvent.END_ELEMENT:
                return "END_ELEMENT";
            case XMLEvent.PROCESSING_INSTRUCTION:
                return "PROCESSING_INSTRUCTION";
            case XMLEvent.CHARACTERS:
                return "CHARACTERS";
            case XMLEvent.COMMENT:
                return "COMMENT";
            case XMLEvent.START_DOCUMENT:
                return "START_DOCUMENT";
            case XMLEvent.END_DOCUMENT:
                return "END_DOCUMENT";
            case XMLEvent.ENTITY_REFERENCE:
                return "ENTITY_REFERENCE";
            case XMLEvent.ATTRIBUTE:
                return "ATTRIBUTE";
            case XMLEvent.DTD:
                return "DTD";
            case XMLEvent.CDATA:
                return "CDATA";
            case XMLEvent.SPACE:
                return "SPACE";
        }
        return "UNKNOWN_EVENT_TYPE, " + String.valueOf(eventType);
    }
    
    /** Returns the count of attributes on this START_ELEMENT,
     * this method is only valid on a START_ELEMENT or ATTRIBUTE.  This
     * count excludes namespace definitions.  Attribute indices are
     * zero-based.
     * @return returns the number of attributes
     * @throws IllegalStateException if this is not a START_ELEMENT or ATTRIBUTE
     */
    public int getAttributeCount() {
        //xxx: recognize SAX properties namespace, namespace-prefix to get XML Namespace declarations
        //does length includes namespace declarations ?
        
        //State should be either START_ELEMENT or ATTRIBUTE
        if( fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.ATTRIBUTE) {
            return fScanner.getAttributeIterator().getLength() ;
        } else{
            throw new java.lang.IllegalStateException( "Current state is not among the states " 
                     + getEventTypeString(XMLEvent.START_ELEMENT) + " , " 
                     + getEventTypeString(XMLEvent.ATTRIBUTE)
                     + "valid for getAttributeCount()") ;
        }
    }//getAttributeCount
    
    /** Returns the localName of the attribute at the provided
     * index
     * @param index the position of the attribute
     * @return the localName of the attribute
     * @throws IllegalStateException if this is not a START_ELEMENT or ATTRIBUTE
     */
    public QName getAttributeName(int index) {
        //State should be either START_ELEMENT or ATTRIBUTE
        if( fEventType == XMLEvent.START_ELEMENT || fEventType == XMLEvent.ATTRIBUTE) {