xmlschemavalidator.java

来自「JAVA的一些源码 JAVA2 STANDARD EDITION DEVELO」· Java 代码 · 共 1,551 行 · 第 1/5 页

         */
        public void startDocument(
        XMLLocator locator,
        String encoding,
        NamespaceContext namespaceContext,
        Augmentations augs)
        throws XNIException {
            
            fValidationState.setNamespaceSupport(namespaceContext);
            fState4XsiType.setNamespaceSupport(namespaceContext);
            fState4ApplyDefault.setNamespaceSupport(namespaceContext);
            fLocator = locator;
            
            handleStartDocument(locator, encoding);
            // call handlers
            if (fDocumentHandler != null) {
                fDocumentHandler.startDocument(locator, encoding, namespaceContext, augs);
            }
            
        } // startDocument(XMLLocator,String)
        
        /**
         * Notifies of the presence of an XMLDecl line in the document. If
         * present, this method will be called immediately following the
         * startDocument call.
         *
         * @param version    The XML version.
         * @param encoding   The IANA encoding name of the document, or null if
         *                   not specified.
         * @param standalone The standalone value, or null if not specified.
         * @param augs     Additional information that may include infoset augmentations
         *
         * @throws XNIException Thrown by handler to signal an error.
         */
        public void xmlDecl(String version, String encoding, String standalone, Augmentations augs)
        throws XNIException {
            
            // call handlers
            if (fDocumentHandler != null) {
                fDocumentHandler.xmlDecl(version, encoding, standalone, augs);
            }
            
        } // xmlDecl(String,String,String)
        
        /**
         * Notifies of the presence of the DOCTYPE line in the document.
         *
         * @param rootElement The name of the root element.
         * @param publicId    The public identifier if an external DTD or null
         *                    if the external DTD is specified using SYSTEM.
         * @param systemId    The system identifier if an external DTD, null
         *                    otherwise.
         * @param augs     Additional information that may include infoset augmentations
         *
         * @throws XNIException Thrown by handler to signal an error.
         */
        public void doctypeDecl(
        String rootElement,
        String publicId,
        String systemId,
        Augmentations augs)
        throws XNIException {
            
            // call handlers
            if (fDocumentHandler != null) {
                fDocumentHandler.doctypeDecl(rootElement, publicId, systemId, augs);
            }
            
        } // doctypeDecl(String,String,String)
        
        /**
         * The start of an element.
         *
         * @param element    The name of the element.
         * @param attributes The element attributes.
         * @param augs     Additional information that may include infoset augmentations
         *
         * @throws XNIException Thrown by handler to signal an error.
         */
        public void startElement(QName element, XMLAttributes attributes, Augmentations augs)
        throws XNIException {
            
            Augmentations modifiedAugs = handleStartElement(element, attributes, augs);
            // call handlers
            if (fDocumentHandler != null) {
                fDocumentHandler.startElement(element, attributes, modifiedAugs );
            }
            
        } // startElement(QName,XMLAttributes, Augmentations)
        
        /**
         * An empty element.
         *
         * @param element    The name of the element.
         * @param attributes The element attributes.
         * @param augs     Additional information that may include infoset augmentations
         *
         * @throws XNIException Thrown by handler to signal an error.
         */
        public void emptyElement(QName element, XMLAttributes attributes, Augmentations augs)
        throws XNIException {
            
            Augmentations modifiedAugs = handleStartElement(element, attributes, augs);
            
            // in the case where there is a {value constraint}, and the element
            // doesn't have any text content, change emptyElement call to
            // start + characters + end
            fDefaultValue = null;
            // fElementDepth == -2 indicates that the schema validator was removed
            // from the pipeline. then we don't need to call handleEndElement.
            if (fElementDepth != -2)
                modifiedAugs = handleEndElement(element, modifiedAugs);
            
            // call handlers
            if (fDocumentHandler != null) {
                if (!fSchemaElementDefault || fDefaultValue == null) {
                    fDocumentHandler.emptyElement(element, attributes, modifiedAugs);
                } else {
                    fDocumentHandler.startElement(element, attributes, modifiedAugs);
                    fDocumentHandler.characters(fDefaultValue, null);
                    fDocumentHandler.endElement(element, modifiedAugs);
                }
            }
        } // emptyElement(QName,XMLAttributes, Augmentations)
        
        /**
         * Character content.
         *
         * @param text The content.
         * @param augs     Additional information that may include infoset augmentations
         *
         * @throws XNIException Thrown by handler to signal an error.
         */
        public void characters(XMLString text, Augmentations augs) throws XNIException {
            
            text = handleCharacters(text);
            // call handlers
            if (fDocumentHandler != null) {
                if (fNormalizeData && fUnionType) {
                    // for union types we can't normalize data
                    // thus we only need to send augs information if any;
                    // the normalized data for union will be send
                    // after normalization is performed (at the endElement())
                    if (augs != null)
                        fDocumentHandler.characters(fEmptyXMLStr, augs);
                } else {
                    if( fTurnIgnorableCharactersIntoIgnorableWhitespaces && isElementOnlyContent() )
                        fDocumentHandler.ignorableWhitespace(text, augs);
                    else
                        fDocumentHandler.characters(text, augs);
                }
            }
            
        } // characters(XMLString)
        
        /**
         * Ignorable whitespace. For this method to be called, the document
         * source must have some way of determining that the text containing
         * only whitespace characters should be considered ignorable. For
         * example, the validator can determine if a length of whitespace
         * characters in the document are ignorable based on the element
         * content model.
         *
         * @param text The ignorable whitespace.
         * @param augs     Additional information that may include infoset augmentations
         *
         * @throws XNIException Thrown by handler to signal an error.
         */
        public void ignorableWhitespace(XMLString text, Augmentations augs) throws XNIException {
            
            handleIgnorableWhitespace(text);
            // call handlers
            if (fDocumentHandler != null) {
                fDocumentHandler.ignorableWhitespace(text, augs);
            }
            
        } // ignorableWhitespace(XMLString)
        
        /**
         * The end of an element.
         *
         * @param element The name of the element.
         * @param augs     Additional information that may include infoset augmentations
         *
         * @throws XNIException Thrown by handler to signal an error.
         */
        public void endElement(QName element, Augmentations augs) throws XNIException {
            
            // in the case where there is a {value constraint}, and the element
            // doesn't have any text content, add a characters call.
            fDefaultValue = null;
            Augmentations modifiedAugs = handleEndElement(element, augs);
            // call handlers
            if (fDocumentHandler != null) {
                if (!fSchemaElementDefault || fDefaultValue == null) {
                    fDocumentHandler.endElement(element, modifiedAugs);
                } else {
                    fDocumentHandler.characters(fDefaultValue, null);
                    fDocumentHandler.endElement(element, modifiedAugs);
                }
            }
        } // endElement(QName, Augmentations)
        
        /**
         * The start of a CDATA section.
         *
         * @param augs     Additional information that may include infoset augmentations
         *
         * @throws XNIException Thrown by handler to signal an error.
         */
        public void startCDATA(Augmentations augs) throws XNIException {
            
            // REVISIT: what should we do here if schema normalization is on??
            fInCDATA = true;
            // call handlers
            if (fDocumentHandler != null) {
                fDocumentHandler.startCDATA(augs);
            }
            
        } // startCDATA()
        
        /**
         * The end of a CDATA section.
         *
         * @param augs     Additional information that may include infoset augmentations
         *
         * @throws XNIException Thrown by handler to signal an error.
         */
        public void endCDATA(Augmentations augs) throws XNIException {
            
            // call handlers
            fInCDATA = false;
            if (fDocumentHandler != null) {
                fDocumentHandler.endCDATA(augs);
            }
            
        } // endCDATA()
        
        /**
         * The end of the document.
         *
         * @param augs     Additional information that may include infoset augmentations
         *
         * @throws XNIException Thrown by handler to signal an error.
         */
        public void endDocument(Augmentations augs) throws XNIException {
            
            handleEndDocument();
            
            // call handlers
            if (fDocumentHandler != null) {
                fDocumentHandler.endDocument(augs);
            }
            fLocator = null;
            
        } // endDocument(Augmentations)
        
        //
        // DOMRevalidationHandler methods
        //
        
        
        
        
        
        public boolean characterData(String data, Augmentations augs) {
            
            fSawText = fSawText || data.length() > 0;
            
            // REVISIT: this methods basically duplicates implementation of
            //          handleCharacters(). We should be able to reuse some code
            
            // if whitespace == -1 skip normalization, because it is a complexType
            // or a union type.
            if (fNormalizeData && fWhiteSpace != -1 && fWhiteSpace != XSSimpleType.WS_PRESERVE) {
                // normalize data
                normalizeWhitespace(data, fWhiteSpace == XSSimpleType.WS_COLLAPSE);
                fBuffer.append(fNormalizedStr.ch, fNormalizedStr.offset, fNormalizedStr.length);
            } else {
                if (fAppendBuffer)
                    fBuffer.append(data);
            }
            
            // When it's a complex type with element-only content, we need to
            // find out whether the content contains any non-whitespace character.
            boolean allWhiteSpace = true;
            if (fCurrentType != null
            && fCurrentType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) {
                XSComplexTypeDecl ctype = (XSComplexTypeDecl)fCurrentType;
                if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_ELEMENT) {
                    // data outside of element content
                    for (int i=0; i< data.length(); i++) {
                        if (!XMLChar.isSpace(data.charAt(i))) {
                            allWhiteSpace = false;
                            fSawCharacters = true;
                            break;
                        }
                    }
                }
            }
            
            return allWhiteSpace;
        }
        
        public void elementDefault(String data){
            // no-op
        }
        
        //
        // XMLDocumentHandler and XMLDTDHandler methods
        //