View Javadoc
1   package org.andromda.cartridges.jsf.portlet.myfaces.tomahawk.support;
2   
3   import java.io.CharConversionException;
4   import java.io.IOException;
5   import java.io.OutputStream;
6   import java.text.MessageFormat;
7   import javax.servlet.ServletOutputStream;
8   
9   /**
10   * This class is a dummy ServletOutputStream.
11   *
12   * @author <a href="mailto:shinsuke@yahoo.co.jp">Shinsuke Sugaya</a>
13   *
14   */
15  public class ServletOutputStreamWrapper extends ServletOutputStream {
16      private OutputStream outputStream;
17  
18      /**
19       * @param outputStream
20       */
21      public ServletOutputStreamWrapper(OutputStream outputStream) {
22          this.outputStream = outputStream;
23      }
24  
25      /**
26       * Writes a <code>String</code> to the client, without a carriage
27       * return-line feed (CRLF) character at the end.
28       *
29       *
30       * @param s
31       *            the <code>String</code> to send to the client
32       *
33       * @exception IOException
34       *                if an input or output exception occurred
35       *
36       */
37      public void print(String s) throws IOException {
38          if (s == null)
39              s = "null";
40          int len = s.length();
41          for (int i = 0; i < len; i++) {
42              char c = s.charAt(i);
43  
44              //
45              // XXX NOTE: This is clearly incorrect for many strings,
46              // but is the only consistent approach within the current
47              // servlet framework. It must suffice until servlet output
48              // streams properly encode their output.
49              //
50              if ((c & 0xff00) != 0) { // high order byte must be zero
51                  String errMsg = "Not an ISO 8859-1 character: {0}";
52                  Object[] errArgs = new Object[1];
53                  errArgs[0] = new Character(c);
54                  errMsg = MessageFormat.format(errMsg, errArgs);
55                  throw new CharConversionException(errMsg);
56              }
57              write(c);
58          }
59      }
60  
61      /**
62       * Writes a <code>boolean</code> value to the client, with no carriage
63       * return-line feed (CRLF) character at the end.
64       *
65       * @param b
66       *            the <code>boolean</code> value to send to the client
67       *
68       * @exception IOException
69       *                if an input or output exception occurred
70       *
71       */
72      public void print(boolean b) throws IOException {
73          String msg;
74          if (b) {
75              msg = "true";
76          } else {
77              msg = "false";
78          }
79          print(msg);
80      }
81  
82      /**
83       * Writes a character to the client, with no carriage return-line feed
84       * (CRLF) at the end.
85       *
86       * @param c
87       *            the character to send to the client
88       *
89       * @exception IOException
90       *                if an input or output exception occurred
91       *
92       */
93      public void print(char c) throws IOException {
94          print(String.valueOf(c));
95      }
96  
97      /**
98       *
99       * Writes an int to the client, with no carriage return-line feed (CRLF) at
100      * the end.
101      *
102      * @param i
103      *            the int to send to the client
104      *
105      * @exception IOException
106      *                if an input or output exception occurred
107      *
108      */
109     public void print(int i) throws IOException {
110         print(String.valueOf(i));
111     }
112 
113     /**
114      *
115      * Writes a <code>long</code> value to the client, with no carriage
116      * return-line feed (CRLF) at the end.
117      *
118      * @param l
119      *            the <code>long</code> value to send to the client
120      *
121      * @exception IOException
122      *                if an input or output exception occurred
123      *
124      */
125     public void print(long l) throws IOException {
126         print(String.valueOf(l));
127     }
128 
129     /**
130      *
131      * Writes a <code>float</code> value to the client, with no carriage
132      * return-line feed (CRLF) at the end.
133      *
134      * @param f
135      *            the <code>float</code> value to send to the client
136      *
137      * @exception IOException
138      *                if an input or output exception occurred
139      */
140     public void print(float f) throws IOException {
141         print(String.valueOf(f));
142     }
143 
144     /**
145      *
146      * Writes a <code>double</code> value to the client, with no carriage
147      * return-line feed (CRLF) at the end.
148      *
149      * @param d
150      *            the <code>double</code> value to send to the client
151      *
152      * @exception IOException
153      *                if an input or output exception occurred
154      */
155     public void print(double d) throws IOException {
156         print(String.valueOf(d));
157     }
158 
159     /**
160      * Writes a carriage return-line feed (CRLF) to the client.
161      *
162      * @exception IOException if an input or output exception occurred
163      */
164     public void println() throws IOException {
165         print("\r\n");
166     }
167 
168     /**
169      * Writes a <code>String</code> to the client, followed by a carriage
170      * return-line feed (CRLF).
171      *
172      *
173      * @param s the <code>String</code> to write to the client
174      *
175      * @exception IOException if an input or output exception occurred
176      *
177      */
178     public void println(String s) throws IOException {
179         print(s);
180         println();
181     }
182 
183     /**
184      *
185      * Writes a <code>boolean</code> value to the client, followed by a
186      * carriage return-line feed (CRLF).
187      *
188      * @param b the <code>boolean</code> value to write to the client
189      * @exception IOException if an input or output exception occurred
190      *
191      */
192     public void println(boolean b) throws IOException {
193         print(b);
194         println();
195     }
196 
197     /**
198      *
199      * Writes a character to the client, followed by a carriage return-line feed
200      * (CRLF).
201      *
202      * @param c
203      *            the character to write to the client
204      *
205      * @exception IOException
206      *                if an input or output exception occurred
207      *
208      */
209     public void println(char c) throws IOException {
210         print(c);
211         println();
212     }
213 
214     /**
215      *
216      * Writes an int to the client, followed by a carriage return-line feed
217      * (CRLF) character.
218      *
219      *
220      * @param i
221      *            the int to write to the client
222      *
223      * @exception IOException
224      *                if an input or output exception occurred
225      *
226      */
227     public void println(int i) throws IOException {
228         print(i);
229         println();
230     }
231 
232     /**
233      *
234      * Writes a <code>long</code> value to the client, followed by a carriage
235      * return-line feed (CRLF).
236      *
237      *
238      * @param l
239      *            the <code>long</code> value to write to the client
240      *
241      * @exception IOException
242      *                if an input or output exception occurred
243      *
244      */
245     public void println(long l) throws IOException {
246         print(l);
247         println();
248     }
249 
250     /**
251      *
252      * Writes a <code>float</code> value to the client, followed by a carriage
253      * return-line feed (CRLF).
254      *
255      * @param f
256      *            the <code>float</code> value to write to the client
257      *
258      *
259      * @exception IOException
260      *                if an input or output exception occurred
261      *
262      */
263     public void println(float f) throws IOException {
264         print(f);
265         println();
266     }
267 
268     /**
269      *
270      * Writes a <code>double</code> value to the client, followed by a
271      * carriage return-line feed (CRLF).
272      *
273      *
274      * @param d
275      *            the <code>double</code> value to write to the client
276      *
277      * @exception IOException
278      *                if an input or output exception occurred
279      *
280      */
281     public void println(double d) throws IOException {
282         print(d);
283         println();
284     }
285 
286     /**
287      * @see java.io.OutputStream#write(int)
288      */
289     public void write(int b) throws IOException {
290         outputStream.write(b);
291     }
292 
293     /**
294      * @see java.io.OutputStream#close()
295      */
296     public void close() throws IOException {
297         outputStream.close();
298     }
299 
300     /**
301      * @see Object#equals(Object)
302      */
303     public boolean equals(Object obj) {
304         return outputStream.equals(obj);
305     }
306 
307     /**
308      * @see java.io.OutputStream#flush()
309      */
310     public void flush() throws IOException {
311         outputStream.flush();
312     }
313 
314     /**
315      * @see Object#hashCode()
316      */
317     public int hashCode() {
318         return outputStream.hashCode();
319     }
320 
321     /**
322      * @see Object#toString()
323      */
324     public String toString() {
325         return outputStream.toString();
326     }
327 
328     /**
329      * @see java.io.OutputStream#write(byte[], int, int)
330      */
331     public void write(byte[] b, int off, int len) throws IOException {
332         outputStream.write(b, off, len);
333     }
334 
335     /**
336      * @see java.io.OutputStream#write(byte[])
337      */
338     public void write(byte[] b) throws IOException {
339         outputStream.write(b);
340     }
341 }