public StandardContext() 
{
        super();
        pipeline.setBasic(new StandardContextValve());
        broadcaster = new NotificationBroadcasterSupport();
}

Create a new StandardContext component with the default basic Valve.

 public  void addApplicationListener(String listener) 
{
        synchronized (applicationListenersLock) {
            String results[] =new String[applicationListeners.length + 1];
            for (int i = 0; i <  applicationListeners.length; i++) {
                if (listener.equals(applicationListeners[i])) {
                    log.info(sm.getString(
                            "standardContext.duplicateListener",listener));
                    return;
                }
                results[i] = applicationListeners[i];
            }
            results[applicationListeners.length] = listener;
            applicationListeners = results;
        }
        fireContainerEvent("addApplicationListener", listener);
        // FIXME - add instance if already started?
}

Add a new Listener class name to the set of Listeners configured for this application.

 public  void addApplicationParameter(ApplicationParameter parameter) 
{
        synchronized (applicationParametersLock) {
            String newName = parameter.getName();
            for (int i = 0; i <  applicationParameters.length; i++) {
                if (newName.equals(applicationParameters[i].getName()) &&
                    !applicationParameters[i].getOverride())
                    return;
            }
            ApplicationParameter results[] =
                new ApplicationParameter[applicationParameters.length + 1];
            System.arraycopy(applicationParameters, 0, results, 0,
                             applicationParameters.length);
            results[applicationParameters.length] = parameter;
            applicationParameters = results;
        }
        fireContainerEvent("addApplicationParameter", parameter);
}

Add a new application parameter for this application.

 public  void addChild(Container child) 
{
        // Global JspServlet
        Wrapper oldJspServlet = null;
        if (!(child instanceof Wrapper)) {
            throw new IllegalArgumentException
                (sm.getString("standardContext.notWrapper"));
        }
        Wrapper wrapper = (Wrapper) child;
        boolean isJspServlet = "jsp".equals(child.getName());
        // Allow webapp to override JspServlet inherited from global web.xml.
        if (isJspServlet) {
            oldJspServlet = (Wrapper) findChild("jsp");
            if (oldJspServlet != null) {
                removeChild(oldJspServlet);
            }
        }
        String jspFile = wrapper.getJspFile();
        if ((jspFile != null) && !jspFile.startsWith("/")) {
            if (isServlet22()) {
                if(log.isDebugEnabled())
                    log.debug(sm.getString("standardContext.wrapper.warning", 
                                       jspFile));
                wrapper.setJspFile("/" + jspFile);
            } else {
                throw new IllegalArgumentException
                    (sm.getString("standardContext.wrapper.error", jspFile));
            }
        }
        super.addChild(child);
        if (isJspServlet && oldJspServlet != null) {
            /*
             * The webapp-specific JspServlet inherits all the mappings
             * specified in the global web.xml, and may add additional ones.
             */
            String[] jspMappings = oldJspServlet.findMappings();
            for (int i=0; jspMappings!=null && i< jspMappings.length; i++) {
                addServletMapping(jspMappings[i], child.getName());
            }
        }
}

Add a child Container, only if the proposed child is an implementation of Wrapper.

 public  void addConstraint(SecurityConstraint constraint) 
{
        // Validate the proposed constraint
        SecurityCollection collections[] = constraint.findCollections();
        for (int i = 0; i <  collections.length; i++) {
            String patterns[] = collections[i].findPatterns();
            for (int j = 0; j <  patterns.length; j++) {
                patterns[j] = adjustURLPattern(patterns[j]);
                if (!validateURLPattern(patterns[j]))
                    throw new IllegalArgumentException
                        (sm.getString
                         ("standardContext.securityConstraint.pattern",
                          patterns[j]));
            }
        }
        // Add this constraint to the set for our web application
        synchronized (constraintsLock) {
            SecurityConstraint results[] =
                new SecurityConstraint[constraints.length + 1];
            for (int i = 0; i <  constraints.length; i++)
                results[i] = constraints[i];
            results[constraints.length] = constraint;
            constraints = results;
        }
}

Add a security constraint to the set for this web application.

 public  void addErrorPage(ErrorPage errorPage) 
{
        // Validate the input parameters
        if (errorPage == null)
            throw new IllegalArgumentException
                (sm.getString("standardContext.errorPage.required"));
        String location = errorPage.getLocation();
        if ((location != null) && !location.startsWith("/")) {
            if (isServlet22()) {
                if(log.isDebugEnabled())
                    log.debug(sm.getString("standardContext.errorPage.warning",
                                 location));
                errorPage.setLocation("/" + location);
            } else {
                throw new IllegalArgumentException
                    (sm.getString("standardContext.errorPage.error",
                                  location));
            }
        }
        // Add the specified error page to our internal collections
        String exceptionType = errorPage.getExceptionType();
        if (exceptionType != null) {
            synchronized (exceptionPages) {
                exceptionPages.put(exceptionType, errorPage);
            }
        } else {
            synchronized (statusPages) {
                if (errorPage.getErrorCode() == 200) {
                    this.okErrorPage = errorPage;
                }
                statusPages.put(Integer.valueOf(errorPage.getErrorCode()),
                                errorPage);
            }
        }
        fireContainerEvent("addErrorPage", errorPage);
}

Add an error page for the specified error or Java exception.

 public  void addFilterDef(FilterDef filterDef) 
{
        synchronized (filterDefs) {
            filterDefs.put(filterDef.getFilterName(), filterDef);
        }
        fireContainerEvent("addFilterDef", filterDef);
}

Add a filter definition to this Context.

 public  void addFilterMap(FilterMap filterMap) 
{
        // Validate the proposed filter mapping
        String filterName = filterMap.getFilterName();
        String[] servletNames = filterMap.getServletNames();
        String[] urlPatterns = filterMap.getURLPatterns();
        if (findFilterDef(filterName) == null)
            throw new IllegalArgumentException
                (sm.getString("standardContext.filterMap.name", filterName));
//      < = Servlet API 2.4
//      if ((servletNames.length == 0) && (urlPatterns.length == 0))
//      Servlet API 2.5 (FIX 43338)
//      SRV 6.2.5 says supporting for '*' as the servlet-name in filter-mapping.
        if (!filterMap.getMatchAllServletNames() && 
            !filterMap.getMatchAllUrlPatterns() && 
            (servletNames.length == 0) && (urlPatterns.length == 0))
            throw new IllegalArgumentException
                (sm.getString("standardContext.filterMap.either"));
        // FIXME: Older spec revisions may still check this
        /*
        if ((servletNames.length != 0) && (urlPatterns.length != 0))
            throw new IllegalArgumentException
                (sm.getString("standardContext.filterMap.either"));
        */
        // Because filter-pattern is new in 2.3, no need to adjust
        // for 2.2 backwards compatibility
        for (int i = 0; i <  urlPatterns.length; i++) {
            if (!validateURLPattern(urlPatterns[i])) {
                throw new IllegalArgumentException
                    (sm.getString("standardContext.filterMap.pattern",
                            urlPatterns[i]));
            }
        }
        // Add this filter mapping to our registered set
        synchronized (filterMaps) {
            FilterMap results[] =new FilterMap[filterMaps.length + 1];
            System.arraycopy(filterMaps, 0, results, 0, filterMaps.length);
            results[filterMaps.length] = filterMap;
            filterMaps = results;
        }
        fireContainerEvent("addFilterMap", filterMap);
}

Add a filter mapping to this Context.

 public  void addInstanceListener(String listener) 
{
        synchronized (instanceListenersLock) {
            String results[] =new String[instanceListeners.length + 1];
            for (int i = 0; i <  instanceListeners.length; i++)
                results[i] = instanceListeners[i];
            results[instanceListeners.length] = listener;
            instanceListeners = results;
        }
        fireContainerEvent("addInstanceListener", listener);
}

Add the classname of an InstanceListener to be added to each Wrapper appended to this Context.

 public  void addJspMapping(String pattern) 
{
        String servletName = findServletMapping("*.jsp");
        if (servletName == null) {
            servletName = "jsp";
        }
        if( findChild(servletName) != null) {
            addServletMapping(pattern, servletName, true);
        } else {
            if(log.isDebugEnabled())
                log.debug("Skiping " + pattern + " , no servlet " + servletName);
        }
}

Add the given URL pattern as a jsp-property-group. This maps resources that match the given pattern so they will be passed to the JSP container. Though there are other elements in the property group, we only care about the URL pattern here. The JSP container will parse the rest.

 public  void addLocaleEncodingMappingParameter(String locale,
    String encoding) 
{
        getCharsetMapper().addCharsetMappingFromDeploymentDescriptor(locale, encoding);
}

Add a Locale Encoding Mapping (see Sec 5.4 of Servlet spec 2.4)

 public  void addMessageDestination(MessageDestination md) 
{
        synchronized (messageDestinations) {
            messageDestinations.put(md.getName(), md);
        }
        fireContainerEvent("addMessageDestination", md.getName());
}

Add a message destination for this web application.

 public  void addMessageDestinationRef(MessageDestinationRef mdr) 
{
        namingResources.addMessageDestinationRef(mdr);
        fireContainerEvent("addMessageDestinationRef", mdr.getName());
}

Add a message destination reference for this web application.

 public  void addMimeMapping(String extension,
    String mimeType) 
{
        synchronized (mimeMappings) {
            mimeMappings.put(extension, mimeType);
        }
        fireContainerEvent("addMimeMapping", extension);
}

Add a new MIME mapping, replacing any existing mapping for the specified extension.

 public  void addNotificationListener(NotificationListener listener,
    NotificationFilter filter,
    Object object) throws IllegalArgumentException 
{
    	broadcaster.addNotificationListener(listener,filter,object);
}

 public  void addParameter(String name,
    String value) 
{
        // Validate the proposed context initialization parameter
        if ((name == null) || (value == null))
            throw new IllegalArgumentException
                (sm.getString("standardContext.parameter.required"));
        if (parameters.get(name) != null)
            throw new IllegalArgumentException
                (sm.getString("standardContext.parameter.duplicate", name));
        // Add this parameter to our defined set
        synchronized (parameters) {
            parameters.put(name, value);
        }
        fireContainerEvent("addParameter", name);
}

Add a new context initialization parameter.

 public  void addRoleMapping(String role,
    String link) 
{
        synchronized (roleMappings) {
            roleMappings.put(role, link);
        }
        fireContainerEvent("addRoleMapping", role);
}

Add a security role reference for this web application.

 public  void addSecurityRole(String role) 
{
        synchronized (securityRolesLock) {
            String results[] =new String[securityRoles.length + 1];
            for (int i = 0; i <  securityRoles.length; i++)
                results[i] = securityRoles[i];
            results[securityRoles.length] = role;
            securityRoles = results;
        }
        fireContainerEvent("addSecurityRole", role);
}

Add a new security role for this web application.

 public  void addServletMapping(String pattern,
    String name) 
{
        addServletMapping(pattern, name, false);
}

Add a new servlet mapping, replacing any existing mapping for the specified pattern.

 public  void addServletMapping(String pattern,
    String name,
    boolean jspWildCard) 
{
        // Validate the proposed mapping
        if (findChild(name) == null)
            throw new IllegalArgumentException
                (sm.getString("standardContext.servletMap.name", name));
        pattern = adjustURLPattern(RequestUtil.URLDecode(pattern));
        if (!validateURLPattern(pattern))
            throw new IllegalArgumentException
                (sm.getString("standardContext.servletMap.pattern", pattern));
        // Add this mapping to our registered set
        synchronized (servletMappingsLock) {
            String name2 = (String) servletMappings.get(pattern);
            if (name2 != null) {
                // Don't allow more than one servlet on the same pattern
                Wrapper wrapper = (Wrapper) findChild(name2);
                wrapper.removeMapping(pattern);
                mapper.removeWrapper(pattern);
            }
            servletMappings.put(pattern, name);
        }
        Wrapper wrapper = (Wrapper) findChild(name);
        wrapper.addMapping(pattern);
        // Update context mapper
        mapper.addWrapper(pattern, wrapper, jspWildCard);
        fireContainerEvent("addServletMapping", pattern);
}

Add a new servlet mapping, replacing any existing mapping for the specified pattern.

 public  void addTaglib(String uri,
    String location) 
{
        synchronized (taglibs) {
            taglibs.put(uri, location);
        }
        fireContainerEvent("addTaglib", uri);
}

