public XMLGrammarCachingConfiguration() 
{
    //
    // Constructors
    //
        this(fStaticSymbolTable, fStaticGrammarPool, null);
}

Default constructor.

 public XMLGrammarCachingConfiguration(SymbolTable symbolTable) 
{
        this(symbolTable, fStaticGrammarPool, null);
}

Constructs a parser configuration using the specified symbol table.

Parameters:

symbolTable - The symbol table to use.

 public XMLGrammarCachingConfiguration(SymbolTable symbolTable,
    XMLGrammarPool grammarPool) 
{
        this(symbolTable, grammarPool, null);
}

Constructs a parser configuration using the specified symbol table and grammar pool.

REVISIT: Grammar pool will be updated when the new validation engine is implemented.

Parameters:

symbolTable - The symbol table to use.

grammarPool - The grammar pool to use.

 public XMLGrammarCachingConfiguration(SymbolTable symbolTable,
    XMLGrammarPool grammarPool,
    XMLComponentManager parentSettings) 
{
        super(symbolTable, grammarPool, parentSettings);
        // REVISIT:  may need to add some features/properties
        // specific to this configuration at some point...
        // add default recognized features
        // set state for default features
        // add default recognized properties
        // create and register missing components
        fSchemaLoader = new XMLSchemaLoader(fSymbolTable);
        fSchemaLoader.setProperty(XMLGRAMMAR_POOL, fGrammarPool);
        // and set up the DTD loader too:
        fDTDLoader = new XMLDTDLoader(fSymbolTable, fGrammarPool);
}

Constructs a parser configuration using the specified symbol table, grammar pool, and parent settings.

REVISIT: Grammar pool will be updated when the new validation engine is implemented.

Parameters:

symbolTable - The symbol table to use.

grammarPool - The grammar pool to use.

parentSettings - The parent settings.

 protected  void checkFeature(String featureId) throws XMLConfigurationException 
{
        super.checkFeature(featureId);
}

Check a feature. If feature is known and supported, this method simply returns. Otherwise, the appropriate exception is thrown.

 protected  void checkProperty(String propertyId) throws XMLConfigurationException 
{
        super.checkProperty(propertyId);
}

Check a property. If the property is known and supported, this method simply returns. Otherwise, the appropriate exception is thrown.

 public  void clearGrammarPool() 
{
        fGrammarPool.clear();
}

 public  void lockGrammarPool() 
{
        fGrammarPool.lockPool();
}

 DTDGrammar parseDTD(XMLInputSource is) throws IOException 
{
        XMLEntityResolver resolver = getEntityResolver();
        if(resolver != null) {
            fDTDLoader.setEntityResolver(resolver);
        }
        fDTDLoader.setProperty(ERROR_REPORTER, fErrorReporter);
        // Should check whether the grammar with this namespace is already in
        // the grammar resolver. But since we don't know the target namespace
        // of the document here, we leave such check to the application...
        DTDGrammar grammar = (DTDGrammar)fDTDLoader.loadGrammar(is);
        // by default, hand it off to the grammar pool
        if (grammar != null) {
            fGrammarPool.cacheGrammars(XMLGrammarDescription.XML_DTD,
                                      new Grammar[]{grammar});
        }
        return grammar;
}

 public Grammar parseGrammar(String type,
    String uri) throws IOException, XNIException 
{
        XMLInputSource source = new XMLInputSource(null, uri, null);
        return parseGrammar(type, source);
}

Parse a grammar from a location identified by an URI. This method also adds this grammar to the XMLGrammarPool

 public Grammar parseGrammar(String type,
    XMLInputSource is) throws IOException, XNIException 
{
        if(type.equals(XMLGrammarDescription.XML_SCHEMA)) {
            // by default, make all XMLGrammarPoolImpl's schema grammars available to fSchemaHandler
            return parseXMLSchema(is);
        } else if(type.equals(XMLGrammarDescription.XML_DTD)) {
            return parseDTD(is);
        }
        // don't know this grammar...
        return null;
}

Parse a grammar from a location identified by an XMLInputSource. This method also adds this grammar to the XMLGrammarPool

 SchemaGrammar parseXMLSchema(XMLInputSource is) throws IOException 
{
        XMLEntityResolver resolver = getEntityResolver();
        if(resolver != null) {
            fSchemaLoader.setEntityResolver(resolver);
        }
        if (fErrorReporter.getMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN) == null) {
            fErrorReporter.putMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN, new XSMessageFormatter());
        } 
        fSchemaLoader.setProperty(ERROR_REPORTER, fErrorReporter);
        String propPrefix = Constants.XERCES_PROPERTY_PREFIX;
        String propName = propPrefix + Constants.SCHEMA_LOCATION;
        fSchemaLoader.setProperty(propName, getProperty(propName));
        propName = propPrefix + Constants.SCHEMA_NONS_LOCATION;
        fSchemaLoader.setProperty(propName, getProperty(propName));
        propName = Constants.JAXP_PROPERTY_PREFIX+Constants.SCHEMA_SOURCE;
        fSchemaLoader.setProperty(propName, getProperty(propName));
        fSchemaLoader.setFeature(SCHEMA_FULL_CHECKING, getFeature(SCHEMA_FULL_CHECKING));
        // Should check whether the grammar with this namespace is already in
        // the grammar resolver. But since we don't know the target namespace
        // of the document here, we leave such check to XSDHandler
        SchemaGrammar grammar = (SchemaGrammar)fSchemaLoader.loadGrammar(is);
        // by default, hand it off to the grammar pool
        if (grammar != null) {
            fGrammarPool.cacheGrammars(XMLGrammarDescription.XML_SCHEMA,
                                      new Grammar[]{grammar});
        }
        return grammar;
}

 public  void unlockGrammarPool() 
{
        fGrammarPool.unlockPool();
}