View Javadoc

    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 }