Add a JSP tag library for the specified URI.

 public  void addWatchedResource(String name) 
{
        synchronized (watchedResourcesLock) {
            String results[] = new String[watchedResources.length + 1];
            for (int i = 0; i <  watchedResources.length; i++)
                results[i] = watchedResources[i];
            results[watchedResources.length] = name;
            watchedResources = results;
        }
        fireContainerEvent("addWatchedResource", name);
}

Add a new watched resource to the set recognized by this Context.

 public  void addWelcomeFile(String name) 
{
        synchronized (welcomeFilesLock) {
            // Welcome files from the application deployment descriptor
            // completely replace those from the default conf/web.xml file
            if (replaceWelcomeFiles) {
                welcomeFiles = new String[0];
                setReplaceWelcomeFiles(false);
            }
            String results[] =new String[welcomeFiles.length + 1];
            for (int i = 0; i <  welcomeFiles.length; i++)
                results[i] = welcomeFiles[i];
            results[welcomeFiles.length] = name;
            welcomeFiles = results;
        }
        postWelcomeFiles();
        fireContainerEvent("addWelcomeFile", name);
}

Add a new welcome file to the set recognized by this Context.

 public  void addWrapperLifecycle(String listener) 
{
        synchronized (wrapperLifecyclesLock) {
            String results[] =new String[wrapperLifecycles.length + 1];
            for (int i = 0; i <  wrapperLifecycles.length; i++)
                results[i] = wrapperLifecycles[i];
            results[wrapperLifecycles.length] = listener;
            wrapperLifecycles = results;
        }
        fireContainerEvent("addWrapperLifecycle", listener);
}

Add the classname of a LifecycleListener to be added to each Wrapper appended to this Context.

 public  void addWrapperListener(String listener) 
{
        synchronized (wrapperListenersLock) {
            String results[] =new String[wrapperListeners.length + 1];
            for (int i = 0; i <  wrapperListeners.length; i++)
                results[i] = wrapperListeners[i];
            results[wrapperListeners.length] = listener;
            wrapperListeners = results;
        }
        fireContainerEvent("addWrapperListener", listener);
}

Add the classname of a ContainerListener to be added to each Wrapper appended to this Context.

 protected String adjustURLPattern(String urlPattern) 
{
        if (urlPattern == null)
            return (urlPattern);
        if (urlPattern.startsWith("/") || urlPattern.startsWith("*."))
            return (urlPattern);
        if (!isServlet22())
            return (urlPattern);
        if(log.isDebugEnabled())
            log.debug(sm.getString("standardContext.urlPattern.patternWarning",
                         urlPattern));
        return ("/" + urlPattern);
}

Adjust the URL pattern to begin with a leading slash, if appropriate (i.e. we are running a servlet 2.2 application). Otherwise, return the specified URL pattern unchanged.

 public  void create() throws Exception 
{
        init();
}

 public ObjectName createObjectName(String hostDomain,
    ObjectName parentName) throws MalformedObjectNameException 
{
        String onameStr;
        StandardHost hst=(StandardHost)getParent();
        String pathName=getName();
        String hostName=getParent().getName();
        String name= "//" + ((hostName==null)? "DEFAULT" : hostName) +
                (("".equals(pathName))?"/":pathName );
        String suffix=",J2EEApplication=" +
                getJ2EEApplication() + ",J2EEServer=" +
                getJ2EEServer();
        onameStr="j2eeType=WebModule,name=" + name + suffix;
        if( log.isDebugEnabled())
            log.debug("Registering " + onameStr + " for " + oname);
        // default case - no domain explictely set.
        if( getDomain() == null ) domain=hst.getDomain();
        ObjectName oname=new ObjectName(getDomain() + ":" + onameStr);
        return oname;
}

 public Wrapper createWrapper() 
{
        Wrapper wrapper = null;
        if (wrapperClass != null) {
            try {
                wrapper = (Wrapper) wrapperClass.newInstance();
            } catch (Throwable t) {
                log.error("createWrapper", t);
                return (null);
            }
        } else {
            wrapper = new StandardWrapper();
        }
        synchronized (instanceListenersLock) {
            for (int i = 0; i <  instanceListeners.length; i++) {
                try {
                    Class clazz = Class.forName(instanceListeners[i]);
                    InstanceListener listener =
                      (InstanceListener) clazz.newInstance();
                    wrapper.addInstanceListener(listener);
                } catch (Throwable t) {
                    log.error("createWrapper", t);
                    return (null);
                }
            }
        }
        synchronized (wrapperLifecyclesLock) {
            for (int i = 0; i <  wrapperLifecycles.length; i++) {
                try {
                    Class clazz = Class.forName(wrapperLifecycles[i]);
                    LifecycleListener listener =
                      (LifecycleListener) clazz.newInstance();
                    if (wrapper instanceof Lifecycle)
                        ((Lifecycle) wrapper).addLifecycleListener(listener);
                } catch (Throwable t) {
                    log.error("createWrapper", t);
                    return (null);
                }
            }
        }
        synchronized (wrapperListenersLock) {
            for (int i = 0; i <  wrapperListeners.length; i++) {
                try {
                    Class clazz = Class.forName(wrapperListeners[i]);
                    ContainerListener listener =
                      (ContainerListener) clazz.newInstance();
                    wrapper.addContainerListener(listener);
                } catch (Throwable t) {
                    log.error("createWrapper", t);
                    return (null);
                }
            }
        }
        return (wrapper);
}

Factory method to create and return a new Wrapper instance, of the Java implementation class appropriate for this Context implementation. The constructor of the instantiated Wrapper will have been called, but no properties will have been set.

 public  void destroy() throws Exception 
{
        if( oname != null ) { 
            // Send j2ee.object.deleted notification 
            Notification notification = 
                new Notification("j2ee.object.deleted", this.getObjectName(), 
                                sequenceNumber++);
            broadcaster.sendNotification(notification);
        } 
        super.destroy();
        // Notify our interested LifecycleListeners
        lifecycle.fireLifecycleEvent(DESTROY_EVENT, null);
        synchronized (instanceListenersLock) {
            instanceListeners = new String[0];
        }
}

Destroy needs to clean up the context completely. The problem is that undoing all the config in start() and restoring a 'fresh' state is impossible. After stop()/destroy()/init()/start() we should have the same state as if a fresh start was done - i.e read modified web.xml, etc. This can only be done by completely removing the context object and remapping a new one, or by cleaning up everything. XXX Should this be done in stop() ?

 protected File engineBase() 
{
        String base=System.getProperty("catalina.base");
        if( base == null ) {
            StandardEngine eng=(StandardEngine)this.getParent().getParent();
            base=eng.getBaseDir();
        }
        return (new File(base));
}

Return a File object representing the base directory for the entire servlet container (i.e. the Engine container if present).

 public boolean filterStart() 
{
        if (getLogger().isDebugEnabled())
            getLogger().debug("Starting filters");
        // Instantiate and record a FilterConfig for each defined filter
        boolean ok = true;
        synchronized (filterConfigs) {
            filterConfigs.clear();
            Iterator names = filterDefs.keySet().iterator();
            while (names.hasNext()) {
                String name = (String) names.next();
                if (getLogger().isDebugEnabled())
                    getLogger().debug(" Starting filter '" + name + "'");
                ApplicationFilterConfig filterConfig = null;
                try {
                    filterConfig = new ApplicationFilterConfig
                      (this, (FilterDef) filterDefs.get(name));
                    filterConfigs.put(name, filterConfig);
                } catch (Throwable t) {
                    getLogger().error
                        (sm.getString("standardContext.filterStart", name), t);
                    ok = false;
                }
            }
        }
        return (ok);
}

Configure and initialize the set of filters for this Context. Return true if all filter initialization completed successfully, or false otherwise.

 public boolean filterStop() 
{
        if (getLogger().isDebugEnabled())
            getLogger().debug("Stopping filters");
        // Release all Filter and FilterConfig instances
        synchronized (filterConfigs) {
            Iterator names = filterConfigs.keySet().iterator();
            while (names.hasNext()) {
                String name = (String) names.next();
                if (getLogger().isDebugEnabled())
                    getLogger().debug(" Stopping filter '" + name + "'");
                ApplicationFilterConfig filterConfig =
                  (ApplicationFilterConfig) filterConfigs.get(name);
                filterConfig.release();
            }
            filterConfigs.clear();
        }
        return (true);
}

Finalize and release the set of filters for this Context. Return true if all filter finalization completed successfully, or false otherwise.

 public String[] findApplicationListeners() 
{
        return (applicationListeners);
}

Return the set of application listener class names configured for this application.

 public ApplicationParameter[] findApplicationParameters() 
{
        synchronized (applicationParametersLock) {
            return (applicationParameters);
        }
}

Return the set of application parameters for this application.

 public SecurityConstraint[] findConstraints() 
{
        return (constraints);
}

Return the security constraints for this web application. If there are none, a zero-length array is returned.

 public ErrorPage findErrorPage(int errorCode) 
{
        if (errorCode == 200) {
            return (okErrorPage);
        } else {
            return ((ErrorPage) statusPages.get(new Integer(errorCode)));
        }
}

Return the error page entry for the specified HTTP error code, if any; otherwise return null.

 public ErrorPage findErrorPage(String exceptionType) 
{
        synchronized (exceptionPages) {
            return ((ErrorPage) exceptionPages.get(exceptionType));
        }
}

Return the error page entry for the specified Java exception type, if any; otherwise return null.

 public ErrorPage[] findErrorPages() 
{
        synchronized(exceptionPages) {
            synchronized(statusPages) {
                ErrorPage results1[] = new ErrorPage[exceptionPages.size()];
                results1 =
                    (ErrorPage[]) exceptionPages.values().toArray(results1);
                ErrorPage results2[] = new ErrorPage[statusPages.size()];
                results2 =
                    (ErrorPage[]) statusPages.values().toArray(results2);
                ErrorPage results[] =
                    new ErrorPage[results1.length + results2.length];
                for (int i = 0; i <  results1.length; i++)
                    results[i] = results1[i];
                for (int i = results1.length; i <  results.length; i++)
                    results[i] = results2[i - results1.length];
                return (results);
            }
        }
}

Return the set of defined error pages for all specified error codes and exception types.

 public FilterConfig findFilterConfig(String name) 
{
        return ((FilterConfig) filterConfigs.get(name));
}

Find and return the initialized FilterConfig for the specified filter name, if any; otherwise return null.

 public FilterDef findFilterDef(String filterName) 
{
        synchronized (filterDefs) {
            return ((FilterDef) filterDefs.get(filterName));
        }
}

Return the filter definition for the specified filter name, if any; otherwise return null.

 public FilterDef[] findFilterDefs() 
{
        synchronized (filterDefs) {
            FilterDef results[] = new FilterDef[filterDefs.size()];
            return ((FilterDef[]) filterDefs.values().toArray(results));
        }
}

Return the set of defined filters for this Context.

 public FilterMap[] findFilterMaps() 
{
        return (filterMaps);
}

Return the set of filter mappings for this Context.

 public String[] findInstanceListeners() 
{
        synchronized (instanceListenersLock) {
            return (instanceListeners);
        }
}

Return the set of InstanceListener classes that will be added to newly created Wrappers automatically.

 public Context findMappingObject() 
{
        return (Context) getMappingObject();
}

FIXME: Fooling introspection ...

 public MessageDestination findMessageDestination(String name) 
{
        synchronized (messageDestinations) {
            return ((MessageDestination) messageDestinations.get(name));
        }
}

Return the message destination with the specified name, if any; otherwise, return null.

 public MessageDestinationRef findMessageDestinationRef(String name) 
{
        return namingResources.findMessageDestinationRef(name);
}

Return the message destination ref with the specified name, if any; otherwise, return null.

 public MessageDestinationRef[] findMessageDestinationRefs() 
{
        return namingResources.findMessageDestinationRefs();
}

Return the set of defined message destination refs for this web application. If none have been defined, a zero-length array is returned.

 public MessageDestination[] findMessageDestinations() 
{
        synchronized (messageDestinations) {
            MessageDestination results[] =
                new MessageDestination[messageDestinations.size()];
            return ((MessageDestination[])
                    messageDestinations.values().toArray(results));
        }
}

