001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: *
017: * $Header:$
018: */
019: package org.apache.beehive.controls.runtime.servlet;
020:
021: import javax.servlet.ServletResponse;
022: import javax.servlet.ServletResponseWrapper;
023:
024: import org.apache.beehive.controls.api.context.ControlContainerContext;
025: import org.apache.beehive.controls.api.context.ControlThreadContext;
026:
027: /**
028: * This class is the contextual service implementation for javax.servlet.ServletResponse. It
029: * acts as an intermediary between the client and the ServletResponse instance held by the
030: * associated ServletBeanContext. It validates that attempt to access the ServletResponse
031: * only occur during the servlet request processing lifecycle, then delegates to the underlying
032: * ServletResponse instance for actual services.
033: */
034: /* package */class ServletResponseService implements ServletResponse {
035: /**
036: * This static helper class derives from javax.servlet.ServletRequestWrapper and can
037: * be used to wrap a ServletRequestService instance in cases where the client expects
038: * to be able to use the standard wrapper interfaces to unwrap requests.
039: */
040: private static class Wrapper extends ServletResponseWrapper {
041: Wrapper(ServletResponseService responseService) {
042: super (responseService);
043: _responseService = responseService;
044: }
045:
046: /**
047: * Overrides the default ServletRequestWrapper.getRequest implementation. Rather
048: * than just returning the request passed into the constructor (i.e. the request
049: * service), it will go unwrap step further and return the current (active) http
050: * request.
051: */
052: public ServletResponse getResponse() {
053: return _responseService.getServletResponse();
054: }
055:
056: ServletResponseService _responseService;
057: }
058:
059: /* package */ServletResponseService(ServletBeanContext beanContext) {
060: _beanContext = beanContext;
061: }
062:
063: /**
064: * This method retrieves the current ServletBeanContext for the service. It is capable
065: * of reassociating with the current active context, if the service instance has been
066: * serialized/deserialized.
067: */
068: final protected ServletBeanContext getServletBeanContext() {
069: if (_beanContext == null) {
070: ControlContainerContext ccc = ControlThreadContext
071: .getContext();
072: if (!(ccc instanceof ServletBeanContext))
073: throw new IllegalStateException(
074: "No ServletBeanContext available");
075:
076: _beanContext = (ServletBeanContext) ccc;
077: }
078: return _beanContext;
079: }
080:
081: final protected ServletResponse getServletResponse() {
082: ServletResponse servletResponse = getServletBeanContext()
083: .getServletResponse();
084: if (servletResponse == null)
085: throw new IllegalStateException(
086: "No access to ServletResponse outside request processing");
087: return servletResponse;
088: }
089:
090: /**
091: * This method returns a ServletResponseWrapper instance that wraps the response service.
092: * This is useful in instances where there is code that uses the wrapper interfaces to
093: * unwrap responses to get to the 'root' response.
094: */
095: /* package */ServletResponseWrapper getResponseWrapper() {
096: return new Wrapper(this );
097: }
098:
099: public java.lang.String getCharacterEncoding() {
100: return getServletResponse().getCharacterEncoding();
101: }
102:
103: public java.lang.String getContentType() {
104: return getServletResponse().getContentType();
105: }
106:
107: public javax.servlet.ServletOutputStream getOutputStream()
108: throws java.io.IOException {
109: return getServletResponse().getOutputStream();
110: }
111:
112: public java.io.PrintWriter getWriter() throws java.io.IOException {
113: return getServletResponse().getWriter();
114: }
115:
116: public void setCharacterEncoding(java.lang.String charset) {
117: getServletResponse().setCharacterEncoding(charset);
118: }
119:
120: public void setContentLength(int len) {
121: getServletResponse().setContentLength(len);
122: }
123:
124: public void setContentType(java.lang.String type) {
125: getServletResponse().setContentType(type);
126: }
127:
128: public void setBufferSize(int size) {
129: getServletResponse().setBufferSize(size);
130: }
131:
132: public int getBufferSize() {
133: return getServletResponse().getBufferSize();
134: }
135:
136: public void flushBuffer() throws java.io.IOException {
137: getServletResponse().flushBuffer();
138: }
139:
140: public void resetBuffer() {
141: getServletResponse().resetBuffer();
142: }
143:
144: public boolean isCommitted() {
145: return getServletResponse().isCommitted();
146: }
147:
148: public void reset() {
149: getServletResponse().reset();
150: }
151:
152: public void setLocale(java.util.Locale loc) {
153: getServletResponse().setLocale(loc);
154: }
155:
156: public java.util.Locale getLocale() {
157: return getServletResponse().getLocale();
158: }
159:
160: transient private ServletBeanContext _beanContext; // never access directly
161: }
|