public  void compose(ComponentManager manager) throws ComponentException 
{
                           
        super.compose(manager);
        if (programGenerator == null) {
            this.programGenerator =
                    (ProgramGenerator) manager.lookup(ProgramGenerator.ROLE);
        }
}

Set the global component manager. This method sets the sitemap-defined program generator

 public  void configure(Configuration config) throws ConfigurationException 
{
        boolean autoComplete = config.getChild("autocomplete-documents").getValueAsBoolean(false);
        if (autoComplete) {
            this.completionPipe = new CompletionPipe();
            this.completionPipe.enableLogging(getLogger());
        }
        this.markupLanguage = config.getChild("markup-language").getValue(DEFAULT_MARKUP_LANGUAGE);
        this.programmingLanguage = config.getChild("programming-language").getValue(DEFAULT_PROGRAMMING_LANGUAGE);
}

 public  void dispose() 
{
        this.manager.release(this.programGenerator);
        this.programGenerator = null;
        this.manager = null;
}

dispose

 public  void generate() throws IOException, SAXException, ProcessingException 
{
        if (this.completionPipe != null) {
            generator.setConsumer(this.completionPipe);
            if (this.xmlConsumer != null) {
                this.completionPipe.setConsumer(this.xmlConsumer);
            } else {
                this.completionPipe.setContentHandler(this.contentHandler);
                this.completionPipe.setLexicalHandler(this.lexicalHandler);
            }
        } else {
            if (this.xmlConsumer != null) {
                generator.setConsumer(this.xmlConsumer);
            } else {
                generator.setContentHandler(this.contentHandler);
                generator.setLexicalHandler(this.lexicalHandler);
            }
        }
        // Fixes BUG#4062: Set document locator which is used by XIncludeTransformer
        org.xml.sax.helpers.LocatorImpl locator = new org.xml.sax.helpers.LocatorImpl();
        locator.setSystemId(this.inputSource.getURI());
        this.contentHandler.setDocumentLocator(locator);
        // Log exception and ensure that generator is released.
        try {
            generator.generate();
        } catch (IOException e) {
            getLogger().debug("IOException in generate()", e);
            throw e;
        } catch (SAXException e) {
            getLogger().debug("SAXException in generate()", e);
            throw e;
        } catch (ProcessingException e) {
            getLogger().debug("ProcessingException in generate()", e);
            throw e;
        } catch (Exception e) {
            getLogger().debug("Exception in generate()", e);
            throw new ProcessingException("Exception in ServerPagesGenerator.generate()", e);
        } finally {
            if (generator != null) {
                programGenerator.release(generator);
            }
            generator = null;
        }
        if (this.completionPipe != null) {
            this.completionPipe.flushEvents();
        }
}

Generate XML data. This method loads a server pages generator associated with its (file) input source and delegates SAX event generator to it taking care of "closing" any event left open by the loaded generator as a result of its possible "premature" return (a common situation in server pages)

 public Serializable getKey() 
{
        Object key = generator.getKey();
        if (key == null) {
            return this.inputSource.getURI();
        }
        return this.inputSource.getURI() + '-" + key;
}

Generate the unique key. This key must be unique inside the space of this component. This method must be invoked before the generateValidity() method.

 public SourceValidity getValidity() 
{
        // VG: Input source's systemID is part of the key,
        // and need not be included into the validity.
        return generator.getValidity();
}

Generate the validity object. Before this method can be invoked the generateKey() method must be invoked.

 public  void recycle() 
{
        if (this.generator != null) {
            this.programGenerator.release(this.generator);
            this.generator = null;
        }
        if (this.inputSource != null) {
            this.resolver.release(this.inputSource);
            this.inputSource = null;
        }
        if (this.completionPipe != null) {
            this.completionPipe.recycle();
            this.completionPipe = null;
        }
        super.recycle();
}

Recycle the generator by removing references

 public  void setup(SourceResolver resolver,
    Map objectModel,
    String src,
    Parameters par) throws IOException, SAXException, ProcessingException 
{
             
        super.setup(resolver, objectModel, src, par);
        String markupLanguage = this.parameters.getParameter(
                "markup-language", this.markupLanguage);
        String programmingLanguage = this.parameters.getParameter(
                "programming-language", this.programmingLanguage);
        try {
            this.inputSource = this.resolver.resolveURI(src);
        } catch (SourceException se) {
            throw SourceUtil.handle("Error during resolving of '" + src + "'.", se);
            //throw SourceUtil.handle(se);
        }
        try {
            this.generator = (AbstractServerPage) programGenerator.load(this.manager,
                    this.inputSource, markupLanguage, programmingLanguage, this.resolver);
        } catch (ProcessingException e) {
            throw e;
        } catch (Exception e) {
            getLogger().warn("setup()", e);
            throw new ProcessingException(e.getMessage(), e);
        } catch (NoClassDefFoundError e) {
            // VG: Usually indicates that page invoked with the wrong case.
            // I.e., it was compiled as "my.xsp" and inoked as "My.xsp",
            // results in different class name and an error.
            getLogger().warn("Failed to load class: " + e);
            throw new ResourceNotFoundException(e.getMessage());
        }
        // Give our own logger to the generator so that logs go in the correct category
        generator.enableLogging(getLogger());
        generator.setup(super.resolver, super.objectModel, super.source, super.parameters);
}