Return the set of defined message destinations for this web application. If none have been defined, a zero-length array is returned.

 public String findMimeMapping(String extension) 
{
        return ((String) mimeMappings.get(extension));
}

Return the MIME type to which the specified extension is mapped, if any; otherwise return null.

 public String[] findMimeMappings() 
{
        synchronized (mimeMappings) {
            String results[] = new String[mimeMappings.size()];
            return
                ((String[]) mimeMappings.keySet().toArray(results));
        }
}

Return the extensions for which MIME mappings are defined. If there are none, a zero-length array is returned.

 public String findParameter(String name) 
{
        synchronized (parameters) {
            return ((String) parameters.get(name));
        }
}

Return the value for the specified context initialization parameter name, if any; otherwise return null.

 public String[] findParameters() 
{
        synchronized (parameters) {
            String results[] = new String[parameters.size()];
            return ((String[]) parameters.keySet().toArray(results));
        }
}

Return the names of all defined context initialization parameters for this Context. If no parameters are defined, a zero-length array is returned.

 public String findRoleMapping(String role) 
{
        String realRole = null;
        synchronized (roleMappings) {
            realRole = (String) roleMappings.get(role);
        }
        if (realRole != null)
            return (realRole);
        else
            return (role);
}

For the given security role (as used by an application), return the corresponding role name (as defined by the underlying Realm) if there is one. Otherwise, return the specified role unchanged.

 public boolean findSecurityRole(String role) 
{
        synchronized (securityRolesLock) {
            for (int i = 0; i <  securityRoles.length; i++) {
                if (role.equals(securityRoles[i]))
                    return (true);
            }
        }
        return (false);
}

Return true if the specified security role is defined for this application; otherwise return false.

 public String[] findSecurityRoles() 
{
        synchronized (securityRolesLock) {
            return (securityRoles);
        }
}

Return the security roles defined for this application. If none have been defined, a zero-length array is returned.

 public String findServletMapping(String pattern) 
{
        synchronized (servletMappingsLock) {
            return ((String) servletMappings.get(pattern));
        }
}

Return the servlet name mapped by the specified pattern (if any); otherwise return null.

 public String[] findServletMappings() 
{
        synchronized (servletMappingsLock) {
            String results[] = new String[servletMappings.size()];
            return
               ((String[]) servletMappings.keySet().toArray(results));
        }
}

Return the patterns of all defined servlet mappings for this Context. If no mappings are defined, a zero-length array is returned.

 public DirContext findStaticResources() 
{
        return getResources();
}

Return the naming resources associated with this web application. FIXME: Fooling introspection ...

 public String findStatusPage(int status) 
{
        ErrorPage errorPage = (ErrorPage)statusPages.get(new Integer(status));
        if (errorPage!=null) {
            return errorPage.getLocation();
        }
        return null;
}

Return the context-relative URI of the error page for the specified HTTP status code, if any; otherwise return null.

 public int[] findStatusPages() 
{
        synchronized (statusPages) {
            int results[] = new int[statusPages.size()];
            Iterator elements = statusPages.keySet().iterator();
            int i = 0;
            while (elements.hasNext())
                results[i++] = ((Integer) elements.next()).intValue();
            return (results);
        }
}

Return the set of HTTP status codes for which error pages have been specified. If none are specified, a zero-length array is returned.

 public String findTaglib(String uri) 
{
        synchronized (taglibs) {
            return ((String) taglibs.get(uri));
        }
}

Return the tag library descriptor location for the specified taglib URI, if any; otherwise, return null.

 public String[] findTaglibs() 
{
        synchronized (taglibs) {
            String results[] = new String[taglibs.size()];
            return ((String[]) taglibs.keySet().toArray(results));
        }
}

Return the URIs of all tag libraries for which a tag library descriptor location has been specified. If none are specified, a zero-length array is returned.

 public String[] findWatchedResources() 
{
        synchronized (watchedResourcesLock) {
            return watchedResources;
        }
}

Return the set of watched resources for this Context. If none are defined, a zero length array will be returned.

 public boolean findWelcomeFile(String name) 
{
        synchronized (welcomeFilesLock) {
            for (int i = 0; i <  welcomeFiles.length; i++) {
                if (name.equals(welcomeFiles[i]))
                    return (true);
            }
        }
        return (false);
}

Return true if the specified welcome file is defined for this Context; otherwise return false.

 public String[] findWelcomeFiles() 
{
        synchronized (welcomeFilesLock) {
            return (welcomeFiles);
        }
}

Return the set of welcome files defined for this Context. If none are defined, a zero-length array is returned.

 public String[] findWrapperLifecycles() 
{
        synchronized (wrapperLifecyclesLock) {
            return (wrapperLifecycles);
        }
}

Return the set of LifecycleListener classes that will be added to newly created Wrappers automatically.

 public String[] findWrapperListeners() 
{
        synchronized (wrapperListenersLock) {
            return (wrapperListeners);
        }
}

Return the set of ContainerListener classes that will be added to newly created Wrappers automatically.

 public String getAltDDName() 
{
        return altDDName;
}

Return the alternate Deployment Descriptor name.

 public AnnotationProcessor getAnnotationProcessor() 
{
       return annotationProcessor;
}

 public boolean getAntiJARLocking() 
{
        return (this.antiJARLocking);
}

Return the antiJARLocking flag for this Context.

 public boolean getAntiResourceLocking() 
{
        return (this.antiResourceLocking);
}

Return the antiResourceLocking flag for this Context.

 protected String getAppBase() 
{
        String appBase = null;
        Container container = this;
        while (container != null) {
            if (container instanceof Host)
                break;
            container = container.getParent();
        }
        if (container != null) {
            appBase = ((Host) container).getAppBase();
        }
        return appBase;
}

Get app base.

 public Object[] getApplicationEventListeners() 
{
        return (applicationEventListenersObjects);
}

Return the set of initialized application event listener objects, in the order they were specified in the web application deployment descriptor, for this application.

 public Object[] getApplicationLifecycleListeners() 
{
        return (applicationLifecycleListenersObjects);
}

Return the set of initialized application lifecycle listener objects, in the order they were specified in the web application deployment descriptor, for this application.

 public boolean getAvailable() 
{
        return (this.available);
}

Return the application available flag for this Context.

 protected String getBasePath() 
{
        String docBase = null;
        Container container = this;
        while (container != null) {
            if (container instanceof Host)
                break;
            container = container.getParent();
        }
        File file = new File(getDocBase());
        if (!file.isAbsolute()) {
            if (container == null) {
                docBase = (new File(engineBase(), getDocBase())).getPath();
            } else {
                // Use the "appBase" property of this container
                String appBase = ((Host) container).getAppBase();
                file = new File(appBase);
                if (!file.isAbsolute())
                    file = new File(engineBase(), appBase);
                docBase = (new File(file, getDocBase())).getPath();
            }
        } else {
            docBase = file.getPath();
        }
        return docBase;
}

Get base path.

 public int getCacheMaxSize() 
{
        return cacheMaxSize;
}

Return the maximum size of the cache in KB.

 public int getCacheObjectMaxSize() 
{
        return cacheObjectMaxSize;
}

Return the maximum size of objects to be cached in KB.

 public int getCacheTTL() 
{
        return cacheTTL;
}

Get cache TTL.

 public CharsetMapper getCharsetMapper() 
{
        // Create a mapper the first time it is requested
        if (this.charsetMapper == null) {
            try {
                Class clazz = Class.forName(charsetMapperClass);
                this.charsetMapper =
                  (CharsetMapper) clazz.newInstance();
            } catch (Throwable t) {
                this.charsetMapper = new CharsetMapper();
            }
        }
        return (this.charsetMapper);
}

Return the Locale to character set mapper for this Context.

 public String getCharsetMapperClass() 
{
        return (this.charsetMapperClass);
}

Return the Locale to character set mapper class for this Context.

 public boolean getClearReferencesStopThreads() 
{
        return (this.clearReferencesStopThreads);
}

Return the clearReferencesStopThreads flag for this Context.

 public String getCompilerClasspath() 
{
        return compilerClasspath;
}

Return the compiler classpath.

 public File getConfigBase() 
{
        File configBase = 
            new File(System.getProperty("catalina.base"), "conf");
        if (!configBase.exists()) {
            return null;
        }
        Container container = this;
        Container host = null;
        Container engine = null;
        while (container != null) {
            if (container instanceof Host)
                host = container;
            if (container instanceof Engine)
                engine = container;
            container = container.getParent();
        }
        if (engine != null) {
            configBase = new File(configBase, engine.getName());
        }
        if (host != null) {
            configBase = new File(configBase, host.getName());
        }
        if (saveConfig) {
            configBase.mkdirs();
        }
        return configBase;
}

Get config base.

 public String getConfigFile() 
{
        return (this.configFile);
}

Return the path to a file to save this Context information.

 public boolean getConfigured() 
{
        return (this.configured);
}

Return the "correctly configured" flag for this Context.

 public boolean getCookies() 
{
        return (this.cookies);
}

Return the "use cookies for session ids" flag.

 public boolean getCrossContext() 
{
        return (this.crossContext);
}

Return the "allow crossing servlet contexts" flag.

 protected String getDefaultConfigFile() 
{
        String basename = null;
        String path = getPath();
        if (path.equals("")) {
            basename = "ROOT";
        } else {
            basename = path.substring(1).replace('/', '#');
        }
        return (basename + ".xml");
}

Given a context path, get the config file name.

 public String getDefaultContextXml() 
{
        return defaultContextXml;
}

 public String getDefaultWebXml() 
{
        return defaultWebXml;
}

 public boolean getDelegate() 
{
        return (this.delegate);
}

Return the "follow standard delegation model" flag used to configure our ClassLoader.

 public String getDeploymentDescriptor() 
{
    
        InputStream stream = null;
        ServletContext servletContext = getServletContext();
        if (servletContext != null) {
            stream = servletContext.getResourceAsStream(
                org.apache.catalina.startup.Constants.ApplicationWebXml);
        }
        if (stream == null) {
            return "";
        }
        BufferedReader br = new BufferedReader(
                                new InputStreamReader(stream));
        StringBuffer sb = new StringBuffer();
        String strRead = "";
        try {
            while (strRead != null) {
                sb.append(strRead);
                strRead = br.readLine();
            }
        } catch (IOException e) {
            return "";
        }
        return sb.toString();
}

JSR77 deploymentDescriptor attribute

 public String getDisplayName() 
{
        return (this.displayName);
}

Return the display name of this web application.

 public boolean getDistributable() 
{
        return (this.distributable);
}

Return the distributable flag for this web application.

 public String getDocBase() 
{
        return (this.docBase);
}

Return the document root for this Context. This can be an absolute pathname, a relative pathname, or a URL.

 public String getEncodedPath() 
{
        return encodedPath;
}

 public String getEngineName() 
{
        if( engineName != null ) return engineName;
        return domain;
}

 public String getHostname() 
{
        Container parentHost = getParent();
        if (parentHost != null) {
            hostName = parentHost.getName();
        }
        if ((hostName == null) || (hostName.length() <  1))
            hostName = "_";
        return hostName;
}

 public boolean getIgnoreAnnotations() 
{
        return this.ignoreAnnotations;
}

Return the boolean on the annotations parsing.

 public String getInfo() 
{
        return (info);
}

Return descriptive information about this Container implementation and the corresponding version number, in the format <description>/<version>.

 public String getJ2EEApplication() 
{
        return j2EEApplication;
}

 public String getJ2EEServer() 
{
        return j2EEServer;
}

 public String[] getJavaVMs() 
{
        return javaVMs;
}

 public LoginConfig getLoginConfig() 
{
        return (this.loginConfig);
}

Return the login configuration descriptor for this web application.

 public Mapper getMapper() 
{
        return (mapper);
}

Get the mapper associated with the context.

 public NamingContextListener getNamingContextListener() 
{
        return namingContextListener;
}

Naming context listener accessor.

 public NamingResources getNamingResources() 
{
        if (namingResources == null) {
            setNamingResources(new NamingResources());
        }
        return (namingResources);
}

