JspWriterImpl


1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.apache.jasper.runtime;
19  
20  import java.io.IOException  ;
21  import java.io.Writer  ;
22  import java.security.AccessController  ;
23  import java.security.PrivilegedAction  ;
24  
25  import javax.servlet.ServletResponse  ;
26  import javax.servlet.jsp.JspWriter  ;
27  
28  import org.apache.jasper.Constants;
29  import org.apache.jasper.compiler.Localizer;
30  import org.apache.jasper.security.SecurityUtil;
31  
32  /**
33   * Write text to a character-output stream, buffering characters so as
34   * to provide for the efficient writing of single characters, arrays,
35   * and strings. 
36   *
37   * Provide support for discarding for the output that has been 
38   * buffered. 
39   * 
40   * This needs revisiting when the buffering problems in the JSP spec
41   * are fixed -akv 
42   *
43   * @author Anil K. Vijendran
44   */
45  public class JspWriterImpl extends JspWriter   {
46      
47      private Writer   out;
48      private ServletResponse   response;    
49      private char cb[];
50      private int nextChar;
51      private boolean flushed = false;
52      private boolean closed = false;
53      
54      public JspWriterImpl() {
55          super( Constants.DEFAULT_BUFFER_SIZE, true );
56      }
57      
58      /**
59       * Create a buffered character-output stream that uses a default-sized
60       * output buffer.
61       *
62       * @param  response  A Servlet Response
63       */
64      public JspWriterImpl(ServletResponse   response) {
65          this(response, Constants.DEFAULT_BUFFER_SIZE, true);
66      }
67      
68      /**
69       * Create a new buffered character-output stream that uses an output
70       * buffer of the given size.
71       *
72       * @param  response A Servlet Response
73       * @param  sz       Output-buffer size, a positive integer
74       *
75       * @exception  IllegalArgumentException  If sz is <= 0
76       */
77      public JspWriterImpl(ServletResponse   response, int sz, 
78              boolean autoFlush) {
79          super(sz, autoFlush);
80          if (sz < 0)
81              throw new IllegalArgumentException  ("Buffer size <= 0");
82          this.response = response;
83          cb = sz == 0 ? null : new char[sz];
84          nextChar = 0;
85      }
86      
87      void init( ServletResponse   response, int sz, boolean autoFlush ) {
88          this.response= response;
89          if( sz > 0 && ( cb == null || sz > cb.length ) )
90              cb=new char[sz];
91          nextChar = 0;
92          this.autoFlush=autoFlush;
93          this.bufferSize=sz;
94      }
95      
96      /** Package-level access
97       */
98      void recycle() {
99          flushed = false;
100         closed = false;
101         out = null;
102         nextChar = 0;
103         response = null;
104     }
105     
106     /**
107      * Flush the output buffer to the underlying character stream, without
108      * flushing the stream itself.  This method is non-private only so that it
109      * may be invoked by PrintStream.
110      */
111     protected final void flushBuffer() throws IOException   {
112         if (bufferSize == 0)
113             return;
114         flushed = true;
115         ensureOpen();
116         if (nextChar == 0)
117             return;
118         initOut();
119         out.write(cb, 0, nextChar);
120         nextChar = 0;
121     }
122     
123     private void initOut() throws IOException   {
124         if (out == null) {
125             out = response.getWriter();
126         }
127     }
128     
129     private String   getLocalizeMessage(final String   message){
130         if (SecurityUtil.isPackageProtectionEnabled()){
131             return (String  )AccessController.doPrivileged(new PrivilegedAction  (){
132                 public Object   run(){
133                     return Localizer.getMessage(message); 
134                 }
135             });
136         } else {
137             return Localizer.getMessage(message);
138         }
139     }
140     
141     /**
142      * Discard the output buffer.
143      */
144     public final void clear() throws IOException   {
145         if ((bufferSize == 0) && (out != null))
146             // clear() is illegal after any unbuffered output (JSP.5.5)
147             throw new IllegalStateException  (
148                     getLocalizeMessage("jsp.error.ise_on_clear"));
149         if (flushed)
150             throw new IOException  (
151                     getLocalizeMessage("jsp.error.attempt_to_clear_flushed_buffer"));
152         ensureOpen();
153         nextChar = 0;
154     }
155     
156     public void clearBuffer() throws IOException   {
157         if (bufferSize == 0)
158             throw new IllegalStateException  (
159                     getLocalizeMessage("jsp.error.ise_on_clear"));
160         ensureOpen();
161         nextChar = 0;
162     }
163     
164     private final void bufferOverflow() throws IOException   {
165         throw new IOException  (getLocalizeMessage("jsp.error.overflow"));
166     }
167     
168     /**
169      * Flush the stream.
170      *
171      */
172     public void flush()  throws IOException   {
173         flushBuffer();
174         if (out != null) {
175             out.flush();
176         }
177     }
178     
179     /**
180      * Close the stream.
181      *
182      */
183     public void close() throws IOException   {
184         if (response == null || closed)
185             // multiple calls to close is OK
186             return;
187         flush();
188         if (out != null)
189             out.close();
190         out = null;
191         closed = true;
192     }
193     
194     /**
195      * @return the number of bytes unused in the buffer
196      */
197     public int getRemaining() {
198         return bufferSize - nextChar;
199     }
200     
201     /** check to make sure that the stream has not been closed */
202     private void ensureOpen() throws IOException   {
203         if (response == null || closed)
204             throw new IOException  ("Stream closed");
205     }
206     
207     
208     /**
209      * Write a single character.
210      */
211     public void write(int c) throws IOException   {
212         ensureOpen();
213         if (bufferSize == 0) {
214             initOut();
215             out.write(c);
216         }
217         else {
218             if (nextChar >= bufferSize)
219                 if (autoFlush)
220                     flushBuffer();
221                 else
222                     bufferOverflow();
223             cb[nextChar++] = (char) c;
224         }
225     }
226     
227     /**
228      * Our own little min method, to avoid loading java.lang.Math if we've run
229      * out of file descriptors and we're trying to print a stack trace.
230      */
231     private int min(int a, int b) {
232         if (a < b) return a;
233         return b;
234     }
235     
236     /**
237      * Write a portion of an array of characters.
238      *
239      * <p> Ordinarily this method stores characters from the given array into
240      * this stream's buffer, flushing the buffer to the underlying stream as
241      * needed.  If the requested length is at least as large as the buffer,
242      * however, then this method will flush the buffer and write the characters
243      * directly to the underlying stream.  Thus redundant
244      * <code>DiscardableBufferedWriter</code>s will not copy data unnecessarily.
245      *
246      * @param  cbuf  A character array
247      * @param  off   Offset from which to start reading characters
248      * @param  len   Number of characters to write
249      */
250     public void write(char cbuf[], int off, int len) 
251     throws IOException   
252     {
253         ensureOpen();
254         
255         if (bufferSize == 0) {
256             initOut();
257             out.write(cbuf, off, len);
258             return;
259         }
260         
261         if ((off < 0) || (off > cbuf.length) || (len < 0) ||
262                 ((off + len) > cbuf.length) || ((off + len) < 0)) {
263             throw new IndexOutOfBoundsException  ();
264         } else if (len == 0) {
265             return;
266         } 
267         
268         if (len >= bufferSize) {
269             /* If the request length exceeds the size of the output buffer,
270              flush the buffer and then write the data directly.  In this
271              way buffered streams will cascade harmlessly. */
272             if (autoFlush)
273                 flushBuffer();
274             else
275                 bufferOverflow();
276             initOut();
277             out.write(cbuf, off, len);
278             return;
279         }
280         
281         int b = off, t = off + len;
282         while (b < t) {
283             int d = min(bufferSize - nextChar, t - b);
284             System.arraycopy(cbuf, b, cb, nextChar, d);
285             b += d;
286             nextChar += d;
287             if (nextChar >= bufferSize) 
288                 if (autoFlush)
289                     flushBuffer();
290                 else
291                     bufferOverflow();
292         }
293         
294     }
295     
296     /**
297      * Write an array of characters.  This method cannot be inherited from the
298      * Writer class because it must suppress I/O exceptions.
299      */
300     public void write(char buf[]) throws IOException   {
301         write(buf, 0, buf.length);
302     }
303     
304     /**
305      * Write a portion of a String.
306      *
307      * @param  s     String to be written
308      * @param  off   Offset from which to start reading characters
309      * @param  len   Number of characters to be written
310      */
311     public void write(String   s, int off, int len) throws IOException   {
312         ensureOpen();
313         if (bufferSize == 0) {
314             initOut();
315             out.write(s, off, len);
316             return;
317         }
318         int b = off, t = off + len;
319         while (b < t) {
320             int d = min(bufferSize - nextChar, t - b);
321             s.getChars(b, b + d, cb, nextChar);
322             b += d;
323             nextChar += d;
324             if (nextChar >= bufferSize) 
325                 if (autoFlush)
326                     flushBuffer();
327                 else
328                     bufferOverflow();
329         }
330     }
331     
332     /**
333      * Write a string.  This method cannot be inherited from the Writer class
334      * because it must suppress I/O exceptions.
335      */
336     public void write(String   s) throws IOException   {
337         // Simple fix for Bugzilla 35410
338         // Calling the other write function so as to init the buffer anyways
339         if(s == null) {
340             write(s, 0, 0);
341         } else {
342             write(s, 0, s.length());
343         }
344     }
345     
346     
347     static String   lineSeparator = System.getProperty("line.separator");
348     
349     /**
350      * Write a line separator.  The line separator string is defined by the
351      * system property <tt>line.separator</tt>, and is not necessarily a single
352      * newline ('\n') character.
353      *
354      * @exception  IOException  If an I/O error occurs
355      */
356     
357     public void newLine() throws IOException   {
358         write(lineSeparator);
359     }
360     
361     
362     /* Methods that do not terminate lines */
363     
364     /**
365      * Print a boolean value.  The string produced by <code>{@link
366      * java.lang.String#valueOf(boolean)}</code> is translated into bytes
367      * according to the platform's default character encoding, and these bytes
368      * are written in exactly the manner of the <code>{@link
369      * #write(int)}</code> method.
370      *
371      * @param      b   The <code>boolean</code> to be printed
372      */
373     public void print(boolean b) throws IOException   {
374         write(b ? "true" : "false");
375     }
376     
377     /**
378      * Print a character.  The character is translated into one or more bytes
379      * according to the platform's default character encoding, and these bytes
380      * are written in exactly the manner of the <code>{@link
381      * #write(int)}</code> method.
382      *
383      * @param      c   The <code>char</code> to be printed
384      */
385     public void print(char c) throws IOException   {
386         write(String.valueOf(c));
387     }
388     
389     /**
390      * Print an integer.  The string produced by <code>{@link
391      * java.lang.String#valueOf(int)}</code> is translated into bytes according
392      * to the platform's default character encoding, and these bytes are
393      * written in exactly the manner of the <code>{@link #write(int)}</code>
394      * method.
395      *
396      * @param      i   The <code>int</code> to be printed
397      */
398     public void print(int i) throws IOException   {
399         write(String.valueOf(i));
400     }
401     
402     /**
403      * Print a long integer.  The string produced by <code>{@link
404      * java.lang.String#valueOf(long)}</code> is translated into bytes
405      * according to the platform's default character encoding, and these bytes
406      * are written in exactly the manner of the <code>{@link #write(int)}</code>
407      * method.
408      *
409      * @param      l   The <code>long</code> to be printed
410      */
411     public void print(long l) throws IOException   {
412         write(String.valueOf(l));
413     }
414     
415     /**
416      * Print a floating-point number.  The string produced by <code>{@link
417      * java.lang.String#valueOf(float)}</code> is translated into bytes
418      * according to the platform's default character encoding, and these bytes
419      * are written in exactly the manner of the <code>{@link #write(int)}</code>
420      * method.
421      *
422      * @param      f   The <code>float</code> to be printed
423      */
424     public void print(float f) throws IOException   {
425         write(String.valueOf(f));
426     }
427     
428     /**
429      * Print a double-precision floating-point number.  The string produced by
430      * <code>{@link java.lang.String#valueOf(double)}</code> is translated into
431      * bytes according to the platform's default character encoding, and these
432      * bytes are written in exactly the manner of the <code>{@link
433      * #write(int)}</code> method.
434      *
435      * @param      d   The <code>double</code> to be printed
436      */
437     public void print(double d) throws IOException   {
438         write(String.valueOf(d));
439     }
440     
441     /**
442      * Print an array of characters.  The characters are converted into bytes
443      * according to the platform's default character encoding, and these bytes
444      * are written in exactly the manner of the <code>{@link #write(int)}</code>
445      * method.
446      *
447      * @param      s   The array of chars to be printed
448      *
449      * @throws  NullPointerException  If <code>s</code> is <code>null</code>
450      */
451     public void print(char s[]) throws IOException   {
452         write(s);
453     }
454     
455     /**
456      * Print a string.  If the argument is <code>null</code> then the string
457      * <code>"null"</code> is printed.  Otherwise, the string's characters are
458      * converted into bytes according to the platform's default character
459      * encoding, and these bytes are written in exactly the manner of the
460      * <code>{@link #write(int)}</code> method.
461      *
462      * @param      s   The <code>String</code> to be printed
463      */
464     public void print(String   s) throws IOException   {
465         if (s == null) {
466             s = "null";
467         }
468         write(s);
469     }
470     
471     /**
472      * Print an object.  The string produced by the <code>{@link
473      * java.lang.String#valueOf(Object)}</code> method is translated into bytes
474      * according to the platform's default character encoding, and these bytes
475      * are written in exactly the manner of the <code>{@link #write(int)}</code>
476      * method.
477      *
478      * @param      obj   The <code>Object</code> to be printed
479      */
480     public void print(Object   obj) throws IOException   {
481         write(String.valueOf(obj));
482     }
483     
484     /* Methods that do terminate lines */
485     
486     /**
487      * Terminate the current line by writing the line separator string.  The
488      * line separator string is defined by the system property
489      * <code>line.separator</code>, and is not necessarily a single newline
490      * character (<code>'\n'</code>).
491      *
492      * Need to change this from PrintWriter because the default
493      * println() writes  to the sink directly instead of through the
494      * write method...  
495      */
496     public void println() throws IOException   {
497         newLine();
498     }
499     
500     /**
501      * Print a boolean value and then terminate the line.  This method behaves
502      * as though it invokes <code>{@link #print(boolean)}</code> and then
503      * <code>{@link #println()}</code>.
504      */
505     public void println(boolean x) throws IOException   {
506         print(x);
507         println();
508     }
509     
510     /**
511      * Print a character and then terminate the line.  This method behaves as
512      * though it invokes <code>{@link #print(char)}</code> and then <code>{@link
513      * #println()}</code>.
514      */
515     public void println(char x) throws IOException   {
516         print(x);
517         println();
518     }
519     
520     /**
521      * Print an integer and then terminate the line.  This method behaves as
522      * though it invokes <code>{@link #print(int)}</code> and then <code>{@link
523      * #println()}</code>.
524      */
525     public void println(int x) throws IOException   {
526         print(x);
527         println();
528     }
529     
530     /**
531      * Print a long integer and then terminate the line.  This method behaves
532      * as though it invokes <code>{@link #print(long)}</code> and then
533      * <code>{@link #println()}</code>.
534      */
535     public void println(long x) throws IOException   {
536         print(x);
537         println();
538     }
539     
540     /**
541      * Print a floating-point number and then terminate the line.  This method
542      * behaves as though it invokes <code>{@link #print(float)}</code> and then
543      * <code>{@link #println()}</code>.
544      */
545     public void println(float x) throws IOException   {
546         print(x);
547         println();
548     }
549     
550     /**
551      * Print a double-precision floating-point number and then terminate the
552      * line.  This method behaves as though it invokes <code>{@link
553      * #print(double)}</code> and then <code>{@link #println()}</code>.
554      */
555     public void println(double x) throws IOException   {
556         print(x);
557         println();
558     }
559     
560     /**
561      * Print an array of characters and then terminate the line.  This method
562      * behaves as though it invokes <code>{@link #print(char[])}</code> and then
563      * <code>{@link #println()}</code>.
564      */
565     public void println(char x[]) throws IOException   {
566         print(x);
567         println();
568     }
569     
570     /**
571      * Print a String and then terminate the line.  This method behaves as
572      * though it invokes <code>{@link #print(String)}</code> and then
573      * <code>{@link #println()}</code>.
574      */
575     public void println(String   x) throws IOException   {
576         print(x);
577         println();
578     }
579     
580     /**
581      * Print an Object and then terminate the line.  This method behaves as
582      * though it invokes <code>{@link #print(Object)}</code> and then
583      * <code>{@link #println()}</code>.
584      */
585     public void println(Object   x) throws IOException   {
586         print(x);
587         println();
588     }
589     
590 }
591
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags