Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Class
org.apache.tomcat.core.Context

Packages that use Context
org.apache.tomcat.core | Architecture
org.apache.tomcat.facade | Servlet Facades
org.apache.tomcat.modules.aaa |
org.apache.tomcat.modules.config |
org.apache.tomcat.modules.generators |
org.apache.tomcat.modules.loggers |
org.apache.tomcat.modules.mappers |
org.apache.tomcat.modules.server | Interceptors that are used to connect with a web server, including the standalone http implementation.
org.apache.tomcat.modules.session |
org.apache.tomcat.startup |

Uses of Context in org.apache.tomcat.core

Fields in org.apache.tomcat.core declared as Context
`protected Context` | `Request.context`
`protected Context` | `BaseInterceptor.ctx`

Methods in org.apache.tomcat.core that return Context
`Context` | `ServerSession.getContext()` The web application that creates this session.
`Context` | `Request.getContext()`
`Context` | `ContextManager.getContext(java.lang.String name)`
`Context` | `ContextManager.getContext(Context base, java.lang.String path)` Find a context by doing a sub-request and mapping the request against the active rules ( that means you could use a /~costin if a UserHomeInterceptor is present ) The new context will be in the same virtual host as base.
`Context` | `ContextManager.createContext()`
`Context` | `Container.getContext()` The parent web application, if any.
`Context` | `BaseInterceptor.getContext()`

Methods in org.apache.tomcat.core with parameters of type Context
`void` | `ServerSession.setContext(Context ctx)`
`void` | `Request.setContext(Context context)` Called by mapper interceptors after the context is found or directly by server adapters when this is known in advance
`void` | `ContextManager.addContext(Context ctx)` Adds a new Context to the set managed by this ContextManager.
`void` | `ContextManager.removeContext(Context context)` Shut down and removes a context from service.
`Request` | `ContextManager.createRequest(Context ctx, java.lang.String urlPath)` Create a new sub-request in a given context, set the context "hint" This is a particular case of sub-request that can't get out of a context ( and we know the context before - so no need to compute it again) Note that session and all stuff will still be computed.
`Context` | `ContextManager.getContext(Context base, java.lang.String path)` Find a context by doing a sub-request and mapping the request against the active rules ( that means you could use a /~costin if a UserHomeInterceptor is present ) The new context will be in the same virtual host as base.
`void` | `Container.setContext(Context ctx)` Set the context, if this container is part of a web application.
`java.lang.Object` | `BaseInterceptor.getInfo(Context ctx, Request request, int id, java.lang.String key)` Hook for lazy evaluation of request info.
`int` | `BaseInterceptor.setInfo(Context ctx, Request request, int id, java.lang.String key, java.lang.Object obj)`
`void` | `BaseInterceptor.addInterceptor(ContextManager cm, Context ctx, BaseInterceptor i)` Hook called when a new interceptor is added.
`void` | `BaseInterceptor.removeInterceptor(ContextManager cm, Context ctx, BaseInterceptor i)` Hook called when interceptors are removed.
`void` | `BaseInterceptor.addContext(ContextManager cm, Context ctx)` Called when a context is added to a CM.
`void` | `BaseInterceptor.removeContext(ContextManager cm, Context ctx)` Called when a context is removed from a CM.
`void` | `BaseInterceptor.contextInit(Context ctx)` Notify when a context is initialized.
`void` | `BaseInterceptor.contextShutdown(Context ctx)` Called when a context is stoped, before removeContext.
`void` | `BaseInterceptor.contextState(Context ctx, int newState)` Notify that the context state changed
`void` | `BaseInterceptor.reload(Request req, Context ctx)` Reload notification - called whenever a reload is done.
`void` | `BaseInterceptor.copyContext(Request req, Context oldC, Context newC)` Reload notification - called whenever a full reload is done.
`void` | `BaseInterceptor.addSecurityConstraint(Context ctx, java.lang.String path, Container ct)`
`void` | `BaseInterceptor.preServletInit(Context ctx, Handler sw)` Servlet Init notification
`void` | `BaseInterceptor.postServletInit(Context ctx, Handler sw)`
`void` | `BaseInterceptor.preServletDestroy(Context ctx, Handler sw)` Servlet Destroy notification
`void` | `BaseInterceptor.postServletDestroy(Context ctx, Handler sw)`
`void` | `BaseInterceptor.setContext(Context ctx)` Called for context-level interceptors
`int` | `BaseInterceptor.registerHooks(Hooks h, ContextManager cm, Context ctx)` Special method for self-registered hooks, intended to support a mechanism similar with Apache2.0 and further extensibility without interface changes.

