1
2
3 /*
4 * The contents of this file are subject to the terms
5 * of the Common Development and Distribution License
6 * (the "License"). You may not use this file except
7 * in compliance with the License.
8 *
9 * You can obtain a copy of the license at
10 * glassfish/bootstrap/legal/CDDLv1.0.txt or
11 * https://glassfish.dev.java.net/public/CDDLv1.0.html.
12 * See the License for the specific language governing
13 * permissions and limitations under the License.
14 *
15 * When distributing Covered Code, include this CDDL
16 * HEADER in each file and include the License file at
17 * glassfish/bootstrap/legal/CDDLv1.0.txt. If applicable,
18 * add the following below this CDDL HEADER, with the
19 * fields enclosed by brackets "[]" replaced with your
20 * own identifying information: Portions Copyright [yyyy]
21 * [name of copyright owner]
22 *
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 *
25 * Portions Copyright Apache Software Foundation.
26 */
27
28 package javax.servlet;
29
30 import java.io.OutputStream;
31 import java.io.IOException;
32 import java.io.CharConversionException;
33 import java.text.MessageFormat;
34 import java.util.ResourceBundle;
35
36 /**
37 * Provides an output stream for sending binary data to the
38 * client. A <code>ServletOutputStream</code> object is normally retrieved
39 * via the {@link ServletResponse#getOutputStream} method.
40 *
41 * <p>This is an abstract class that the servlet container implements.
42 * Subclasses of this class
43 * must implement the <code>java.io.OutputStream.write(int)</code>
44 * method.
45 *
46 *
47 * @author Various
48 *
49 * @see ServletResponse
50 *
51 */
52
53 public abstract class ServletOutputStream extends OutputStream {
54
55 private static final String LSTRING_FILE = "javax.servlet.LocalStrings";
56 private static ResourceBundle lStrings =
57 ResourceBundle.getBundle(LSTRING_FILE);
58
59
60
61 /**
62 *
63 * Does nothing, because this is an abstract class.
64 *
65 */
66
67 protected ServletOutputStream() { }
68
69
70 /**
71 * Writes a <code>String</code> to the client,
72 * without a carriage return-line feed (CRLF)
73 * character at the end.
74 *
75 *
76 * @param s the <code>String</code> to send to the client
77 *
78 * @exception IOException if an input or output exception occurred
79 *
80 */
81
82 public void print(String s) throws IOException {
83 if (s==null) s="null";
84 int len = s.length();
85 for (int i = 0; i < len; i++) {
86 char c = s.charAt (i);
87
88 //
89 // XXX NOTE: This is clearly incorrect for many strings,
90 // but is the only consistent approach within the current
91 // servlet framework. It must suffice until servlet output
92 // streams properly encode their output.
93 //
94 if ((c & 0xff00) != 0) { // high order byte must be zero
95 String errMsg = lStrings.getString("err.not_iso8859_1");
96 Object[] errArgs = new Object[1];
97 errArgs[0] = new Character(c);
98 errMsg = MessageFormat.format(errMsg, errArgs);
99 throw new CharConversionException(errMsg);
100 }
101 write (c);
102 }
103 }
104
105
106
107 /**
108 * Writes a <code>boolean</code> value to the client,
109 * with no carriage return-line feed (CRLF)
110 * character at the end.
111 *
112 * @param b the <code>boolean</code> value
113 * to send to the client
114 *
115 * @exception IOException if an input or output exception occurred
116 *
117 */
118
119 public void print(boolean b) throws IOException {
120 String msg;
121 if (b) {
122 msg = lStrings.getString("value.true");
123 } else {
124 msg = lStrings.getString("value.false");
125 }
126 print(msg);
127 }
128
129
130
131 /**
132 * Writes a character to the client,
133 * with no carriage return-line feed (CRLF)
134 * at the end.
135 *
136 * @param c the character to send to the client
137 *
138 * @exception IOException if an input or output exception occurred
139 *
140 */
141
142 public void print(char c) throws IOException {
143 print(String.valueOf(c));
144 }
145
146
147
148
149 /**
150 *
151 * Writes an int to the client,
152 * with no carriage return-line feed (CRLF)
153 * at the end.
154 *
155 * @param i the int to send to the client
156 *
157 * @exception IOException if an input or output exception occurred
158 *
159 */
160
161 public void print(int i) throws IOException {
162 print(String.valueOf(i));
163 }
164
165
166
167
168 /**
169 *
170 * Writes a <code>long</code> value to the client,
171 * with no carriage return-line feed (CRLF) at the end.
172 *
173 * @param l the <code>long</code> value
174 * to send to the client
175 *
176 * @exception IOException if an input or output exception
177 * occurred
178 *
179 */
180
181 public void print(long l) throws IOException {
182 print(String.valueOf(l));
183 }
184
185
186
187 /**
188 *
189 * Writes a <code>float</code> value to the client,
190 * with no carriage return-line feed (CRLF) at the end.
191 *
192 * @param f the <code>float</code> value
193 * to send to the client
194 *
195 * @exception IOException if an input or output exception occurred
196 *
197 *
198 */
199
200 public void print(float f) throws IOException {
201 print(String.valueOf(f));
202 }
203
204
205
206 /**
207 *
208 * Writes a <code>double</code> value to the client,
209 * with no carriage return-line feed (CRLF) at the end.
210 *
211 * @param d the <code>double</code> value
212 * to send to the client
213 *
214 * @exception IOException if an input or output exception occurred
215 *
216 */
217
218 public void print(double d) throws IOException {
219 print(String.valueOf(d));
220 }
221
222
223
224 /**
225 * Writes a carriage return-line feed (CRLF)
226 * to the client.
227 *
228 *
229 *
230 * @exception IOException if an input or output exception occurred
231 *
232 */
233
234 public void println() throws IOException {
235 print("\r\n");
236 }
237
238
239
240 /**
241 * Writes a <code>String</code> to the client,
242 * followed by a carriage return-line feed (CRLF).
243 *
244 *
245 * @param s the <code>String</code> to write to the client
246 *
247 * @exception IOException if an input or output exception occurred
248 *
249 */
250
251 public void println(String s) throws IOException {
252 print(s);
253 println();
254 }
255
256
257
258
259 /**
260 *
261 * Writes a <code>boolean</code> value to the client,
262 * followed by a
263 * carriage return-line feed (CRLF).
264 *
265 *
266 * @param b the <code>boolean</code> value
267 * to write to the client
268 *
269 * @exception IOException if an input or output exception occurred
270 *
271 */
272
273 public void println(boolean b) throws IOException {
274 print(b);
275 println();
276 }
277
278
279
280 /**
281 *
282 * Writes a character to the client, followed by a carriage
283 * return-line feed (CRLF).
284 *
285 * @param c the character to write to the client
286 *
287 * @exception IOException if an input or output exception occurred
288 *
289 */
290
291 public void println(char c) throws IOException {
292 print(c);
293 println();
294 }
295
296
297
298 /**
299 *
300 * Writes an int to the client, followed by a
301 * carriage return-line feed (CRLF) character.
302 *
303 *
304 * @param i the int to write to the client
305 *
306 * @exception IOException if an input or output exception occurred
307 *
308 */
309
310 public void println(int i) throws IOException {
311 print(i);
312 println();
313 }
314
315
316
317 /**
318 *
319 * Writes a <code>long</code> value to the client, followed by a
320 * carriage return-line feed (CRLF).
321 *
322 *
323 * @param l the <code>long</code> value to write to the client
324 *
325 * @exception IOException if an input or output exception occurred
326 *
327 */
328
329 public void println(long l) throws IOException {
330 print(l);
331 println();
332 }
333
334
335
336 /**
337 *
338 * Writes a <code>float</code> value to the client,
339 * followed by a carriage return-line feed (CRLF).
340 *
341 * @param f the <code>float</code> value
342 * to write to the client
343 *
344 *
345 * @exception IOException if an input or output exception
346 * occurred
347 *
348 */
349
350 public void println(float f) throws IOException {
351 print(f);
352 println();
353 }
354
355
356
357 /**
358 *
359 * Writes a <code>double</code> value to the client,
360 * followed by a carriage return-line feed (CRLF).
361 *
362 *
363 * @param d the <code>double</code> value
364 * to write to the client
365 *
366 * @exception IOException if an input or output exception occurred
367 *
368 */
369
370 public void println(double d) throws IOException {
371 print(d);
372 println();
373 }
374 }