Return the naming resources associated with this web application.

 public MBeanNotificationInfo[] getNotificationInfo() 
{
    	// FIXME: i18n
    	if(notificationInfo == null) {
    		notificationInfo = new MBeanNotificationInfo[]{
    				new MBeanNotificationInfo(new String[] {
    				"j2ee.object.created"},
					Notification.class.getName(),
					"web application is created"
    				), 
					new MBeanNotificationInfo(new String[] {
					"j2ee.state.starting"},
					Notification.class.getName(),
					"change web application is starting"
					),
					new MBeanNotificationInfo(new String[] {
					"j2ee.state.running"},
					Notification.class.getName(),
					"web application is running"
					),
					new MBeanNotificationInfo(new String[] {
					"j2ee.state.stopped"},
					Notification.class.getName(),
					"web application start to stopped"
					),
					new MBeanNotificationInfo(new String[] {
					"j2ee.object.stopped"},
					Notification.class.getName(),
					"web application is stopped"
					),
					new MBeanNotificationInfo(new String[] {
					"j2ee.object.deleted"},
					Notification.class.getName(),
					"web application is deleted"
					)
    		};
    	}
    	return notificationInfo;
}

 public String getOriginalDocBase() 
{
        return (this.originalDocBase);
}

Return the original document root for this Context. This can be an absolute pathname, a relative pathname, or a URL. Is only set as deployment has change docRoot!

 public boolean getOverride() 
{
        return (this.override);
}

Return the DefaultContext override flag for this web application.

 public ClassLoader getParentClassLoader() 
{
        if (parentClassLoader != null)
            return (parentClassLoader);
        if (getPrivileged()) {
            return this.getClass().getClassLoader();
        } else if (parent != null) {
            return (parent.getParentClassLoader());
        }
        return (ClassLoader.getSystemClassLoader());
}

Return the parent class loader (if any) for this web application. This call is meaningful only after a Loader has been configured.

 public ObjectName getParentName() throws MalformedObjectNameException 
{
        // "Life" update
        String path=oname.getKeyProperty("name");
        if( path == null ) {
            log.error( "No name attribute " +name );
            return null;
        }
        if( ! path.startsWith( "//")) {
            log.error("Invalid name " + name);
        }
        path=path.substring(2);
        int delim=path.indexOf( "/" );
        hostName="localhost"; // Should be default...
        if( delim  > 0 ) {
            hostName=path.substring(0, delim);
            path = path.substring(delim);
            if (path.equals("/")) {
                this.setName("");
            } else {
                this.setName(path);
            }
        } else {
            if(log.isDebugEnabled())
                log.debug("Setting path " +  path );
            this.setName( path );
        }
        // XXX The service and domain should be the same.
        String parentDomain=getEngineName();
        if( parentDomain == null ) parentDomain=domain;
        ObjectName parentName=new ObjectName( parentDomain + ":" +
                "type=Host,host=" + hostName);
        return parentName;
}

 public String getPath() 
{
        return (getName());
}

Return the context path for this Context.

 public boolean getPaused() 
{
        return (this.paused);
}

Return the request processing paused flag for this Context.

 public boolean getPrivileged() 
{
        return (this.privileged);
}

Return the privileged flag for this web application.

 public boolean getProcessTlds() 
{
	return processTlds;
}

Returns the processTlds attribute value.

 public long getProcessingTime() 
{
        
        long result = 0;
        Container[] children = findChildren();
        if (children != null) {
            for( int i=0; i<  children.length; i++ ) {
                result += ((StandardWrapper)children[i]).getProcessingTime();
            }
        }
        return result;
}

Gets the cumulative processing times of all servlets in this StandardContext.

 public String getPublicId() 
{
        return (this.publicId);
}

Return the public identifier of the deployment descriptor DTD that is currently being parsed.

 public boolean getReloadable() 
{
        return (this.reloadable);
}

Return the reloadable flag for this web application.

 public String getServer() 
{
        return server;
}

 public ServletContext getServletContext() 
{
        if (context == null) {
            context = new ApplicationContext(getBasePath(), this);
            if (altDDName != null)
                context.setAttribute(Globals.ALT_DD_ATTR,altDDName);
        }
        return (context.getFacade());
}

Return the servlet context for which this Context is a facade.

 public String[] getServlets() 
{
        
        String[] result = null;
        Container[] children = findChildren();
        if (children != null) {
            result = new String[children.length];
            for( int i=0; i<  children.length; i++ ) {
                result[i] = ((StandardWrapper)children[i]).getObjectName();
            }
        }
        return result;
}

JSR77 servlets attribute

 public int getSessionTimeout() 
{
        return (this.sessionTimeout);
}

Return the default session timeout (in minutes) for this web application.

 public long getStartTime() 
{
        return startTime;
}

Gets the time this context was started.

 public long getStartupTime() 
{
        return startupTime;
}

Gets the time (in milliseconds) it took to start this context.

 public int getState() 
{
        if( started ) {
            return 1; // RUNNING
        }
        if( initialized ) {
            return 0; // starting ? 
        }
        if( ! available ) { 
            return 4; //FAILED
        }
        // 2 - STOPPING
        return 3; // STOPPED
}

 public DirContext getStaticResources() 
{
        return getResources();
}

Return the naming resources associated with this web application.

 public boolean getSwallowOutput() 
{
        return (this.swallowOutput);
}

Return the value of the swallowOutput flag.

 public boolean getTldNamespaceAware() 
{
        return tldNamespaceAware;
}

Get the server.xml <host> attribute's xmlNamespaceAware.

 public long getTldScanTime() 
{
        return tldScanTime;
}

 public boolean getTldValidation() 
{
        return tldValidation;
}

Get the server.xml attribute's webXmlValidation.

 public long getUnloadDelay() 
{
        return (this.unloadDelay);
}

Return the value of the unloadDelay flag.

 public boolean getUnpackWAR() 
{
        return (unpackWAR);
}

Unpack WAR flag accessor.

 public boolean getUseHttpOnly() 
{
        return useHttpOnly;
}

Gets the value of the use HttpOnly cookies for session cookies flag.

 public String[] getWelcomeFiles() 
{
        return findWelcomeFiles();
}

Return the naming resources associated with this web application.

 public String getWorkDir() 
{
        return (this.workDir);
}

Return the work directory for this Context.

 public String getWorkPath() 
{
        if (getWorkDir() == null) {
            return null;
        }
        File workDir = new File(getWorkDir());
        if (!workDir.isAbsolute()) {
            File catalinaHome = engineBase();
            String catalinaHomePath = null;
            try {
                catalinaHomePath = catalinaHome.getCanonicalPath();
                workDir = new File(catalinaHomePath,
                        getWorkDir());
            } catch (IOException e) {
                log.warn("Exception obtaining work path for " + getPath());
            }
        }
        return workDir.getAbsolutePath();
}

Get the absolute path to the work dir. To avoid duplication.

 public String getWrapperClass() 
{
        return (this.wrapperClassName);
}

Return the Java class name of the Wrapper implementation used for servlets registered in this Context.

 public boolean getXmlNamespaceAware() 
{
        return webXmlNamespaceAware;
}

Get the server.xml attribute's xmlNamespaceAware.

 public boolean getXmlValidation() 
{
        return webXmlValidation;
}

Get the server.xml attribute's xmlValidation.

 public  void init() throws Exception 
{
        if( this.getParent() == null ) {
            ObjectName parentName=getParentName();
            if( ! mserver.isRegistered(parentName)) {
                if(log.isDebugEnabled())
                    log.debug("No host, creating one " + parentName);
                StandardHost host=new StandardHost();
                host.setName(hostName);
                host.setAutoDeploy(false);
                Registry.getRegistry(null, null)
                    .registerComponent(host, parentName, null);
                // We could do it the hard way...
                //mserver.invoke(parentName, "init", new Object[] {}, new String[] {} );
                // or same thing easier:
                host.init();
            }
            // Add the main configuration listener
            LifecycleListener config = null;
            try {
                String configClassName = null;
                try {
                    configClassName = String.valueOf(mserver.getAttribute(parentName, "configClass"));
                } catch (AttributeNotFoundException e) {
                    // Ignore, it's normal a host may not have this optional attribute
                }
                if (configClassName != null) {
                    Class clazz = Class.forName(configClassName);
                    config = (LifecycleListener) clazz.newInstance();
                } else {
                    config = new ContextConfig();
                }
            } catch (Exception e) {
                log.warn("Error creating ContextConfig for " + parentName, e);
                throw e;
            }
            this.addLifecycleListener(config);
            if (log.isDebugEnabled()) {
                log.debug("AddChild " + parentName + " " + this);
            }
            try {
                mserver.invoke(parentName, "addChild", new Object[] { this },
                        new String[] {"org.apache.catalina.Container"});
            } catch (Exception e) {
                destroy();
                throw e;
            }
            // It's possible that addChild may have started us
            if( initialized ) {
                return;
            }
        }
        if (processTlds) {
            this.addLifecycleListener(new TldConfig());
        }
        super.init();
        // Notify our interested LifecycleListeners
        lifecycle.fireLifecycleEvent(INIT_EVENT, null);
        // Send j2ee.state.starting notification 
        if (this.getObjectName() != null) {
            Notification notification = new Notification("j2ee.state.starting", 
                                                        this.getObjectName(), 
                                                        sequenceNumber++);
            broadcaster.sendNotification(notification);
        }
}

 public boolean isAllowLinking() 
{
        return allowLinking;
}

Is linking allowed.

 public boolean isCachingAllowed() 
{
        return cachingAllowed;
}

Is caching allowed ?

 public boolean isCaseSensitive() 
{
        return caseSensitive;
}

Is case sensitive ?

 public boolean isEventProvider() 
{
        return false;
}

 public boolean isFilesystemBased() 
{
        return (filesystemBased);
}

Returns true if the resources associated with this context are filesystem based.

 public boolean isLazy() 
{
        return lazy;
}

 public boolean isReplaceWelcomeFiles() 
{
        return (this.replaceWelcomeFiles);
}

Return the "replace welcome files" property.

 public boolean isSaveConfig() 
{
        return saveConfig;
}

Save config ?

 protected boolean isServlet22() 
{
        if (this.publicId == null)
            return (false);
        if (this.publicId.equals
            (org.apache.catalina.startup.Constants.WebDtdPublicId_22))
            return (true);
        else
            return (false);
}

Are we processing a version 2.2 deployment descriptor?

 public boolean isStateManageable() 
{
        return true;
}

Support for "stateManageable" JSR77

 public boolean isStatisticsProvider() 
{
        return false;
}

 public boolean isUseNaming() 
{
        return (useNaming);
}

Returns true if the internal naming support is used.

 public boolean listenerStart() 
{
        if (log.isDebugEnabled())
            log.debug("Configuring application event listeners");
        // Instantiate the required listeners
        ClassLoader loader = getLoader().getClassLoader();
        String listeners[] = findApplicationListeners();
        Object results[] = new Object[listeners.length];
        boolean ok = true;
        for (int i = 0; i <  results.length; i++) {
            if (getLogger().isDebugEnabled())
                getLogger().debug(" Configuring event listener class '" +
                    listeners[i] + "'");
            try {
                Class clazz = loader.loadClass(listeners[i]);
                results[i] = clazz.newInstance();
                // Annotation processing
                if (!getIgnoreAnnotations()) {
                    getAnnotationProcessor().processAnnotations(results[i]);
                    getAnnotationProcessor().postConstruct(results[i]);
                }
            } catch (Throwable t) {
                getLogger().error
                    (sm.getString("standardContext.applicationListener",
                                  listeners[i]), t);
                ok = false;
            }
        }
        if (!ok) {
            getLogger().error(sm.getString("standardContext.applicationSkipped"));
            return (false);
        }
        // Sort listeners in two arrays
        ArrayList eventListeners = new ArrayList();
        ArrayList lifecycleListeners = new ArrayList();
        for (int i = 0; i <  results.length; i++) {
            if ((results[i] instanceof ServletContextAttributeListener)
                || (results[i] instanceof ServletRequestAttributeListener)
                || (results[i] instanceof ServletRequestListener)
                || (results[i] instanceof HttpSessionAttributeListener)) {
                eventListeners.add(results[i]);
            }
            if ((results[i] instanceof ServletContextListener)
                || (results[i] instanceof HttpSessionListener)) {
                lifecycleListeners.add(results[i]);
            }
        }
        setApplicationEventListeners(eventListeners.toArray());
        setApplicationLifecycleListeners(lifecycleListeners.toArray());
        // Send application start events
        if (getLogger().isDebugEnabled())
            getLogger().debug("Sending application start events");
        Object instances[] = getApplicationLifecycleListeners();
        if (instances == null)
            return (ok);
        ServletContextEvent event =
          new ServletContextEvent(getServletContext());
        for (int i = 0; i <  instances.length; i++) {
            if (instances[i] == null)
                continue;
            if (!(instances[i] instanceof ServletContextListener))
                continue;
            ServletContextListener listener =
                (ServletContextListener) instances[i];
            try {
                fireContainerEvent("beforeContextInitialized", listener);
                listener.contextInitialized(event);
                fireContainerEvent("afterContextInitialized", listener);
            } catch (Throwable t) {
                fireContainerEvent("afterContextInitialized", listener);
                getLogger().error
                    (sm.getString("standardContext.listenerStart",
                                  instances[i].getClass().getName()), t);
                ok = false;
            }
        }
        return (ok);
}

