001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one
003     * or more contributor license agreements.  See the NOTICE file
004     * distributed with this work for additional information
005     * regarding copyright ownership.  The ASF licenses this file
006     * to you under the Apache License, Version 2.0 (the
007     * "License"); you may not use this file except in compliance
008     * with the License.  You may obtain a copy of the License at
009     *
010     *  http://www.apache.org/licenses/LICENSE-2.0
011     *
012     * Unless required by applicable law or agreed to in writing,
013     * software distributed under the License is distributed on an
014     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015     * KIND, either express or implied.  See the License for the
016     * specific language governing permissions and limitations
017     * under the License.
018     */
019    
020    //
021    // This source code implements specifications defined by the Java
022    // Community Process. In order to remain compliant with the specification
023    // DO NOT add / change / or delete method signatures!
024    //
025    
026    package javax.servlet;
027    
028    import java.io.CharConversionException;
029    import java.io.IOException;
030    import java.io.OutputStream;
031    import java.text.MessageFormat;
032    import java.util.ResourceBundle;
033    
034    /**
035     * Provides an output stream for sending binary data to the
036     * client. A <code>ServletOutputStream</code> object is normally retrieved
037     * via the {@link ServletResponse#getOutputStream} method.
038     *
039     * <p>This is an abstract class that the servlet container implements.
040     * Subclasses of this class
041     * must implement the <code>java.io.OutputStream.write(int)</code>
042     * method.
043     *
044     * @see ServletResponse
045     *
046     * @version $Rev: 467553 $ $Date: 2006-10-25 06:01:51 +0200 (Mi, 25. Okt 2006) $
047     */
048    public abstract class ServletOutputStream extends OutputStream {
049        private static final String LSTRING_FILE = "javax.servlet.LocalStrings";
050        private static ResourceBundle lStrings = ResourceBundle.getBundle(LSTRING_FILE);
051    
052        /**
053         * Does nothing, because this is an abstract class.
054         */
055        protected ServletOutputStream() {
056        }
057    
058        /**
059         * Writes a <code>String</code> to the client,
060         * without a carriage return-line feed (CRLF)
061         * character at the end.
062         *
063         * @param s the <code>String</code> to send to the client
064         *
065         * @exception IOException if an input or output exception occurred
066         */
067        public void print(String s) throws IOException {
068            if (s == null) s = "null";
069            int len = s.length();
070            for (int i = 0; i < len; i++) {
071                char c = s.charAt(i);
072    
073                //
074                // XXX NOTE:  This is clearly incorrect for many strings,
075                // but is the only consistent approach within the current
076                // servlet framework.  It must suffice until servlet output
077                // streams properly encode their output.
078                //
079                if ((c & 0xff00) != 0) { // high order byte must be zero
080                    String errMsg = lStrings.getString("err.not_iso8859_1");
081                    Object[] errArgs = new Object[1];
082                    errArgs[0] = new Character(c);
083                    errMsg = MessageFormat.format(errMsg, errArgs);
084                    throw new CharConversionException(errMsg);
085                }
086                write(c);
087            }
088        }
089    
090    
091        /**
092         * Writes a <code>boolean</code> value to the client,
093         * with no carriage return-line feed (CRLF)
094         * character at the end.
095         *
096         * @param b the <code>boolean</code> value
097         * to send to the client
098         *
099         * @exception IOException if an input or output exception occurred
100         */
101        public void print(boolean b) throws IOException {
102            String msg;
103            if (b) {
104                msg = lStrings.getString("value.true");
105            } else {
106                msg = lStrings.getString("value.false");
107            }
108            print(msg);
109        }
110    
111        /**
112         * Writes a character to the client,
113         * with no carriage return-line feed (CRLF)
114         * at the end.
115         *
116         * @param c the character to send to the client
117         *
118         * @exception IOException if an input or output exception occurred
119         */
120        public void print(char c) throws IOException {
121            print(String.valueOf(c));
122        }
123    
124        /**
125         * Writes an int to the client,
126         * with no carriage return-line feed (CRLF)
127         * at the end.
128         *
129         * @param i the int to send to the client
130         *
131         * @exception IOException if an input or output exception occurred
132         */
133        public void print(int i) throws IOException {
134            print(String.valueOf(i));
135        }
136    
137        /**
138         * Writes a <code>long</code> value to the client,
139         * with no carriage return-line feed (CRLF) at the end.
140         *
141         * @param l the <code>long</code> value
142         * to send to the client
143         *
144         * @exception IOException if an input or output exception
145         * occurred
146         */
147        public void print(long l) throws IOException {
148            print(String.valueOf(l));
149        }
150    
151        /**
152         * Writes a <code>float</code> value to the client,
153         * with no carriage return-line feed (CRLF) at the end.
154         *
155         * @param f the <code>float</code> value
156         * to send to the client
157         *
158         * @exception IOException if an input or output exception occurred
159         */
160        public void print(float f) throws IOException {
161            print(String.valueOf(f));
162        }
163    
164        /**
165         * Writes a <code>double</code> value to the client,
166         * with no carriage return-line feed (CRLF) at the end.
167         *
168         * @param d the <code>double</code> value
169         * to send to the client
170         *
171         * @exception IOException if an input or output exception occurred
172         */
173        public void print(double d) throws IOException {
174            print(String.valueOf(d));
175        }
176    
177        /**
178         * Writes a carriage return-line feed (CRLF)
179         * to the client.
180         *
181         * @exception IOException if an input or output exception occurred
182         */
183        public void println() throws IOException {
184            print("\r\n");
185        }
186    
187        /**
188         * Writes a <code>String</code> to the client,
189         * followed by a carriage return-line feed (CRLF).
190         *
191         * @param s the </code>String</code> to write to the client
192         *
193         * @exception IOException if an input or output exception occurred
194         */
195        public void println(String s) throws IOException {
196            print(s);
197            println();
198        }
199    
200        /**
201         * Writes a <code>boolean</code> value to the client,
202         * followed by a
203         * carriage return-line feed (CRLF).
204         *
205         * @param b the <code>boolean</code> value
206         * to write to the client
207         *
208         * @exception IOException if an input or output exception occurred
209         */
210        public void println(boolean b) throws IOException {
211            print(b);
212            println();
213        }
214    
215        /**
216         * Writes a character to the client, followed by a carriage
217         * return-line feed (CRLF).
218         *
219         * @param c the character to write to the client
220         *
221         * @exception IOException if an input or output exception occurred
222         */
223        public void println(char c) throws IOException {
224            print(c);
225            println();
226        }
227    
228        /**
229         * Writes an int to the client, followed by a
230         * carriage return-line feed (CRLF) character.
231         *
232         * @param i the int to write to the client
233         *
234         * @exception IOException if an input or output exception occurred
235         */
236        public void println(int i) throws IOException {
237            print(i);
238            println();
239        }
240    
241        /**
242         * Writes a <code>long</code> value to the client, followed by a
243         * carriage return-line feed (CRLF).
244         *
245         * @param l the <code>long</code> value to write to the client
246         *
247         * @exception IOException if an input or output exception occurred
248         */
249        public void println(long l) throws IOException {
250            print(l);
251            println();
252        }
253    
254        /**
255         * Writes a <code>float</code> value to the client,
256         * followed by a carriage return-line feed (CRLF).
257         *
258         * @param f the <code>float</code> value to write to the client
259         *
260         * @exception IOException if an input or output exception occurred
261         */
262        public void println(float f) throws IOException {
263            print(f);
264            println();
265        }
266    
267        /**
268         * Writes a <code>double</code> value to the client,
269         * followed by a carriage return-line feed (CRLF).
270         *
271         * @param d the <code>double</code> value
272         * to write to the client
273         *
274         * @exception IOException if an input or output exception occurred
275         */
276        public void println(double d) throws IOException {
277            print(d);
278            println();
279        }
280    }