public DOMASBuilderImpl() 
{
    //
    // Constructors
    //
        super(new XMLGrammarCachingConfiguration());
}

Constructs a DOM Builder using the dtd/xml schema parser configuration.

 public DOMASBuilderImpl(XMLGrammarCachingConfiguration config) 
{
        super(config);
}

Constructs a DOM Builder using the specified parser configuration. We must demand that the configuration extend XMLGrammarCachingConfiguration to make sure all relevant methods/features are available.

 public DOMASBuilderImpl(SymbolTable symbolTable) 
{
        super(new XMLGrammarCachingConfiguration(symbolTable));
}

Constructs a DOM Builder using the specified symbol table.

 public DOMASBuilderImpl(SymbolTable symbolTable,
    XMLGrammarPool grammarPool) 
{
        super(new XMLGrammarCachingConfiguration(symbolTable, grammarPool));
}

Constructs a DOM Builder using the specified symbol table and grammar pool. The grammarPool implementation should extent the default implementation; otherwise, correct functioning of this class may not occur.

 public ASModel getAbstractSchema() 
{
        return fAbstractSchema;
}

Associate an ASModel with a document instance. This ASModel will be used by the " validate-if-schema" and " datatype-normalization" options during the load of a new Document.

 public ASModel parseASInputSource(LSInput is) throws Exception, DOMASException 
{
                                      
        // need to wrap the LSInput with an XMLInputSource
        XMLInputSource xis = this.dom2xmlInputSource(is);
        try {
            return parseASInputSource(xis);
        }
        catch (XNIException e) {
            Exception ex = e.getException();
            throw ex;
        }
}

Parse a Abstract Schema from a location identified by an LSInput.

 ASModel parseASInputSource(XMLInputSource is) throws Exception 
{
                                      
        if (fGrammarBucket == null) {
            fGrammarBucket = new XSGrammarBucket();
        }
        initGrammarBucket();
        // actually do the parse:
        // save some casting
        XMLGrammarCachingConfiguration gramConfig = (XMLGrammarCachingConfiguration)fConfiguration;
        // ensure grammarPool doesn't absorb grammars while it's parsing
        gramConfig.lockGrammarPool();
        SchemaGrammar grammar = gramConfig.parseXMLSchema(is);
        gramConfig.unlockGrammarPool();
        ASModelImpl newAsModel = null;
        if (grammar != null) {
            newAsModel = new ASModelImpl();
            fGrammarBucket.putGrammar (grammar, true);
            addGrammars(newAsModel, fGrammarBucket);
        }
        return newAsModel;
}

 public ASModel parseASURI(String uri) throws Exception, DOMASException 
{
        XMLInputSource source = new XMLInputSource(null, uri, null);
        return parseASInputSource(source);
}

Parse a Abstract Schema from a location identified by an URI.

 public  void setAbstractSchema(ASModel abstractSchema) 
{
        // since the ASModel associated with this object is an attribute
        // according to the DOM IDL, we must obliterate anything
        // that was set before, rather than adding to it.
        // REVISIT:  so shouldn't we attempt to clear the
        // grammarPool before adding stuff to it?  - NG
        fAbstractSchema = (ASModelImpl)abstractSchema;
        // make sure the GrammarPool is properly initialized.
        XMLGrammarPool grammarPool = (XMLGrammarPool)fConfiguration.getProperty(StandardParserConfiguration.XMLGRAMMAR_POOL);
        // if there is no grammar pool, create one
        // REVISIT: ASBuilder should always create one.
        if (grammarPool == null) {
            // something's not right in this situation...
            grammarPool = new XMLGrammarPoolImpl();
            fConfiguration.setProperty(StandardParserConfiguration.XMLGRAMMAR_POOL,
                                       grammarPool);
        }
        if (fAbstractSchema != null) {
            initGrammarPool(fAbstractSchema, grammarPool);
        }
}

Associate an ASModel with a document instance. This ASModel will be used by the " validate-if-schema" and " datatype-normalization" options during the load of a new Document.