xmlschemavalidator.java

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

        
        // this is included for the convenience of handleEndElement
        protected XMLString fDefaultValue;
        
        // Validation features
        protected boolean fDynamicValidation = false;
        protected boolean fSchemaDynamicValidation = false;
        protected boolean fDoValidation = false;
        protected boolean fFullChecking = false;
        protected boolean fNormalizeData = true;
        protected boolean fSchemaElementDefault = true;
        protected boolean fAugPSVI = true;
        protected boolean fIdConstraint = false;
        protected boolean fIgnoreXsiSchemaLocationHints = false;
        protected boolean fTurnIgnorableCharactersIntoIgnorableWhitespaces = false;
        /** Schema type: None, DTD, Schema */
        private String fSchemaType = null;
        
        // to indicate whether we are in the scope of entity reference or CData
        protected boolean fEntityRef = false;
        protected boolean fInCDATA = false;
        
        // properties
        
        /** Symbol table. */
        protected SymbolTable fSymbolTable;
        
        /**
         * While parsing a document, keep the location of the document.
         */
        private XMLLocator fLocator;
        
        /**
         * A wrapper of the standard error reporter. We'll store all schema errors
         * in this wrapper object, so that we can get all errors (error codes) of
         * a specific element. This is useful for PSVI.
         */
        protected final class XSIErrorReporter {
            
            // the error reporter property
            XMLErrorReporter fErrorReporter;
            
            // store error codes; starting position of the errors for each element;
            // number of element (depth); and whether to record error
            Vector fErrors = new Vector(INITIAL_STACK_SIZE, INC_STACK_SIZE);
            int[] fContext = new int[INITIAL_STACK_SIZE];
            int fContextCount;
            
            // set the external error reporter, clear errors
            public void reset(XMLErrorReporter errorReporter) {
                fErrorReporter = errorReporter;
                fErrors.removeAllElements();
                fContextCount = 0;
            }
            
            // should be called when starting process an element or an attribute.
            // store the starting position for the current context
            public void pushContext() {
                if (!fAugPSVI)
                    return;
                // resize array if necessary
                if (fContextCount == fContext.length) {
                    int newSize = fContextCount + INC_STACK_SIZE;
                    int[] newArray = new int[newSize];
                    System.arraycopy(fContext, 0, newArray, 0, fContextCount);
                    fContext = newArray;
                }
                
                fContext[fContextCount++] = fErrors.size();
            }
            
            // should be called on endElement: get all errors of the current element
            public String[] popContext() {
                if (!fAugPSVI)
                    return null;
                // get starting position of the current element
                int contextPos = fContext[--fContextCount];
                // number of errors of the current element
                int size = fErrors.size() - contextPos;
                // if no errors, return null
                if (size == 0)
                    return null;
                // copy errors from the list to an string array
                String[] errors = new String[size];
                for (int i = 0; i < size; i++) {
                    errors[i] = (String) fErrors.elementAt(contextPos + i);
                }
                // remove errors of the current element
                fErrors.setSize(contextPos);
                return errors;
            }
            
            // should be called when an attribute is done: get all errors of
            // this attribute, but leave the errors to the containing element
            // also called after an element was strictly assessed.
            public String[] mergeContext() {
                if (!fAugPSVI)
                    return null;
                // get starting position of the current element
                int contextPos = fContext[--fContextCount];
                // number of errors of the current element
                int size = fErrors.size() - contextPos;
                // if no errors, return null
                if (size == 0)
                    return null;
                // copy errors from the list to an string array
                String[] errors = new String[size];
                for (int i = 0; i < size; i++) {
                    errors[i] = (String) fErrors.elementAt(contextPos + i);
                }
                // don't resize the vector: leave the errors for this attribute
                // to the containing element
                return errors;
            }
            
            public void reportError(String domain, String key, Object[] arguments, short severity)
            throws XNIException {
                fErrorReporter.reportError(domain, key, arguments, severity);
                fErrors.addElement(key);
            } // reportError(String,String,Object[],short)
            
            public void reportError(
            XMLLocator location,
            String domain,
            String key,
            Object[] arguments,
            short severity)
            throws XNIException {
                fErrorReporter.reportError(location, domain, key, arguments, severity);
                fErrors.addElement(key);
            } // reportError(XMLLocator,String,String,Object[],short)
        }
        
        /** Error reporter. */
        protected final XSIErrorReporter fXSIErrorReporter = new XSIErrorReporter();
        
        /** Entity resolver */
        protected XMLEntityResolver fEntityResolver;
        
        // updated during reset
        protected ValidationManager fValidationManager = null;
        protected ValidationState fValidationState = new ValidationState();
        protected XMLGrammarPool fGrammarPool;
        
        // schema location property values
        protected String fExternalSchemas = null;
        protected String fExternalNoNamespaceSchema = null;
        
        //JAXP Schema Source property
        protected Object fJaxpSchemaSource = null;
        
        //ResourceIdentifier for use in calling EntityResolver
        final XMLResourceIdentifierImpl fResourceIdentifier = new XMLResourceIdentifierImpl();
        
        /** Schema Grammar Description passed,  to give a chance to application to supply the Grammar */
        protected final XSDDescription fXSDDescription = new XSDDescription();
        protected final Hashtable fLocationPairs = new Hashtable();
        
        
        
        
        // handlers
        
        /** Document handler. */
        protected XMLDocumentHandler fDocumentHandler;
        
        protected XMLDocumentSource fDocumentSource;
        
        //
        // XMLComponent methods
        //
        
        /**
         * Returns a list of feature identifiers that are recognized by
         * this component. This method may return null if no features
         * are recognized by this component.
         */
        public String[] getRecognizedFeatures() {
            return (String[]) (RECOGNIZED_FEATURES.clone());
        } // getRecognizedFeatures():String[]
        
        /**
         * Sets the state of a feature. This method is called by the component
         * manager any time after reset when a feature changes state.
         * <p>
         * <strong>Note:</strong> Components should silently ignore features
         * that do not affect the operation of the component.
         *
         * @param featureId The feature identifier.
         * @param state     The state of the feature.
         *
         * @throws SAXNotRecognizedException The component should not throw
         *                                   this exception.
         * @throws SAXNotSupportedException The component should not throw
         *                                  this exception.
         */
        public void setFeature(String featureId, boolean state) throws XMLConfigurationException {
        } // setFeature(String,boolean)
        
        /**
         * Returns a list of property identifiers that are recognized by
         * this component. This method may return null if no properties
         * are recognized by this component.
         */
        public String[] getRecognizedProperties() {
            return (String[])(RECOGNIZED_PROPERTIES.clone());
        } // getRecognizedProperties():String[]
        
        /**
         * Sets the value of a property. This method is called by the component
         * manager any time after reset when a property changes value.
         * <p>
         * <strong>Note:</strong> Components should silently ignore properties
         * that do not affect the operation of the component.
         *
         * @param propertyId The property identifier.
         * @param value      The value of the property.
         *
         * @throws SAXNotRecognizedException The component should not throw
         *                                   this exception.
         * @throws SAXNotSupportedException The component should not throw
         *                                  this exception.
         */
        public void setProperty(String propertyId, Object value) throws XMLConfigurationException {
        } // setProperty(String,Object)
        
        /**
         * Returns the default state for a feature, or null if this
         * component does not want to report a default value for this
         * feature.
         *
         * @param featureId The feature identifier.
         *
         * @since Xerces 2.2.0
         */
        public Boolean getFeatureDefault(String featureId) {
            for (int i = 0; i < RECOGNIZED_FEATURES.length; i++) {
                if (RECOGNIZED_FEATURES[i].equals(featureId)) {
                    return FEATURE_DEFAULTS[i];
                }
            }
            return null;
        } // getFeatureDefault(String):Boolean
        
        /**
         * Returns the default state for a property, or null if this
         * component does not want to report a default value for this
         * property.
         *
         * @param propertyId The property identifier.
         *
         * @since Xerces 2.2.0
         */
        public Object getPropertyDefault(String propertyId) {
            for (int i = 0; i < RECOGNIZED_PROPERTIES.length; i++) {
                if (RECOGNIZED_PROPERTIES[i].equals(propertyId)) {
                    return PROPERTY_DEFAULTS[i];
                }
            }
            return null;
        } // getPropertyDefault(String):Object
        
        //
        // XMLDocumentSource methods
        //
        
        /** Sets the document handler to receive information about the document. */
        public void setDocumentHandler(XMLDocumentHandler documentHandler) {
            fDocumentHandler = documentHandler;
        } // setDocumentHandler(XMLDocumentHandler)
        
        /** Returns the document handler */
        public XMLDocumentHandler getDocumentHandler() {
            return fDocumentHandler;
        } // setDocumentHandler(XMLDocumentHandler)
        
        //
        // XMLDocumentHandler methods
        //
        
        /** Sets the document source */
        public void setDocumentSource(XMLDocumentSource source){
            fDocumentSource = source;
        } // setDocumentSource
        
        /** Returns the document source */
        public XMLDocumentSource getDocumentSource(){
            return fDocumentSource;
        } // getDocumentSource
        
        /**
         * The start of the document.
         *
         * @param locator The system identifier of the entity if the entity
         *                 is external, null otherwise.
         * @param encoding The auto-detected IANA encoding name of the entity
         *                 stream. This value will be null in those situations
         *                 where the entity encoding is not auto-detected (e.g.
         *                 internal entities or a document entity that is
         *                 parsed from a java.io.Reader).
         * @param namespaceContext
         *                 The namespace context in effect at the
         *                 start of this document.
         *                 This object represents the current context.
         *                 Implementors of this class are responsible
         *                 for copying the namespace bindings from the
         *                 the current context (and its parent contexts)
         *                 if that information is important.
         * @param augs     Additional information that may include infoset augmentations
         *
         * @throws XNIException Thrown by handler to signal an error.