Configure the set of instantiated application event listeners for this Context. Return true if all listeners wre initialized successfully, or false otherwise.

 public boolean listenerStop() 
{
        if (log.isDebugEnabled())
            log.debug("Sending application stop events");
        boolean ok = true;
        Object listeners[] = getApplicationLifecycleListeners();
        if (listeners != null) {
            ServletContextEvent event =
                new ServletContextEvent(getServletContext());
            for (int i = 0; i <  listeners.length; i++) {
                int j = (listeners.length - 1) - i;
                if (listeners[j] == null)
                    continue;
                if (listeners[j] instanceof ServletContextListener) {
                    ServletContextListener listener =
                        (ServletContextListener) listeners[j];
                    try {
                        fireContainerEvent("beforeContextDestroyed", listener);
                        listener.contextDestroyed(event);
                        fireContainerEvent("afterContextDestroyed", listener);
                    } catch (Throwable t) {
                        fireContainerEvent("afterContextDestroyed", listener);
                        getLogger().error
                            (sm.getString("standardContext.listenerStop",
                                listeners[j].getClass().getName()), t);
                        ok = false;
                    }
                }
                // Annotation processing
                if (!getIgnoreAnnotations()) {
                    try {
                        getAnnotationProcessor().preDestroy(listeners[j]);
                    } catch (Throwable t) {
                        getLogger().error
                            (sm.getString("standardContext.listenerStop",
                                listeners[j].getClass().getName()), t);
                        ok = false;
                    }
                }
            }
        }
        // Annotation processing
        listeners = getApplicationEventListeners();
        if (!getIgnoreAnnotations() && listeners != null) {
            for (int i = 0; i <  listeners.length; i++) {
                int j = (listeners.length - 1) - i;
                if (listeners[j] == null)
                    continue;
                try {
                    getAnnotationProcessor().preDestroy(listeners[j]);
                } catch (Throwable t) {
                    getLogger().error
                        (sm.getString("standardContext.listenerStop",
                            listeners[j].getClass().getName()), t);
                    ok = false;
                }
            }
        }
        setApplicationEventListeners(null);
        setApplicationLifecycleListeners(null);
        return (ok);
}

Send an application stop event to all interested listeners. Return true if all events were sent successfully, or false otherwise.

 public  void loadOnStartup(Container[] children) 
{
        // Collect "load on startup" servlets that need to be initialized
        TreeMap map = new TreeMap();
        for (int i = 0; i <  children.length; i++) {
            Wrapper wrapper = (Wrapper) children[i];
            int loadOnStartup = wrapper.getLoadOnStartup();
            if (loadOnStartup <  0)
                continue;
            Integer key = Integer.valueOf(loadOnStartup);
            ArrayList list = (ArrayList) map.get(key);
            if (list == null) {
                list = new ArrayList();
                map.put(key, list);
            }
            list.add(wrapper);
        }
        // Load the collected "load on startup" servlets
        Iterator keys = map.keySet().iterator();
        while (keys.hasNext()) {
            Integer key = (Integer) keys.next();
            ArrayList list = (ArrayList) map.get(key);
            Iterator wrappers = list.iterator();
            while (wrappers.hasNext()) {
                Wrapper wrapper = (Wrapper) wrappers.next();
                try {
                    wrapper.load();
                } catch (ServletException e) {
                    getLogger().error(sm.getString("standardWrapper.loadException",
                                      getName()), StandardWrapper.getRootCause(e));
                    // NOTE: load errors (including a servlet that throws
                    // UnavailableException from tht init() method) are NOT
                    // fatal to application startup
                }
            }
        }
}

Load and initialize all servlets marked "load on startup" in the web application deployment descriptor.

 public  void preDeregister() throws Exception 
{
        if( started ) {
            try {
                stop();
            } catch( Exception ex ) {
                log.error( "error stopping ", ex);
            }
        }
}

 public ObjectName preRegister(MBeanServer server,
    ObjectName name) throws Exception 
{
        if( oname != null ) {
            //log.info( "Already registered " + oname + " " + name);
            // Temporary - /admin uses the old names
            return name;
        }
        ObjectName result=super.preRegister(server,name);
        return name;
}

There are 2 cases: 1.The context is created and registered by internal APIS 2. The context is created by JMX, and it'll self-register.

 public synchronized  void reload() 
{
        // Validate our current component state
        if (!started)
            throw new IllegalStateException
                (sm.getString("containerBase.notStarted", logName()));
        // Make sure reloading is enabled
        //      if (!reloadable)
        //          throw new IllegalStateException
        //              (sm.getString("standardContext.notReloadable"));
        if(log.isInfoEnabled())
            log.info(sm.getString("standardContext.reloadingStarted"));
        // Stop accepting requests temporarily
        setPaused(true);
        try {
            stop();
        } catch (LifecycleException e) {
            log.error(sm.getString("standardContext.stoppingContext"), e);
        }
        try {
            start();
        } catch (LifecycleException e) {
            log.error(sm.getString("standardContext.startingContext"), e);
        }
        setPaused(false);
}

Reload this web application, if reloading is supported.

IMPLEMENTATION NOTE: This method is designed to deal with reloads required by changes to classes in the underlying repositories of our class loader. It does not handle changes to the web application deployment descriptor. If that has occurred, you should stop this Context and create (and start) a new Context instance instead.

 public  void removeApplicationListener(String listener) 
{
        synchronized (applicationListenersLock) {
            // Make sure this welcome file is currently present
            int n = -1;
            for (int i = 0; i <  applicationListeners.length; i++) {
                if (applicationListeners[i].equals(listener)) {
                    n = i;
                    break;
                }
            }
            if (n <  0)
                return;
            // Remove the specified constraint
            int j = 0;
            String results[] = new String[applicationListeners.length - 1];
            for (int i = 0; i <  applicationListeners.length; i++) {
                if (i != n)
                    results[j++] = applicationListeners[i];
            }
            applicationListeners = results;
        }
        // Inform interested listeners
        fireContainerEvent("removeApplicationListener", listener);
        // FIXME - behavior if already started?
}

Remove the specified application listener class from the set of listeners for this application.

 public  void removeApplicationParameter(String name) 
{
        synchronized (applicationParametersLock) {
            // Make sure this parameter is currently present
            int n = -1;
            for (int i = 0; i <  applicationParameters.length; i++) {
                if (name.equals(applicationParameters[i].getName())) {
                    n = i;
                    break;
                }
            }
            if (n <  0)
                return;
            // Remove the specified parameter
            int j = 0;
            ApplicationParameter results[] =
                new ApplicationParameter[applicationParameters.length - 1];
            for (int i = 0; i <  applicationParameters.length; i++) {
                if (i != n)
                    results[j++] = applicationParameters[i];
            }
            applicationParameters = results;
        }
        // Inform interested listeners
        fireContainerEvent("removeApplicationParameter", name);
}

Remove the application parameter with the specified name from the set for this application.

 public  void removeChild(Container child) 
{
        if (!(child instanceof Wrapper)) {
            throw new IllegalArgumentException
                (sm.getString("standardContext.notWrapper"));
        }
        super.removeChild(child);
}

Add a child Container, only if the proposed child is an implementation of Wrapper.

 public  void removeConstraint(SecurityConstraint constraint) 
{
        synchronized (constraintsLock) {
            // Make sure this constraint is currently present
            int n = -1;
            for (int i = 0; i <  constraints.length; i++) {
                if (constraints[i].equals(constraint)) {
                    n = i;
                    break;
                }
            }
            if (n <  0)
                return;
            // Remove the specified constraint
            int j = 0;
            SecurityConstraint results[] =
                new SecurityConstraint[constraints.length - 1];
            for (int i = 0; i <  constraints.length; i++) {
                if (i != n)
                    results[j++] = constraints[i];
            }
            constraints = results;
        }
        // Inform interested listeners
        fireContainerEvent("removeConstraint", constraint);
}

Remove the specified security constraint from this web application.

 public  void removeErrorPage(ErrorPage errorPage) 
{
        String exceptionType = errorPage.getExceptionType();
        if (exceptionType != null) {
            synchronized (exceptionPages) {
                exceptionPages.remove(exceptionType);
            }
        } else {
            synchronized (statusPages) {
                if (errorPage.getErrorCode() == 200) {
                    this.okErrorPage = null;
                }
                statusPages.remove(Integer.valueOf(errorPage.getErrorCode()));
            }
        }
        fireContainerEvent("removeErrorPage", errorPage);
}

Remove the error page for the specified error code or Java language exception, if it exists; otherwise, no action is taken.

 public  void removeFilterDef(FilterDef filterDef) 
{
        synchronized (filterDefs) {
            filterDefs.remove(filterDef.getFilterName());
        }
        fireContainerEvent("removeFilterDef", filterDef);
}

Remove the specified filter definition from this Context, if it exists; otherwise, no action is taken.

 public  void removeFilterMap(FilterMap filterMap) 
{
        synchronized (filterMapsLock) {
            // Make sure this filter mapping is currently present
            int n = -1;
            for (int i = 0; i <  filterMaps.length; i++) {
                if (filterMaps[i] == filterMap) {
                    n = i;
                    break;
                }
            }
            if (n <  0)
                return;
            // Remove the specified filter mapping
            FilterMap results[] = new FilterMap[filterMaps.length - 1];
            System.arraycopy(filterMaps, 0, results, 0, n);
            System.arraycopy(filterMaps, n + 1, results, n,
                             (filterMaps.length - 1) - n);
            filterMaps = results;
        }
        // Inform interested listeners
        fireContainerEvent("removeFilterMap", filterMap);
}

Remove a filter mapping from this Context.

 public  void removeInstanceListener(String listener) 
{
        synchronized (instanceListenersLock) {
            // Make sure this welcome file is currently present
            int n = -1;
            for (int i = 0; i <  instanceListeners.length; i++) {
                if (instanceListeners[i].equals(listener)) {
                    n = i;
                    break;
                }
            }
            if (n <  0)
                return;
            // Remove the specified constraint
            int j = 0;
            String results[] = new String[instanceListeners.length - 1];
            for (int i = 0; i <  instanceListeners.length; i++) {
                if (i != n)
                    results[j++] = instanceListeners[i];
            }
            instanceListeners = results;
        }
        // Inform interested listeners
        fireContainerEvent("removeInstanceListener", listener);
}

Remove a class name from the set of InstanceListener classes that will be added to newly created Wrappers.

 public  void removeMessageDestination(String name) 
{
        synchronized (messageDestinations) {
            messageDestinations.remove(name);
        }
        fireContainerEvent("removeMessageDestination", name);
}

Remove any message destination with the specified name.

 public  void removeMessageDestinationRef(String name) 
{
        namingResources.removeMessageDestinationRef(name);
        fireContainerEvent("removeMessageDestinationRef", name);
}

Remove any message destination ref with the specified name.

 public  void removeMimeMapping(String extension) 
{
        synchronized (mimeMappings) {
            mimeMappings.remove(extension);
        }
        fireContainerEvent("removeMimeMapping", extension);
}

Remove the MIME mapping for the specified extension, if it exists; otherwise, no action is taken.

 public  void removeNotificationListener(NotificationListener listener) throws ListenerNotFoundException 
{
    	broadcaster.removeNotificationListener(listener);
}

Remove a JMX-NotificationListener

 public  void removeNotificationListener(NotificationListener listener,
    NotificationFilter filter,
    Object object) throws ListenerNotFoundException 
{
    	broadcaster.removeNotificationListener(listener,filter,object);
}

 public  void removeParameter(String name) 
{
        synchronized (parameters) {
            parameters.remove(name);
        }
        fireContainerEvent("removeParameter", name);
}