Uses of Context in org.apache.tomcat.facade

Fields in org.apache.tomcat.facade declared as Context
`protected Context` | `ServletHandler.context`

Methods in org.apache.tomcat.facade that return Context
`Context` | `ServletInfo.getContext()`
`Context` | `ServletHandler.getContext()` Return the context associated with the handler

Methods in org.apache.tomcat.facade with parameters of type Context
`void` | `WebXmlReader.contextInit(Context ctx)`
`void` | `TagPoolManagerInterceptor.contextInit(Context ctx)` This hook is called when an application context is initialized.
`void` | `TagPoolManagerInterceptor.contextShutdown(Context ctx)` This hook is called when an application context is shutdown.
`void` | `ServletInfo.addServlet(Context ctx, WebXmlReader wxR)` This method can called to add the servlet to the web application.
`void` | `ServletInfo.setContext(Context ctx)`
`void` | `ServletHandler.setContext(Context context)`
`void` | `Servlet22Interceptor.contextShutdown(Context ctx)` Call servlet.destroy() for all servlets, as required by the spec
`void` | `Servlet22Interceptor.addContext(ContextManager cm, Context ctx)`
`void` | `LoadOnStartupInterceptor.contextInit(Context ctx)`
`void` | `JspInterceptor.addContext(ContextManager cm, Context ctx)` Jasper-specific initializations, add work dir to classpath,
`void` | `JspInterceptor.contextInit(Context ctx)` Do the needed initialization if jspServlet is used.
`void` | `JspInterceptor.preServletInit(Context ctx, Handler sw)` Set the HttpJspBase classloader before init, as required by Jasper

Constructors in org.apache.tomcat.facade with parameters of type Context
`Servlet22Interceptor(Context ctx)`

Uses of Context in org.apache.tomcat.modules.aaa

Methods in org.apache.tomcat.modules.aaa with parameters of type Context
`void` | `SimpleRealm.contextInit(Context ctx)`
`void` | `JDBCRealm.contextShutdown(Context ctx)`
`void` | `JDBCRealm.contextInit(Context ctx)`
`void` | `AccessInterceptor.contextInit(Context ctx)`

Uses of Context in org.apache.tomcat.modules.config

