001 /*
002 * Copyright 1999-2001,2004 The Apache Software Foundation.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.apache.commons.workflow.web;
018
019
020 import java.io.ByteArrayOutputStream;
021 import java.io.CharArrayWriter;
022 import java.io.IOException;
023 import java.io.PrintWriter;
024 import javax.servlet.ServletOutputStream;
025 import javax.servlet.ServletResponse;
026 import javax.servlet.ServletResponseWrapper;
027
028
029 /**
030 * <p>Implementation of <code>HttpServletResponseWrapper</code> for use in
031 * <code>IncludeStep23</code>. It buffers the response characters up into
032 * a memory-resident buffer that can be converted into a String by calling
033 * <code>getContent()</code>.</p>
034 *
035 * @version $Revision: 155475 $ $Date: 2005-02-26 13:31:11 +0000 (Sat, 26 Feb 2005) $
036 * @author Craig R. McClanahan
037 */
038
039 public class IncludeResponse23 extends ServletResponseWrapper {
040
041
042 // ----------------------------------------------------------- Constructors
043
044
045 /**
046 * Construct a new response wrapper according to the specified parameters.
047 *
048 * @param response The servlet response we are wrapping
049 */
050 public IncludeResponse23(ServletResponse response) {
051
052 super(response);
053
054 }
055
056
057 // ----------------------------------------------------- Instance Variables
058
059
060 /**
061 * Accumulator for output that is generated via
062 * <code>getOutputStream()</code>.
063 */
064 protected ByteArrayOutputStream baos = null;
065
066
067 /**
068 * Accumulator for output that is generated via
069 * <code>getWriter()</code>.
070 */
071 protected CharArrayWriter caw = null;
072
073
074 // --------------------------------------------------------- Public Methods
075
076
077 /**
078 * Swallow any attempt to flush the response buffer.
079 */
080 public void flushBuffer() throws IOException {
081
082 ; // No action is required
083
084 }
085
086
087 /**
088 * Return the character encoding for the included response (if any).
089 */
090 public String getCharacterEncoding() {
091
092 return (null); // FIXME - getCharacterEncoding()
093
094 }
095
096
097 /**
098 * Return the response data written to this response as a String.
099 *
100 * @exception IOException if a conversion error occurs
101 */
102 public String getContent() throws IOException {
103
104 String encoding = getCharacterEncoding();
105 if (baos != null) {
106 if (encoding == null)
107 return (baos.toString());
108 else
109 return (baos.toString(encoding));
110 } else if (caw != null) {
111 return (caw.toString());
112 } else {
113 return ("");
114 }
115
116 }
117
118
119 /**
120 * Return a ServletOutputStream that can be used to accumulate the response
121 * data for the included resource.
122 *
123 * @exception IOException if an I/O error occurs
124 */
125 public ServletOutputStream getOutputStream() throws IOException {
126
127 if (caw != null)
128 throw new IllegalStateException("getWriter() already called");
129 baos = new ByteArrayOutputStream();
130 // return (new IncludeOutputStream23(this));
131 return (null); // FIXME - getOutputStream()
132
133 }
134
135
136 /**
137 * Return a PrintWriter that can be used to accumulate the response data
138 * for the included resource.
139 *
140 * @exception IOException if an I/O error occurs
141 */
142 public PrintWriter getWriter() throws IOException {
143
144 if (baos != null)
145 throw new IllegalStateException
146 ("getOutputStream() already called");
147 caw = new CharArrayWriter();
148 // return (new IncludeWriter23(this));
149 return (null); // FIXME - getWriter()
150
151 }
152
153
154 /**
155 * Reset the response buffer and all headers.
156 */
157 public void reset() {
158
159 resetBuffer();
160
161 }
162
163
164 /**
165 * Reset the response buffer to contain no data.
166 */
167 public void resetBuffer() {
168
169 if (baos != null)
170 baos.reset();
171 else if (caw != null)
172 caw.reset();
173
174 }
175
176
177 /**
178 * Set the content type (and possibly the character encoding) of the
179 * response data.
180 *
181 * @param contentType The new content type
182 */
183 public void setContentType(String contentType) {
184
185 ; // FIXME - setContentType()
186
187 }
188
189
190 // -------------------------------------------------------- Package Methods
191
192
193 /**
194 * Write a sequence of bytes to our accumulator.
195 *
196 * @param b The byte array
197 */
198 void write(byte b[]) {
199
200 baos.write(b, 0, b.length);
201
202 }
203
204
205 /**
206 * Write a sequence of bytes to our accumulator.
207 *
208 * @param b The byte array
209 * @param off Starting offset
210 * @param len Number of bytes to be written
211 */
212 void write(byte b[], int off, int len) {
213
214 baos.write(b, off, len);
215
216 }
217
218
219 /**
220 * Write a sequence of characters to our accumulator.
221 *
222 * @param c The character array
223 */
224 void write(char c[]) {
225
226 caw.write(c, 0, c.length);
227
228 }
229
230
231 /**
232 * Write a sequence of characters to our accumulator.
233 *
234 * @param c The character array
235 * @param off Starting offset
236 * @param len Number of bytes to be written
237 */
238 void write(char c[], int off, int len) {
239
240 caw.write(c, off, len);
241
242 }
243
244
245 /**
246 * Write a single byte or character (based on which accumulator has
247 * been created) to our accumulator.
248 *
249 * @param value The byte or character to be written
250 */
251 void write(int value) {
252
253 if (baos != null)
254 baos.write(value);
255 else
256 caw.write(value);
257
258 }
259
260
261 /**
262 * Write a sequence of characters to our accumulator.
263 *
264 * @param s The character string
265 */
266 void write(String s) {
267
268 caw.write(s, 0, s.length());
269
270 }
271
272
273 /**
274 * Write a sequence of characters to our accumulator.
275 *
276 * @param s The character string
277 * @param off Starting offset
278 * @param len Number of characters to write
279 */
280 void write(String s, int off, int len) {
281
282 caw.write(s, off, len);
283
284 }
285
286
287 }