Remove the context initialization parameter with the specified name, if it exists; otherwise, no action is taken.

 public  void removeRoleMapping(String role) 
{
        synchronized (roleMappings) {
            roleMappings.remove(role);
        }
        fireContainerEvent("removeRoleMapping", role);
}

Remove any security role reference for the specified name

 public  void removeSecurityRole(String role) 
{
        synchronized (securityRolesLock) {
            // Make sure this security role is currently present
            int n = -1;
            for (int i = 0; i <  securityRoles.length; i++) {
                if (role.equals(securityRoles[i])) {
                    n = i;
                    break;
                }
            }
            if (n <  0)
                return;
            // Remove the specified security role
            int j = 0;
            String results[] = new String[securityRoles.length - 1];
            for (int i = 0; i <  securityRoles.length; i++) {
                if (i != n)
                    results[j++] = securityRoles[i];
            }
            securityRoles = results;
        }
        // Inform interested listeners
        fireContainerEvent("removeSecurityRole", role);
}

Remove any security role with the specified name.

 public  void removeServletMapping(String pattern) 
{
        String name = null;
        synchronized (servletMappingsLock) {
            name = (String) servletMappings.remove(pattern);
        }
        Wrapper wrapper = (Wrapper) findChild(name);
        if( wrapper != null ) {
            wrapper.removeMapping(pattern);
        }
        mapper.removeWrapper(pattern);
        fireContainerEvent("removeServletMapping", pattern);
}

Remove any servlet mapping for the specified pattern, if it exists; otherwise, no action is taken.

 public  void removeTaglib(String uri) 
{
        synchronized (taglibs) {
            taglibs.remove(uri);
        }
        fireContainerEvent("removeTaglib", uri);
}

Remove the tag library location forthe specified tag library URI.

 public  void removeWatchedResource(String name) 
{
        
        synchronized (watchedResourcesLock) {
            // Make sure this watched resource is currently present
            int n = -1;
            for (int i = 0; i <  watchedResources.length; i++) {
                if (watchedResources[i].equals(name)) {
                    n = i;
                    break;
                }
            }
            if (n <  0)
                return;
            // Remove the specified watched resource
            int j = 0;
            String results[] = new String[watchedResources.length - 1];
            for (int i = 0; i <  watchedResources.length; i++) {
                if (i != n)
                    results[j++] = watchedResources[i];
            }
            watchedResources = results;
        }
        fireContainerEvent("removeWatchedResource", name);
}

Remove the specified watched resource name from the list associated with this Context.

 public  void removeWelcomeFile(String name) 
{
        synchronized (welcomeFilesLock) {
            // Make sure this welcome file is currently present
            int n = -1;
            for (int i = 0; i <  welcomeFiles.length; i++) {
                if (welcomeFiles[i].equals(name)) {
                    n = i;
                    break;
                }
            }
            if (n <  0)
                return;
            // Remove the specified constraint
            int j = 0;
            String results[] = new String[welcomeFiles.length - 1];
            for (int i = 0; i <  welcomeFiles.length; i++) {
                if (i != n)
                    results[j++] = welcomeFiles[i];
            }
            welcomeFiles = results;
        }
        // Inform interested listeners
        postWelcomeFiles();
        fireContainerEvent("removeWelcomeFile", name);
}

Remove the specified welcome file name from the list recognized by this Context.

 public  void removeWrapperLifecycle(String listener) 
{
        synchronized (wrapperLifecyclesLock) {
            // Make sure this welcome file is currently present
            int n = -1;
            for (int i = 0; i <  wrapperLifecycles.length; i++) {
                if (wrapperLifecycles[i].equals(listener)) {
                    n = i;
                    break;
                }
            }
            if (n <  0)
                return;
            // Remove the specified constraint
            int j = 0;
            String results[] = new String[wrapperLifecycles.length - 1];
            for (int i = 0; i <  wrapperLifecycles.length; i++) {
                if (i != n)
                    results[j++] = wrapperLifecycles[i];
            }
            wrapperLifecycles = results;
        }
        // Inform interested listeners
        fireContainerEvent("removeWrapperLifecycle", listener);
}

Remove a class name from the set of LifecycleListener classes that will be added to newly created Wrappers.

 public  void removeWrapperListener(String listener) 
{
        synchronized (wrapperListenersLock) {
            // Make sure this welcome file is currently present
            int n = -1;
            for (int i = 0; i <  wrapperListeners.length; i++) {
                if (wrapperListeners[i].equals(listener)) {
                    n = i;
                    break;
                }
            }
            if (n <  0)
                return;
            // Remove the specified constraint
            int j = 0;
            String results[] = new String[wrapperListeners.length - 1];
            for (int i = 0; i <  wrapperListeners.length; i++) {
                if (i != n)
                    results[j++] = wrapperListeners[i];
            }
            wrapperListeners = results;
        }
        // Inform interested listeners
        fireContainerEvent("removeWrapperListener", listener);
}

Remove a class name from the set of ContainerListener classes that will be added to newly created Wrappers.

 public boolean resourcesStart() 
{
        boolean ok = true;
        Hashtable env = new Hashtable();
        if (getParent() != null)
            env.put(ProxyDirContext.HOST, getParent().getName());
        env.put(ProxyDirContext.CONTEXT, getName());
        try {
            ProxyDirContext proxyDirContext =
                new ProxyDirContext(env, webappResources);
            if (webappResources instanceof FileDirContext) {
                filesystemBased = true;
                ((FileDirContext) webappResources).setCaseSensitive
                    (isCaseSensitive());
                ((FileDirContext) webappResources).setAllowLinking
                    (isAllowLinking());
            }
            if (webappResources instanceof BaseDirContext) {
                ((BaseDirContext) webappResources).setDocBase(getBasePath());
                ((BaseDirContext) webappResources).setCached
                    (isCachingAllowed());
                ((BaseDirContext) webappResources).setCacheTTL(getCacheTTL());
                ((BaseDirContext) webappResources).setCacheMaxSize
                    (getCacheMaxSize());
                ((BaseDirContext) webappResources).allocate();
            }
            // Register the cache in JMX
            if (isCachingAllowed()) {
                ObjectName resourcesName = 
                    new ObjectName(this.getDomain() + ":type=Cache,host=" 
                                   + getHostname() + ",path=" 
                                   + (("".equals(getPath()))?"/":getPath()));
                Registry.getRegistry(null, null).registerComponent
                    (proxyDirContext.getCache(), resourcesName, null);
            }
            this.resources = proxyDirContext;
        } catch (Throwable t) {
            log.error(sm.getString("standardContext.resourcesStart"), t);
            ok = false;
        }
        return (ok);
}

Allocate resources, including proxy. Return true if initialization was successfull, or false otherwise.

 public boolean resourcesStop() 
{
        boolean ok = true;
        try {
            if (resources != null) {
                if (resources instanceof Lifecycle) {
                    ((Lifecycle) resources).stop();
                }
                if (webappResources instanceof BaseDirContext) {
                    ((BaseDirContext) webappResources).release();
                }
                // Unregister the cache in JMX
                if (isCachingAllowed()) {
                    ObjectName resourcesName = 
                        new ObjectName(this.getDomain()
                                       + ":type=Cache,host=" 
                                       + getHostname() + ",path=" 
                                       + (("".equals(getPath()))?"/"
                                          :getPath()));
                    Registry.getRegistry(null, null)
                        .unregisterComponent(resourcesName);
                }
            }
        } catch (Throwable t) {
            log.error(sm.getString("standardContext.resourcesStop"), t);
            ok = false;
        }
        this.resources = null;
        return (ok);
}

Deallocate resources and destroy proxy.

 public  void setAllowLinking(boolean allowLinking) 
{
        this.allowLinking = allowLinking;
}

Set allow linking.

 public  void setAltDDName(String altDDName) 
{
        this.altDDName = altDDName;
        if (context != null) {
            context.setAttribute(Globals.ALT_DD_ATTR,altDDName);
        }
}

Set an alternate Deployment Descriptor name.

 public  void setAnnotationProcessor(AnnotationProcessor annotationProcessor) 
{
       this.annotationProcessor = annotationProcessor;
}

 public  void setAntiJARLocking(boolean antiJARLocking) 
{
        boolean oldAntiJARLocking = this.antiJARLocking;
        this.antiJARLocking = antiJARLocking;
        support.firePropertyChange("antiJARLocking",
                                   oldAntiJARLocking,
                                   this.antiJARLocking);
}

Set the antiJARLocking feature for this Context.

 public  void setAntiResourceLocking(boolean antiResourceLocking) 
{
        boolean oldAntiResourceLocking = this.antiResourceLocking;
        this.antiResourceLocking = antiResourceLocking;
        support.firePropertyChange("antiResourceLocking",
                                   oldAntiResourceLocking,
                                   this.antiResourceLocking);
}

Set the antiResourceLocking feature for this Context.

 public  void setApplicationEventListeners(Object[] listeners) 
{
        applicationEventListenersObjects = listeners;
}

Store the set of initialized application event listener objects, in the order they were specified in the web application deployment descriptor, for this application.

 public  void setApplicationLifecycleListeners(Object[] listeners) 
{
        applicationLifecycleListenersObjects = listeners;
}

Store the set of initialized application lifecycle listener objects, in the order they were specified in the web application deployment descriptor, for this application.

 public  void setAvailable(boolean available) 
{
        boolean oldAvailable = this.available;
        this.available = available;
        support.firePropertyChange("available",
                                   oldAvailable,
                                   this.available);
}

Set the application available flag for this Context.

 public  void setCacheMaxSize(int cacheMaxSize) 
{
        this.cacheMaxSize = cacheMaxSize;
}

Set the maximum size of the cache in KB.

 public  void setCacheObjectMaxSize(int cacheObjectMaxSize) 
{
        this.cacheObjectMaxSize = cacheObjectMaxSize;
}

Set the maximum size of objects to be placed the cache in KB.

 public  void setCacheTTL(int cacheTTL) 
{
        this.cacheTTL = cacheTTL;
}

Set cache TTL.

 public  void setCachingAllowed(boolean cachingAllowed) 
{
        this.cachingAllowed = cachingAllowed;
}

Set caching allowed flag.

 public  void setCaseSensitive(boolean caseSensitive) 
{
        this.caseSensitive = caseSensitive;
}

Set case sensitivity.

 public  void setCharsetMapper(CharsetMapper mapper) 
{
        CharsetMapper oldCharsetMapper = this.charsetMapper;
        this.charsetMapper = mapper;
        if( mapper != null )
            this.charsetMapperClass= mapper.getClass().getName();
        support.firePropertyChange("charsetMapper", oldCharsetMapper,
                                   this.charsetMapper);
}

Set the Locale to character set mapper for this Context.

 public  void setCharsetMapperClass(String mapper) 
{
        String oldCharsetMapperClass = this.charsetMapperClass;
        this.charsetMapperClass = mapper;
        support.firePropertyChange("charsetMapperClass",
                                   oldCharsetMapperClass,
                                   this.charsetMapperClass);
}

Set the Locale to character set mapper class for this Context.

 public  void setClearReferencesStopThreads(boolean clearReferencesStopThreads) 
{
        boolean oldClearReferencesStopThreads = this.clearReferencesStopThreads;
        this.clearReferencesStopThreads = clearReferencesStopThreads;
        support.firePropertyChange("clearReferencesStopThreads",
                                   oldClearReferencesStopThreads,
                                   this.clearReferencesStopThreads);
}

Set the clearReferencesStopThreads feature for this Context.

 public  void setCompilerClasspath(String compilerClasspath) 
{
        this.compilerClasspath = compilerClasspath;
}

Set the compiler classpath.

 public  void setConfigFile(String configFile) 
{
        this.configFile = configFile;
}

Set the path to a file to save this Context information.

 public  void setConfigured(boolean configured) 
{
        boolean oldConfigured = this.configured;
        this.configured = configured;
        support.firePropertyChange("configured",
                                   oldConfigured,
                                   this.configured);
}

Set the "correctly configured" flag for this Context. This can be set to false by startup listeners that detect a fatal configuration error to avoid the application from being made available.

 public  void setCookies(boolean cookies) 
{
        boolean oldCookies = this.cookies;
        this.cookies = cookies;
        support.firePropertyChange("cookies",
                                   oldCookies,
                                   this.cookies);
}