Methods in org.apache.tomcat.modules.config with parameters of type Context
`void` | `WorkDirSetup.addContext(ContextManager cm, Context ctx)`
`void` | `WorkDirSetup.contextShutdown(Context ctx)`
`java.lang.Object` | `WorkDirSetup.getInfo(Context ctx, Request req, int info, java.lang.String k)`
`void` | `TrustedLoader.contextInit(Context ctx)`
`void` | `TrustedLoader.reload(Request req, Context context)` Again, remove and add back
`void` | `TrustedLoader.loadInterceptors(Context ctx, java.io.File modulesF, java.util.Vector modulesV)`
`void` | `ServerXmlReader.addInterceptor(ContextManager cm, Context ctx, BaseInterceptor module)` When this module is added, it'll automatically load a configuration file and add all global modules.
`void` | `ProfileLoader.addContext(ContextManager cm, Context ctx)` Adjust paths for a context - make the base and all loggers point to canonical paths.
`void` | `ProfileLoader.addInterceptor(ContextManager cm, Context ctx, BaseInterceptor module)` Read the profiles.
`void` | `ProfileLoader.addTagRules(ContextManager cm, Context ctx, XmlMapper xh)`
`void` | `PolicyLoader.addInterceptor(ContextManager cm, Context ctx, BaseInterceptor module)`
`void` | `PolicyInterceptor.addInterceptor(ContextManager cm, Context ctx, BaseInterceptor module)`
`protected void` | `PolicyInterceptor.addDefaultPermissions(Context context, java.lang.String base, java.security.Permissions p)` Add a default set of permissions to the context
`void` | `PolicyInterceptor.contextInit(Context context)`
`void` | `PathSetter.addInterceptor(ContextManager cm, Context ctx, BaseInterceptor module)` Adjust context manager paths.
`void` | `PathSetter.addContext(ContextManager cm, Context ctx)` Adjust paths for a context - make the base and all loggers point to canonical paths.
`void` | `LogSetter.addInterceptor(ContextManager cm, Context ctx, BaseInterceptor module)` The log will be added and opened as soon as the module is added to the server
`void` | `LogSetter.addContext(ContextManager cm, Context ctx)` Set default ServletLog for Context if necessary
`void` | `LoaderInterceptor11.addContext(ContextManager cm, Context context)` Add all WEB-INF/classes and WEB-INF/lib to the context path
`void` | `LoaderInterceptor11.contextInit(Context ctx)` setup the ClassLoader for this context.
`void` | `LoaderInterceptor11.copyContext(Request req, Context oldC, Context newC)`
`void` | `LoaderInterceptor11.reload(Request req, Context context)` Construct another class loader, when the context is reloaded.
`void` | `LoaderInterceptor11.prepareClassLoader(Context context)` Initialize the class loader.
`protected java.lang.ClassLoader` | `LoaderInterceptor11.constructLoader(Context context)` Override this method to provide an alternate loader (or create a new interceptor )
`java.lang.Object` | `LoaderInterceptor11.getInfo(Context ctx, Request req, int info, java.lang.String k)`
`void` | `JservConfig.contextInit(Context ctx)`
`protected boolean` | `JservConfig.addMapping(Context ctx, Container ct, java.io.PrintWriter pw)`
`void` | `HookSetter.addInterceptor(ContextManager cm, Context ctx, BaseInterceptor module)` When this module is added, it'll automatically load a configuration file and add all global modules.
`void` | `BaseJkConfig.addInterceptor(ContextManager cm, Context ctx, BaseInterceptor bi)`
`void` | `BaseJkConfig.contextInit(Context ctx)`
`protected boolean` | `BaseJkConfig.addMapping(Context ctx, Container ct, java.io.PrintWriter pw)`
`protected java.lang.String` | `BaseJkConfig.getAbsoluteDocBase(Context context)`
`void` | `AutoDeploy.addInterceptor(ContextManager cm, Context ctx, BaseInterceptor module)` Find all wars and expand them.
`void` | `AutoDeploy.addContext(ContextManager cm, Context ctx)`
`void` | `AutoDeploy.contextInit(Context context)`
`void` | `AutoDeploy.reload(Request req, Context context)`

Uses of Context in org.apache.tomcat.modules.generators

Methods in org.apache.tomcat.modules.generators with parameters of type Context
`void` | `StaticInterceptor.contextInit(Context ctx)`
`void` | `Jdk12Interceptor.preServletInit(Context ctx, Handler sw)`
`void` | `Jdk12Interceptor.preServletDestroy(Context ctx, Handler sw)` Servlet Destroy notification
`void` | `Jdk12Interceptor.postServletDestroy(Context ctx, Handler sw)`
`void` | `Jdk12Interceptor.postServletInit(Context ctx, Handler sw)`
`void` | `ErrorHandler.contextInit(Context ctx)` Add default error handlers
`Handler` | `ErrorHandler.getHandlerForPath(ContextManager cm, Context ctx, java.lang.String path)`

Uses of Context in org.apache.tomcat.modules.loggers

