public JspRuntimeContext(ServletContext context,
    Options options) 
{
                           
        JspFactoryImpl factory = new JspFactoryImpl();
        SecurityClassLoad.securityClassLoad(factory.getClass().getClassLoader());
        if( System.getSecurityManager() != null ) {
            String basePackage = "org.apache.jasper.";
            try {
                factory.getClass().getClassLoader().loadClass( basePackage +
                                                               "runtime.JspFactoryImpl$PrivilegedGetPageContext");
                factory.getClass().getClassLoader().loadClass( basePackage +
                                                               "runtime.JspFactoryImpl$PrivilegedReleasePageContext");
                factory.getClass().getClassLoader().loadClass( basePackage +
                                                               "runtime.JspRuntimeLibrary");
                factory.getClass().getClassLoader().loadClass( basePackage +
                                                               "runtime.JspRuntimeLibrary$PrivilegedIntrospectHelper");
                factory.getClass().getClassLoader().loadClass( basePackage +
                                                               "runtime.ServletResponseWrapperInclude");
                factory.getClass().getClassLoader().loadClass( basePackage +
                                                               "servlet.JspServletWrapper");
            } catch (ClassNotFoundException ex) {
                throw new IllegalStateException(ex);
            }
        }
        JspFactory.setDefaultFactory(factory);
        this.context = context;
        this.options = options;
        // Get the parent class loader
        parentClassLoader =
            (URLClassLoader) Thread.currentThread().getContextClassLoader();
        if (parentClassLoader == null) {
            parentClassLoader =
                (URLClassLoader)this.getClass().getClassLoader();
        }
	if (log.isDebugEnabled()) {
	    if (parentClassLoader != null) {
		log.debug(Localizer.getMessage("jsp.message.parent_class_loader_is",
					       parentClassLoader.toString()));
	    } else {
		log.debug(Localizer.getMessage("jsp.message.parent_class_loader_is",
					       "< none >"));
	    }
        }
        initClassPath();
	if (context instanceof org.apache.jasper.servlet.JspCServletContext) {
	    return;
	}
        if (Constants.IS_SECURITY_ENABLED) {
            initSecurity();
        }
        // If this web application context is running from a
        // directory, start the background compilation thread
        String appBase = context.getRealPath("/");         
        if (!options.getDevelopment()
                && appBase != null
                && options.getCheckInterval()  > 0) {
            lastCheck = System.currentTimeMillis();
        }
}

Create a JspRuntimeContext for a web application context. Loads in any previously generated dependencies from file.

Parameters:

context - ServletContext for web application

 public  void addWrapper(String jspUri,
    JspServletWrapper jsw) 
{
 
    // ------------------------------------------------------ Public Methods
        jsps.put(jspUri, jsw);
}

Add a new JspServletWrapper.

 public  void checkCompile() 
{
        if (lastCheck <  0) {
            // Checking was disabled
            return;
        }
        long now = System.currentTimeMillis();
        if (now  > (lastCheck + (options.getCheckInterval() * 1000L))) {
            lastCheck = now;
        } else {
            return;
        }
        Object [] wrappers = jsps.values().toArray();
        for (int i = 0; i <  wrappers.length; i++ ) {
            JspServletWrapper jsw = (JspServletWrapper)wrappers[i];
            JspCompilationContext ctxt = jsw.getJspEngineContext();
            // JspServletWrapper also synchronizes on this when
            // it detects it has to do a reload
            synchronized(jsw) {
                try {
                    ctxt.compile();
                } catch (FileNotFoundException ex) {
                    ctxt.incrementRemoved();
                } catch (Throwable t) {
                    jsw.getServletContext().log("Background compile failed",
						t);
                }
            }
        }
}

Method used by background thread to check the JSP dependencies registered with this class for JSP's.

 public  void destroy() 
{
        Iterator servlets = jsps.values().iterator();
        while (servlets.hasNext()) {
            ((JspServletWrapper) servlets.next()).destroy();
        }
}

Process a "destory" event for this web application context.

 public String getClassPath() 
{
        return classpath;
}

The classpath that is passed off to the Java compiler.

 public CodeSource getCodeSource() 
{
        return codeSource;
}

Get the SecurityManager Policy CodeSource for this web applicaiton context.

 public int getJspCount() 
{
        return jsps.size();
}

Returns the number of JSPs for which JspServletWrappers exist, i.e., the number of JSPs that have been loaded into the webapp.

 public int getJspReloadCount() 
{
        return jspReloadCount;
}

Gets the current value of the JSP reload counter.

 public URLClassLoader getParentClassLoader() 
{
        return parentClassLoader;
}

Get the parent URLClassLoader.

 public PermissionCollection getPermissionCollection() 
{
        return permissionCollection;
}

Get the SecurityManager PermissionCollection for this web application context.

 public JspServletWrapper getWrapper(String jspUri) 
{
        return jsps.get(jspUri);
}

Get an already existing JspServletWrapper.

 public synchronized  void incrementJspReloadCount() 
{
        jspReloadCount++;
}

Increments the JSP reload counter.

 public  void removeWrapper(String jspUri) 
{
        jsps.remove(jspUri);
}

Remove a JspServletWrapper.

 public synchronized  void setJspReloadCount(int count) 
{
        this.jspReloadCount = count;
}

Resets the JSP reload counter.