Set the "use cookies for session ids" flag.

 public  void setCrossContext(boolean crossContext) 
{
        boolean oldCrossContext = this.crossContext;
        this.crossContext = crossContext;
        support.firePropertyChange("crossContext",
                                   oldCrossContext,
                                   this.crossContext);
}

Set the "allow crossing servlet contexts" flag.

 public  void setDefaultContextXml(String defaultContextXml) 
{
        this.defaultContextXml = defaultContextXml;
}

Set the location of the default context xml that will be used. If not absolute, it'll be made relative to the engine's base dir ( which defaults to catalina.base system property ).

 public  void setDefaultWebXml(String defaultWebXml) 
{
        this.defaultWebXml = defaultWebXml;
}

Set the location of the default web xml that will be used. If not absolute, it'll be made relative to the engine's base dir ( which defaults to catalina.base system property ).

 public  void setDelegate(boolean delegate) 
{
        boolean oldDelegate = this.delegate;
        this.delegate = delegate;
        support.firePropertyChange("delegate", oldDelegate,
                                   this.delegate);
}

Set the "follow standard delegation model" flag used to configure our ClassLoader.

 public  void setDisplayName(String displayName) 
{
        String oldDisplayName = this.displayName;
        this.displayName = displayName;
        support.firePropertyChange("displayName", oldDisplayName,
                                   this.displayName);
}

Set the display name of this web application.

 public  void setDistributable(boolean distributable) 
{
        boolean oldDistributable = this.distributable;
        this.distributable = distributable;
        support.firePropertyChange("distributable",
                                   oldDistributable,
                                   this.distributable);
        // Bugzilla 32866
        if(getManager() != null) {
            if(log.isDebugEnabled()) {
                log.debug("Propagating distributable=" + distributable
                          + " to manager");
            }
            getManager().setDistributable(distributable);
        }
}

Set the distributable flag for this web application.

 public  void setDocBase(String docBase) 
{
        this.docBase = docBase;
}

Set the document root for this Context. This can be an absolute pathname, a relative pathname, or a URL.

 public  void setEngineName(String engineName) 
{
        this.engineName = engineName;
}

 public  void setIgnoreAnnotations(boolean ignoreAnnotations) 
{
        boolean oldIgnoreAnnotations = this.ignoreAnnotations;
        this.ignoreAnnotations = ignoreAnnotations;
        support.firePropertyChange("ignoreAnnotations", oldIgnoreAnnotations,
                this.ignoreAnnotations);
}

Set the boolean on the annotations parsing for this web application.

 public  void setJ2EEApplication(String j2EEApplication) 
{
        this.j2EEApplication = j2EEApplication;
}

 public  void setJ2EEServer(String j2EEServer) 
{
        this.j2EEServer = j2EEServer;
}

 public String[] setJavaVMs(String[] javaVMs) 
{
        return this.javaVMs = javaVMs;
}

 public  void setLazy(boolean lazy) 
{
        this.lazy = lazy;
}

 public synchronized  void setLoader(Loader loader) 
{
        super.setLoader(loader);
}

Set the Loader with which this Context is associated.

 public  void setLoginConfig(LoginConfig config) 
{
        // Validate the incoming property value
        if (config == null)
            throw new IllegalArgumentException
                (sm.getString("standardContext.loginConfig.required"));
        String loginPage = config.getLoginPage();
        if ((loginPage != null) && !loginPage.startsWith("/")) {
            if (isServlet22()) {
                if(log.isDebugEnabled())
                    log.debug(sm.getString("standardContext.loginConfig.loginWarning",
                                 loginPage));
                config.setLoginPage("/" + loginPage);
            } else {
                throw new IllegalArgumentException
                    (sm.getString("standardContext.loginConfig.loginPage",
                                  loginPage));
            }
        }
        String errorPage = config.getErrorPage();
        if ((errorPage != null) && !errorPage.startsWith("/")) {
            if (isServlet22()) {
                if(log.isDebugEnabled())
                    log.debug(sm.getString("standardContext.loginConfig.errorWarning",
                                 errorPage));
                config.setErrorPage("/" + errorPage);
            } else {
                throw new IllegalArgumentException
                    (sm.getString("standardContext.loginConfig.errorPage",
                                  errorPage));
            }
        }
        // Process the property setting change
        LoginConfig oldLoginConfig = this.loginConfig;
        this.loginConfig = config;
        support.firePropertyChange("loginConfig",
                                   oldLoginConfig, this.loginConfig);
}

Set the login configuration descriptor for this web application.

 public  void setName(String name) 
{
        super.setName( name );
        encodedPath = urlEncoder.encode(name);
}

 public  void setNamingContextListener(NamingContextListener namingContextListener) 
{
        this.namingContextListener = namingContextListener;
}

Naming context listener setter.

 public  void setNamingResources(NamingResources namingResources) 
{
        // Process the property setting change
        NamingResources oldNamingResources = this.namingResources;
        this.namingResources = namingResources;
        namingResources.setContainer(this);
        support.firePropertyChange("namingResources",
                                   oldNamingResources, this.namingResources);
}

Set the naming resources for this web application.

 public  void setOriginalDocBase(String docBase) 
{
        this.originalDocBase = docBase;
}

Set the original document root for this Context. This can be an absolute pathname, a relative pathname, or a URL.

 public  void setOverride(boolean override) 
{
        boolean oldOverride = this.override;
        this.override = override;
        support.firePropertyChange("override",
                                   oldOverride,
                                   this.override);
}

Set the DefaultContext override flag for this web application.

 public  void setPath(String path) 
{
        // XXX Use host in name
        setName(path);
}

Set the context path for this Context.

IMPLEMENTATION NOTE: The context path is used as the "name" of a Context, because it must be unique.

 public  void setPrivileged(boolean privileged) 
{
        boolean oldPrivileged = this.privileged;
        this.privileged = privileged;
        support.firePropertyChange("privileged",
                                   oldPrivileged,
                                   this.privileged);
}

Set the privileged flag for this web application.

 public  void setProcessTlds(boolean newProcessTlds) 
{
	processTlds = newProcessTlds;
}

Sets the process TLDs attribute.

 public  void setPublicId(String publicId) 
{
        if (log.isDebugEnabled())
            log.debug("Setting deployment descriptor public ID to '" +
                publicId + "'");
        String oldPublicId = this.publicId;
        this.publicId = publicId;
        support.firePropertyChange("publicId", oldPublicId, publicId);
}

Set the public identifier of the deployment descriptor DTD that is currently being parsed.

 public  void setReloadable(boolean reloadable) 
{
        boolean oldReloadable = this.reloadable;
        this.reloadable = reloadable;
        support.firePropertyChange("reloadable",
                                   oldReloadable,
                                   this.reloadable);
}

Set the reloadable flag for this web application.

 public  void setReplaceWelcomeFiles(boolean replaceWelcomeFiles) 
{
        boolean oldReplaceWelcomeFiles = this.replaceWelcomeFiles;
        this.replaceWelcomeFiles = replaceWelcomeFiles;
        support.firePropertyChange("replaceWelcomeFiles",
                                   oldReplaceWelcomeFiles,
                                   this.replaceWelcomeFiles);
}

Set the "replace welcome files" property.

 public synchronized  void setResources(DirContext resources) 
{
        if (started) {
            throw new IllegalStateException
                (sm.getString("standardContext.resources.started"));
        }
        DirContext oldResources = this.webappResources;
        if (oldResources == resources)
            return;
        if (resources instanceof BaseDirContext) {
            ((BaseDirContext) resources).setCached(isCachingAllowed());
            ((BaseDirContext) resources).setCacheTTL(getCacheTTL());
            ((BaseDirContext) resources).setCacheMaxSize(getCacheMaxSize());
            ((BaseDirContext) resources).setCacheObjectMaxSize(
                    getCacheObjectMaxSize());
        }
        if (resources instanceof FileDirContext) {
            filesystemBased = true;
            ((FileDirContext) resources).setCaseSensitive(isCaseSensitive());
            ((FileDirContext) resources).setAllowLinking(isAllowLinking());
        }
        this.webappResources = resources;
        // The proxied resources will be refreshed on start
        this.resources = null;
        support.firePropertyChange("resources", oldResources,
                                   this.webappResources);
}

Set the resources DirContext object with which this Container is associated.

 public  void setSaveConfig(boolean saveConfig) 
{
        this.saveConfig = saveConfig;
}

Set save config flag.

 public String setServer(String server) 
{
        return this.server=server;
}

 public  void setSessionTimeout(int timeout) 
{
        int oldSessionTimeout = this.sessionTimeout;
        /*
         * SRV.13.4 ("Deployment Descriptor"):
         * If the timeout is 0 or less, the container ensures the default
         * behaviour of sessions is never to time out.
         */
        this.sessionTimeout = (timeout == 0) ? -1 : timeout;
        support.firePropertyChange("sessionTimeout",
                                   oldSessionTimeout,
                                   this.sessionTimeout);
}

Set the default session timeout (in minutes) for this web application.

 public  void setStartupTime(long startupTime) 
{
        this.startupTime = startupTime;
}

 public  void setSwallowOutput(boolean swallowOutput) 
{
        boolean oldSwallowOutput = this.swallowOutput;
        this.swallowOutput = swallowOutput;
        support.firePropertyChange("swallowOutput",
                                   oldSwallowOutput,
                                   this.swallowOutput);
}

Set the value of the swallowOutput flag. If set to true, the system.out and system.err will be redirected to the logger during a servlet execution.

 public  void setTldNamespaceAware(boolean tldNamespaceAware) 
{
        this.tldNamespaceAware= tldNamespaceAware;
}

Set the namespace aware feature of the XML parser used when parsing xml instances.

 public  void setTldScanTime(long tldScanTime) 
{
        this.tldScanTime = tldScanTime;
}

 public  void setTldValidation(boolean tldValidation) 
{
        
        this.tldValidation = tldValidation;
}

Set the validation feature of the XML parser used when parsing tlds files.

 public  void setUnloadDelay(long unloadDelay) 
{
        long oldUnloadDelay = this.unloadDelay;
        this.unloadDelay = unloadDelay;
        support.firePropertyChange("unloadDelay",
                                   Long.valueOf(oldUnloadDelay),
                                   Long.valueOf(this.unloadDelay));
}

Set the value of the unloadDelay flag, which represents the amount of ms that the container will wait when unloading servlets. Setting this to a small value may cause more requests to fail to complete when stopping a web application.

 public  void setUnpackWAR(boolean unpackWAR) 
{
        this.unpackWAR = unpackWAR;
}

Unpack WAR flag mutator.

 public  void setUseHttpOnly(boolean useHttpOnly) 
{
        boolean oldUseHttpOnly = this.useHttpOnly;
        this.useHttpOnly = useHttpOnly;
        support.firePropertyChange("useHttpOnly",
                oldUseHttpOnly,
                this.useHttpOnly);
}

Sets the use HttpOnly cookies for session cookies flag.

 public  void setUseNaming(boolean useNaming) 
{
        this.useNaming = useNaming;
}

Enables or disables naming.

 public  void setWorkDir(String workDir) 
{
        this.workDir = workDir;
        if (started) {
            postWorkDirectory();
        }
}

Set the work directory for this Context.

 public  void setWrapperClass(String wrapperClassName) 
{
        this.wrapperClassName = wrapperClassName;
        try {
            wrapperClass = Class.forName(wrapperClassName);         
            if (!StandardWrapper.class.isAssignableFrom(wrapperClass)) {
                throw new IllegalArgumentException(
                    sm.getString("standardContext.invalidWrapperClass",
                                 wrapperClassName));
            }
        } catch (ClassNotFoundException cnfe) {
            throw new IllegalArgumentException(cnfe.getMessage());
        }
}

Set the Java class name of the Wrapper implementation used for servlets registered in this Context.

 public  void setXmlNamespaceAware(boolean webXmlNamespaceAware) 
{
        this.webXmlNamespaceAware= webXmlNamespaceAware;
}

Set the namespace aware feature of the XML parser used when parsing xml instances.

 public  void setXmlValidation(boolean webXmlValidation) 
{
        
        this.webXmlValidation = webXmlValidation;
}