Methods in org.apache.tomcat.modules.loggers with parameters of type Context
`int` | `LogEvents.registerHooks(Hooks hooks, ContextManager cm, Context ctx)`
`void` | `LogEvents.contextInit(Context ctx)`
`void` | `LogEvents.contextShutdown(Context ctx)`
`void` | `LogEvents.addServlet(Context ctx, Handler sw)` Notify when a new servlet is added
`void` | `LogEvents.removeServlet(Context ctx, Handler sw)` Notify when a servlet is removed from context
`void` | `LogEvents.addMapping(Context ctx, java.lang.String path, Handler servlet)`
`void` | `LogEvents.removeMapping(Context ctx, java.lang.String path)`
`void` | `LogEvents.addSecurityConstraint(Context ctx, java.lang.String[] path, java.lang.String[] methods, java.lang.String transport, java.lang.String[] roles)`
`void` | `LogEvents.addInterceptor(ContextManager cm, Context ctx, BaseInterceptor i)`
`void` | `LogEvents.addContext(ContextManager cm, Context ctx)` Called when a context is added to a CM
`void` | `LogEvents.removeContext(ContextManager cm, Context ctx)` Called when a context is removed from a CM
`void` | `LogEvents.preServletInit(Context ctx, Handler sw)` Servlet Init notification
`void` | `LogEvents.postServletInit(Context ctx, Handler sw)`
`void` | `LogEvents.preServletDestroy(Context ctx, Handler sw)` Servlet Destroy notification
`void` | `LogEvents.postServletDestroy(Context ctx, Handler sw)`

Uses of Context in org.apache.tomcat.modules.mappers

Methods in org.apache.tomcat.modules.mappers with parameters of type Context
`void` | `SimpleMapper1.addContext(ContextManager cm, Context ctx)` Called when a context is added.
`void` | `SimpleMapper1.removeContext(ContextManager cm, Context ctx)` Called when a context is removed from a CM - we must ask the mapper to remove all the maps related with this context
`void` | `ReloadInterceptor.addContext(ContextManager cm, Context context)`
`void` | `ReloadInterceptor.contextInit(Context context)` Example of adding web.xml to the dependencies.
`void` | `ReloadInterceptor.reload(Request req, Context context)`
`protected void` | `ReloadInterceptor.loaderHook(DependManager dm, Context context)`
`java.lang.Object` | `DecodeInterceptor.getInfo(Context ctx, Request req, int info, java.lang.String k)`
`int` | `DecodeInterceptor.setInfo(Context ctx, Request req, int info, java.lang.String k, java.lang.Object v)`

Uses of Context in org.apache.tomcat.modules.server

Methods in org.apache.tomcat.modules.server with parameters of type Context
`java.lang.Object` | `Http10Interceptor.getInfo(Context ctx, Request request, int id, java.lang.String key)` getInfo calls for SSL data

Uses of Context in org.apache.tomcat.modules.session

Methods in org.apache.tomcat.modules.session with parameters of type Context
`void` | `SimpleSessionStore.copyContext(Request req, Context oldC, Context newC)`
`void` | `SimpleSessionStore.reload(Request req, Context ctx)`
`void` | `SimpleSessionStore.contextInit(Context ctx)` Init session management stuff for this context.
`void` | `SimpleSessionStore.contextShutdown(Context ctx)` Notification of context shutdown.
`java.util.Enumeration` | `SimpleSessionStore.getSessionIds(Context ctx)`
`java.util.Enumeration` | `SimpleSessionStore.getSessions(Context ctx)`
`int` | `SimpleSessionStore.getSessionCount(Context ctx)`
`int` | `SimpleSessionStore.getRecycledCount(Context ctx)`
`ServerSession` | `SimpleSessionStore.findSession(Context ctx, java.lang.String sessionId)`
`ServerSession` | `SimpleSessionStore.SimpleSessionManager.getNewSession(Request req, Context ctx)`
`ServerSession` | `SimpleSessionStore.SimpleSessionManager.cloneSession(Request req, Context ctx, java.lang.String oldS)`

Uses of Context in org.apache.tomcat.startup

Methods in org.apache.tomcat.startup that return Context
`Context` | `EmbededTomcat.addContext(java.lang.String ctxPath, java.net.URL docRoot, java.lang.String[] hosts)` Add and init a context.
`Context` | `EmbededTomcat.getContext(java.lang.String host, java.lang.String cpath)` Find the context mounted at /cpath for a virtual host.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

Copyright © 2001 Apache Software Foundation. All Rights Reserved.