Set the validation feature of the XML parser used when parsing xml instances.

 public synchronized  void start() throws LifecycleException 
{
        //if (lazy ) return;
        if (started) {
            if(log.isInfoEnabled())
                log.info(sm.getString("containerBase.alreadyStarted", logName()));
            return;
        }
        if( !initialized ) { 
            try {
                init();
            } catch( Exception ex ) {
                throw new LifecycleException("Error initializaing ", ex);
            }
        }
        if(log.isDebugEnabled())
            log.debug("Starting " + ("".equals(getName()) ? "ROOT" : getName()));
        // Set JMX object name for proper pipeline registration
        preRegisterJMX();
        if ((oname != null) && 
            (Registry.getRegistry(null, null).getMBeanServer().isRegistered(oname))) {
            // As things depend on the JMX registration, the context
            // must be reregistered again once properly initialized
            Registry.getRegistry(null, null).unregisterComponent(oname);
        }
        // Notify our interested LifecycleListeners
        lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
        setAvailable(false);
        setConfigured(false);
        boolean ok = true;
        // Add missing components as necessary
        if (webappResources == null) {   // (1) Required by Loader
            if (log.isDebugEnabled())
                log.debug("Configuring default Resources");
            try {
                if ((docBase != null) && (docBase.endsWith(".war")) && (!(new File(getBasePath())).isDirectory()))
                    setResources(new WARDirContext());
                else
                    setResources(new FileDirContext());
            } catch (IllegalArgumentException e) {
                log.error("Error initializing resources: " + e.getMessage());
                ok = false;
            }
        }
        if (ok) {
            if (!resourcesStart()) {
                log.error( "Error in resourceStart()");
                ok = false;
            }
        }
        // Look for a realm - that may have been configured earlier. 
        // If the realm is added after context - it'll set itself.
        // TODO: what is the use case for this ? 
        if( realm == null && mserver != null ) {
            ObjectName realmName=null;
            try {
                realmName=new ObjectName( getEngineName() + ":type=Realm,host=" + 
                        getHostname() + ",path=" + getPath());
                if( mserver.isRegistered(realmName ) ) {
                    mserver.invoke(realmName, "init", 
                            new Object[] {},
                            new String[] {}
                    );            
                }
            } catch( Throwable t ) {
                if(log.isDebugEnabled())
                    log.debug("No realm for this host " + realmName);
            }
        }
        if (getLoader() == null) {
            WebappLoader webappLoader = new WebappLoader(getParentClassLoader());
            webappLoader.setDelegate(getDelegate());
            setLoader(webappLoader);
        }
        // Initialize character set mapper
        getCharsetMapper();
        // Post work directory
        postWorkDirectory();
        // Validate required extensions
        boolean dependencyCheck = true;
        try {
            dependencyCheck = ExtensionValidator.validateApplication
                (getResources(), this);
        } catch (IOException ioe) {
            log.error("Error in dependencyCheck", ioe);
            dependencyCheck = false;
        }
        if (!dependencyCheck) {
            // do not make application available if depency check fails
            ok = false;
        }
        // Reading the "catalina.useNaming" environment variable
        String useNamingProperty = System.getProperty("catalina.useNaming");
        if ((useNamingProperty != null)
            && (useNamingProperty.equals("false"))) {
            useNaming = false;
        }
        if (ok && isUseNaming()) {
            if (namingContextListener == null) {
                namingContextListener = new NamingContextListener();
                namingContextListener.setName(getNamingContextName());
                addLifecycleListener(namingContextListener);
            }
        }
        // Standard container startup
        if (log.isDebugEnabled())
            log.debug("Processing standard container startup");
        // Binding thread
        ClassLoader oldCCL = bindThread();
        boolean mainOk = false;
        try {
            if (ok) {
                started = true;
                // Start our subordinate components, if any
                if ((loader != null) && (loader instanceof Lifecycle))
                    ((Lifecycle) loader).start();
                // Unbinding thread
                unbindThread(oldCCL);
                // Binding thread
                oldCCL = bindThread();
                // Initialize logger again. Other components might have used it too early, 
                // so it should be reset.
                logger = null;
                getLogger();
                if ((logger != null) && (logger instanceof Lifecycle))
                    ((Lifecycle) logger).start();
                if ((cluster != null) && (cluster instanceof Lifecycle))
                    ((Lifecycle) cluster).start();
                if ((realm != null) && (realm instanceof Lifecycle))
                    ((Lifecycle) realm).start();
                if ((resources != null) && (resources instanceof Lifecycle))
                    ((Lifecycle) resources).start();
                // Start our child containers, if any
                Container children[] = findChildren();
                for (int i = 0; i <  children.length; i++) {
                    if (children[i] instanceof Lifecycle)
                        ((Lifecycle) children[i]).start();
                }
                // Start the Valves in our pipeline (including the basic),
                // if any
                if (pipeline instanceof Lifecycle) {
                    ((Lifecycle) pipeline).start();
                }
                // Notify our interested LifecycleListeners
                lifecycle.fireLifecycleEvent(START_EVENT, null);
                // Acquire clustered manager
                Manager contextManager = null;
                if (manager == null) {
                    if ( (getCluster() != null) && distributable) {
                        try {
                            contextManager = getCluster().createManager(getName());
                        } catch (Exception ex) {
                            log.error("standardContext.clusterFail", ex);
                            ok = false;
                        }
                    } else {
                        contextManager = new StandardManager();
                    }
                } 
                // Configure default manager if none was specified
                if (contextManager != null) {
                    setManager(contextManager);
                }
                if (manager!=null && (getCluster() != null) && distributable) {
                    //let the cluster know that there is a context that is distributable
                    //and that it has its own manager
                    getCluster().registerManager(manager);
                }
                mainOk = true;
            }
        } finally {
            // Unbinding thread
            unbindThread(oldCCL);
            if (!mainOk) {
                // An exception occurred
                // Register with JMX anyway, to allow management
                registerJMX();
            }
        }
        if (!getConfigured()) {
            log.error( "Error getConfigured");
            ok = false;
        }
        // We put the resources into the servlet context
        if (ok)
            getServletContext().setAttribute
                (Globals.RESOURCES_ATTR, getResources());
        // Initialize associated mapper
        mapper.setContext(getPath(), welcomeFiles, resources);
        // Binding thread
        oldCCL = bindThread();
        // Set annotation processing parameter for Jasper (unfortunately, since
        // this can be configured in many places and not just in /WEB-INF/web.xml,
        // there are not many solutions)
        // Initialize annotation processor
        if (ok && !getIgnoreAnnotations()) {
            if (annotationProcessor == null) {
                if (isUseNaming() && namingContextListener != null) {
                    annotationProcessor = 
                        new DefaultAnnotationProcessor(namingContextListener.getEnvContext());
                } else {
                    annotationProcessor = new DefaultAnnotationProcessor(null);
                }
            }
            getServletContext().setAttribute
                (AnnotationProcessor.class.getName(), annotationProcessor);
        }
        try {
            // Create context attributes that will be required
            if (ok) {
                postWelcomeFiles();
            }
            if (ok) {
                // Notify our interested LifecycleListeners
                lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
            }
            // Configure and call application event listeners
            if (ok) {
                if (!listenerStart()) {
                    log.error( "Error listenerStart");
                    ok = false;
                }
            }
            try {
                // Start manager
                if ((manager != null) && (manager instanceof Lifecycle)) {
                    ((Lifecycle) getManager()).start();
                }
                // Start ContainerBackgroundProcessor thread
                super.threadStart();
            } catch(Exception e) {
                log.error("Error manager.start()", e);
                ok = false;
            }
            // Configure and call application filters
            if (ok) {
                if (!filterStart()) {
                    log.error( "Error filterStart");
                    ok = false;
                }
            }
            // Load and initialize all "load on startup" servlets
            if (ok) {
                loadOnStartup(findChildren());
            }
        } finally {
            // Unbinding thread
            unbindThread(oldCCL);
        }
        // Set available status depending upon startup success
        if (ok) {
            if (log.isDebugEnabled())
                log.debug("Starting completed");
            setAvailable(true);
        } else {
            log.error(sm.getString("standardContext.startFailed", getName()));
            try {
                stop();
            } catch (Throwable t) {
                log.error(sm.getString("standardContext.startCleanup"), t);
            }
            setAvailable(false);
        }
        // JMX registration
        registerJMX();
        startTime=System.currentTimeMillis();
        // Send j2ee.state.running notification 
        if (ok && (this.getObjectName() != null)) {
            Notification notification = 
                new Notification("j2ee.state.running", this.getObjectName(), 
                                sequenceNumber++);
            broadcaster.sendNotification(notification);
        }
        // Close all JARs right away to avoid always opening a peak number 
        // of files on startup
        if (getLoader() instanceof WebappLoader) {
            ((WebappLoader) getLoader()).closeJARs(true);
        }
        // Reinitializing if something went wrong
        if (!ok && started) {
            stop();
        }
        //cacheContext();
}

Start this Context component.

 public  void startRecursive() throws LifecycleException 
{
        // nothing to start recursive, the servlets will be started by load-on-startup
        start();
}

 public synchronized  void stop() throws LifecycleException 
{
        // Validate and update our current component state
        if (!started) {
            if(log.isInfoEnabled())
                log.info(sm.getString("containerBase.notStarted", logName()));
            return;
        }
        // Notify our interested LifecycleListeners
        lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);
        // Send j2ee.state.stopping notification 
        if (this.getObjectName() != null) {
            Notification notification = 
                new Notification("j2ee.state.stopping", this.getObjectName(), 
                                sequenceNumber++);
            broadcaster.sendNotification(notification);
        }
        // Mark this application as unavailable while we shut down
        setAvailable(false);
        // Binding thread
        ClassLoader oldCCL = bindThread();
        try {
            // Stop our child containers, if any
            Container[] children = findChildren();
            for (int i = 0; i <  children.length; i++) {
                if (children[i] instanceof Lifecycle)
                    ((Lifecycle) children[i]).stop();
            }
            // Stop our filters
            filterStop();
            // Stop ContainerBackgroundProcessor thread
            super.threadStop();
            if ((manager != null) && (manager instanceof Lifecycle)) {
                ((Lifecycle) manager).stop();
            }
            // Stop our application listeners
            listenerStop();
            // Finalize our character set mapper
            setCharsetMapper(null);
            // Normal container shutdown processing
            if (log.isDebugEnabled())
                log.debug("Processing standard container shutdown");
            // Notify our interested LifecycleListeners
            lifecycle.fireLifecycleEvent(STOP_EVENT, null);
            started = false;
            // Stop the Valves in our pipeline (including the basic), if any
            if (pipeline instanceof Lifecycle) {
                ((Lifecycle) pipeline).stop();
            }
            // Clear all application-originated servlet context attributes
            if (context != null)
                context.clearAttributes();
            // Stop resources
            resourcesStop();
            if ((realm != null) && (realm instanceof Lifecycle)) {
                ((Lifecycle) realm).stop();
            }
            if ((cluster != null) && (cluster instanceof Lifecycle)) {
                ((Lifecycle) cluster).stop();
            }
            if ((logger != null) && (logger instanceof Lifecycle)) {
                ((Lifecycle) logger).stop();
            }
            if ((loader != null) && (loader instanceof Lifecycle)) {
                ((Lifecycle) loader).stop();
            }
        } finally {
            // Unbinding thread
            unbindThread(oldCCL);
        }
        // Send j2ee.state.stopped notification 
        if (this.getObjectName() != null) {
            Notification notification = 
                new Notification("j2ee.state.stopped", this.getObjectName(), 
                                sequenceNumber++);
            broadcaster.sendNotification(notification);
        }
        // Reset application context
        context = null;
        // This object will no longer be visible or used. 
        try {
            resetContext();
        } catch( Exception ex ) {
            log.error( "Error reseting context " + this + " " + ex, ex );
        }
        // Notify our interested LifecycleListeners
        lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
        if (log.isDebugEnabled())
            log.debug("Stopping complete");
}

Stop this Context component.

 public String toString() 
{
        StringBuffer sb = new StringBuffer();
        if (getParent() != null) {
            sb.append(getParent().toString());
            sb.append(".");
        }
        sb.append("StandardContext[");
        sb.append(getName());
        sb.append("]");
        return (sb.toString());
}

Return a String representation of this component.