Classes in this File | Line Coverage | Branch Coverage | Complexity | ||||
IOUtil |
|
| 0.0;0 |
1 | package org.apache.maven.shared.utils.io; | |
2 | ||
3 | /* | |
4 | * Licensed to the Apache Software Foundation (ASF) under one | |
5 | * or more contributor license agreements. See the NOTICE file | |
6 | * distributed with this work for additional information | |
7 | * regarding copyright ownership. The ASF licenses this file | |
8 | * to you under the Apache License, Version 2.0 (the | |
9 | * "License"); you may not use this file except in compliance | |
10 | * with the License. You may obtain a copy of the License at | |
11 | * | |
12 | * http://www.apache.org/licenses/LICENSE-2.0 | |
13 | * | |
14 | * Unless required by applicable law or agreed to in writing, | |
15 | * software distributed under the License is distributed on an | |
16 | * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
17 | * KIND, either express or implied. See the License for the | |
18 | * specific language governing permissions and limitations | |
19 | * under the License. | |
20 | */ | |
21 | ||
22 | import javax.annotation.Nonnull; | |
23 | import javax.annotation.Nullable; | |
24 | ||
25 | import java.io.BufferedInputStream; | |
26 | import java.io.BufferedOutputStream; | |
27 | import java.io.ByteArrayInputStream; | |
28 | import java.io.ByteArrayOutputStream; | |
29 | import java.io.IOException; | |
30 | import java.io.InputStream; | |
31 | import java.io.InputStreamReader; | |
32 | import java.io.OutputStream; | |
33 | import java.io.OutputStreamWriter; | |
34 | import java.io.Reader; | |
35 | import java.io.StringReader; | |
36 | import java.io.StringWriter; | |
37 | import java.io.Writer; | |
38 | import java.nio.channels.Channel; | |
39 | ||
40 | /** | |
41 | * General IO Stream manipulation. | |
42 | * <p> | |
43 | * This class provides static utility methods for input/output operations, particularly buffered | |
44 | * copying between sources (<code>InputStream</code>, <code>Reader</code>, <code>String</code> and | |
45 | * <code>byte[]</code>) and destinations (<code>OutputStream</code>, <code>Writer</code>, | |
46 | * <code>String</code> and <code>byte[]</code>). | |
47 | * </p> | |
48 | * <p/> | |
49 | * <p>Unless otherwise noted, these <code>copy</code> methods do <em>not</em> flush or close the | |
50 | * streams. Often, doing so would require making non-portable assumptions about the streams' origin | |
51 | * and further use. This means that both streams' <code>close()</code> methods must be called after | |
52 | * copying. if one omits this step, then the stream resources (sockets, file descriptors) are | |
53 | * released when the associated Stream is garbage-collected. It is not a good idea to rely on this | |
54 | * mechanism. For a good overview of the distinction between "memory management" and "resource | |
55 | * management", see <a href="http://www.unixreview.com/articles/1998/9804/9804ja/ja.htm">this | |
56 | * UnixReview article</a></p> | |
57 | * <p/> | |
58 | * <p>For each <code>copy</code> method, a variant is provided that allows the caller to specify the | |
59 | * buffer size (the default is 4k). As the buffer size can have a fairly large impact on speed, this | |
60 | * may be worth tweaking. Often "large buffer -> faster" does not hold, even for large data | |
61 | * transfers.</p> | |
62 | * <p/> | |
63 | * <p>For byte-to-char methods, a <code>copy</code> variant allows the encoding to be selected | |
64 | * (otherwise the platform default is used).</p> | |
65 | * <p/> | |
66 | * <p>The <code>copy</code> methods use an internal buffer when copying. It is therefore advisable | |
67 | * <em>not</em> to deliberately wrap the stream arguments to the <code>copy</code> methods in | |
68 | * <code>Buffered*</code> streams. For example, don't do the | |
69 | * following:</p> | |
70 | * <p/> | |
71 | * <code>copy( new BufferedInputStream( in ), new BufferedOutputStream( out ) );</code> | |
72 | * <p/> | |
73 | * <p>The rationale is as follows:</p> | |
74 | * <p/> | |
75 | * <p>Imagine that an InputStream's read() is a very expensive operation, which would usually suggest | |
76 | * wrapping in a BufferedInputStream. The BufferedInputStream works by issuing infrequent | |
77 | * {@link java.io.InputStream#read(byte[] b, int off, int len)} requests on the underlying InputStream, to | |
78 | * fill an internal buffer, from which further <code>read</code> requests can inexpensively get | |
79 | * their data (until the buffer runs out).</p> | |
80 | * <p>However, the <code>copy</code> methods do the same thing, keeping an internal buffer, | |
81 | * populated by {@link InputStream#read(byte[] b, int off, int len)} requests. Having two buffers | |
82 | * (or three if the destination stream is also buffered) is pointless, and the unnecessary buffer | |
83 | * management hurts performance slightly (about 3%, according to some simple experiments).</p> | |
84 | * | |
85 | * @author <a href="mailto:peter@apache.org">Peter Donald</a> | |
86 | * @author <a href="mailto:jefft@apache.org">Jeff Turner</a> | |
87 | * @version CVS $Revision: 1401872 $ $Date: 2012-10-24 22:45:04 +0200 (on., 24 okt. 2012) $ | |
88 | * | |
89 | */ | |
90 | ||
91 | /* | |
92 | * Behold, intrepid explorers; a map of this class: | |
93 | * | |
94 | * Method Input Output Dependency | |
95 | * ------ ----- ------ ------- | |
96 | * 1 copy InputStream OutputStream (primitive) | |
97 | * 2 copy Reader Writer (primitive) | |
98 | * | |
99 | * 3 copy InputStream Writer 2 | |
100 | * 4 toString InputStream String 3 | |
101 | * 5 toByteArray InputStream byte[] 1 | |
102 | * | |
103 | * 6 copy Reader OutputStream 2 | |
104 | * 7 toString Reader String 2 | |
105 | * 8 toByteArray Reader byte[] 6 | |
106 | * | |
107 | * 9 copy String OutputStream 2 | |
108 | * 10 copy String Writer (trivial) | |
109 | * 11 toByteArray String byte[] 9 | |
110 | * | |
111 | * 12 copy byte[] Writer 3 | |
112 | * 13 toString byte[] String 12 | |
113 | * 14 copy byte[] OutputStream (trivial) | |
114 | * | |
115 | * | |
116 | * Note that only the first two methods shuffle bytes; the rest use these two, or (if possible) copy | |
117 | * using native Java copy methods. As there are method variants to specify buffer size and encoding, | |
118 | * each row may correspond to up to 4 methods. | |
119 | * | |
120 | */ | |
121 | ||
122 | public final class IOUtil | |
123 | { | |
124 | private static final int DEFAULT_BUFFER_SIZE = 1024 * 4; | |
125 | ||
126 | /** | |
127 | * Private constructor to prevent instantiation. | |
128 | */ | |
129 | private IOUtil() | |
130 | 0 | { |
131 | 0 | } |
132 | ||
133 | /////////////////////////////////////////////////////////////// | |
134 | // Core copy methods | |
135 | /////////////////////////////////////////////////////////////// | |
136 | ||
137 | /** | |
138 | * Copy bytes from an <code>InputStream</code> to an <code>OutputStream</code>. | |
139 | */ | |
140 | public static void copy( @Nonnull final InputStream input, @Nonnull final OutputStream output ) | |
141 | throws IOException | |
142 | { | |
143 | 9 | copy( input, output, DEFAULT_BUFFER_SIZE ); |
144 | 7 | } |
145 | ||
146 | /** | |
147 | * Copy bytes from an <code>InputStream</code> to an <code>OutputStream</code>. | |
148 | * | |
149 | * @param bufferSize Size of internal buffer to use. | |
150 | */ | |
151 | public static void copy( @Nonnull final InputStream input, @Nonnull final OutputStream output, final int bufferSize ) | |
152 | throws IOException | |
153 | { | |
154 | 29 | final byte[] buffer = new byte[bufferSize]; |
155 | int n; | |
156 | 48 | while ( -1 != ( n = input.read( buffer ) ) ) |
157 | { | |
158 | 26 | output.write( buffer, 0, n ); |
159 | } | |
160 | 14 | } |
161 | ||
162 | /** | |
163 | * Copy chars from a <code>Reader</code> to a <code>Writer</code>. | |
164 | */ | |
165 | public static void copy( @Nonnull final Reader input, @Nonnull final Writer output ) | |
166 | throws IOException | |
167 | { | |
168 | 14 | copy( input, output, DEFAULT_BUFFER_SIZE ); |
169 | 6 | } |
170 | ||
171 | /** | |
172 | * Copy chars from a <code>Reader</code> to a <code>Writer</code>. | |
173 | * | |
174 | * @param bufferSize Size of internal buffer to use. | |
175 | */ | |
176 | public static void copy( @Nonnull final Reader input, @Nonnull final Writer output, final int bufferSize ) | |
177 | throws IOException | |
178 | { | |
179 | 136 | final char[] buffer = new char[bufferSize]; |
180 | int n; | |
181 | 245 | while ( -1 != ( n = input.read( buffer ) ) ) |
182 | { | |
183 | 158 | output.write( buffer, 0, n ); |
184 | } | |
185 | 75 | output.flush(); |
186 | 67 | } |
187 | ||
188 | /////////////////////////////////////////////////////////////// | |
189 | // Derived copy methods | |
190 | // InputStream -> * | |
191 | /////////////////////////////////////////////////////////////// | |
192 | ||
193 | /////////////////////////////////////////////////////////////// | |
194 | // InputStream -> Writer | |
195 | ||
196 | /** | |
197 | * Copy and convert bytes from an <code>InputStream</code> to chars on a | |
198 | * <code>Writer</code>. | |
199 | * The platform's default encoding is used for the byte-to-char conversion. | |
200 | */ | |
201 | public static void copy( @Nonnull final InputStream input, @Nonnull final Writer output ) | |
202 | throws IOException | |
203 | { | |
204 | 5 | copy( input, output, DEFAULT_BUFFER_SIZE ); |
205 | 2 | } |
206 | ||
207 | /** | |
208 | * Copy and convert bytes from an <code>InputStream</code> to chars on a | |
209 | * <code>Writer</code>. | |
210 | * The platform's default encoding is used for the byte-to-char conversion. | |
211 | * | |
212 | * @param bufferSize Size of internal buffer to use. | |
213 | */ | |
214 | public static void copy( @Nonnull final InputStream input, @Nonnull final Writer output, final int bufferSize ) | |
215 | throws IOException | |
216 | { | |
217 | 48 | final InputStreamReader in = new InputStreamReader( input ); |
218 | 38 | copy( in, output, bufferSize ); |
219 | 16 | } |
220 | ||
221 | /** | |
222 | * Copy and convert bytes from an <code>InputStream</code> to chars on a | |
223 | * <code>Writer</code>, using the specified encoding. | |
224 | * | |
225 | * @param encoding The name of a supported character encoding. See the | |
226 | * <a href="http://www.iana.org/assignments/character-sets">IANA | |
227 | * Charset Registry</a> for a list of valid encoding types. | |
228 | */ | |
229 | public static void copy( @Nonnull final InputStream input, @Nonnull final Writer output, @Nonnull final String encoding ) | |
230 | throws IOException | |
231 | { | |
232 | 28 | final InputStreamReader in = new InputStreamReader( input, encoding ); |
233 | 8 | copy( in, output ); |
234 | 4 | } |
235 | ||
236 | /** | |
237 | * Copy and convert bytes from an <code>InputStream</code> to chars on a | |
238 | * <code>Writer</code>, using the specified encoding. | |
239 | * | |
240 | * @param encoding The name of a supported character encoding. See the | |
241 | * <a href="http://www.iana.org/assignments/character-sets">IANA | |
242 | * Charset Registry</a> for a list of valid encoding types. | |
243 | * @param bufferSize Size of internal buffer to use. | |
244 | */ | |
245 | public static void copy( @Nonnull final InputStream input, @Nonnull final Writer output, @Nonnull final String encoding, final int bufferSize ) | |
246 | throws IOException | |
247 | { | |
248 | 91 | final InputStreamReader in = new InputStreamReader( input, encoding ); |
249 | 14 | copy( in, output, bufferSize ); |
250 | 4 | } |
251 | ||
252 | /////////////////////////////////////////////////////////////// | |
253 | // InputStream -> String | |
254 | ||
255 | /** | |
256 | * Get the contents of an <code>InputStream</code> as a String. | |
257 | * The platform's default encoding is used for the byte-to-char conversion. | |
258 | */ | |
259 | public @Nonnull static String toString( @Nonnull final InputStream input ) | |
260 | throws IOException | |
261 | { | |
262 | 3 | return toString( input, DEFAULT_BUFFER_SIZE ); |
263 | } | |
264 | ||
265 | /** | |
266 | * Get the contents of an <code>InputStream</code> as a String. | |
267 | * The platform's default encoding is used for the byte-to-char conversion. | |
268 | * | |
269 | * @param bufferSize Size of internal buffer to use. | |
270 | */ | |
271 | public @Nonnull static String toString( @Nonnull final InputStream input, final int bufferSize ) | |
272 | throws IOException | |
273 | { | |
274 | 10 | final StringWriter sw = new StringWriter(); |
275 | 10 | copy( input, sw, bufferSize ); |
276 | 4 | return sw.toString(); |
277 | } | |
278 | ||
279 | /** | |
280 | * Get the contents of an <code>InputStream</code> as a String. | |
281 | * | |
282 | * @param encoding The name of a supported character encoding. See the | |
283 | * <a href="http://www.iana.org/assignments/character-sets">IANA | |
284 | * Charset Registry</a> for a list of valid encoding types. | |
285 | */ | |
286 | public @Nonnull static String toString( @Nonnull final InputStream input, @Nonnull final String encoding ) | |
287 | throws IOException | |
288 | { | |
289 | 9 | return toString( input, encoding, DEFAULT_BUFFER_SIZE ); |
290 | } | |
291 | ||
292 | /** | |
293 | * Get the contents of an <code>InputStream</code> as a String. | |
294 | * | |
295 | * @param encoding The name of a supported character encoding. See the | |
296 | * <a href="http://www.iana.org/assignments/character-sets">IANA | |
297 | * Charset Registry</a> for a list of valid encoding types. | |
298 | * @param bufferSize Size of internal buffer to use. | |
299 | */ | |
300 | public @Nonnull static String toString( @Nonnull final InputStream input, @Nonnull final String encoding, final int bufferSize ) | |
301 | throws IOException | |
302 | { | |
303 | 25 | final StringWriter sw = new StringWriter(); |
304 | 25 | copy( input, sw, encoding, bufferSize ); |
305 | 2 | return sw.toString(); |
306 | } | |
307 | ||
308 | /////////////////////////////////////////////////////////////// | |
309 | // InputStream -> byte[] | |
310 | ||
311 | /** | |
312 | * Get the contents of an <code>InputStream</code> as a <code>byte[]</code>. | |
313 | */ | |
314 | public @Nonnull static byte[] toByteArray( @Nonnull final InputStream input ) | |
315 | throws IOException | |
316 | { | |
317 | 2 | return toByteArray( input, DEFAULT_BUFFER_SIZE ); |
318 | } | |
319 | ||
320 | /** | |
321 | * Get the contents of an <code>InputStream</code> as a <code>byte[]</code>. | |
322 | * | |
323 | * @param bufferSize Size of internal buffer to use. | |
324 | */ | |
325 | public @Nonnull static byte[] toByteArray( @Nonnull final InputStream input, final int bufferSize ) | |
326 | throws IOException | |
327 | { | |
328 | 6 | final ByteArrayOutputStream output = new ByteArrayOutputStream(); |
329 | 6 | copy( input, output, bufferSize ); |
330 | 2 | return output.toByteArray(); |
331 | } | |
332 | ||
333 | /////////////////////////////////////////////////////////////// | |
334 | // Derived copy methods | |
335 | // Reader -> * | |
336 | /////////////////////////////////////////////////////////////// | |
337 | ||
338 | /////////////////////////////////////////////////////////////// | |
339 | // Reader -> OutputStream | |
340 | ||
341 | /** | |
342 | * Serialize chars from a <code>Reader</code> to bytes on an <code>OutputStream</code>, and | |
343 | * flush the <code>OutputStream</code>. | |
344 | */ | |
345 | public static void copy( @Nonnull final Reader input, @Nonnull final OutputStream output ) | |
346 | throws IOException | |
347 | { | |
348 | 5 | copy( input, output, DEFAULT_BUFFER_SIZE ); |
349 | 2 | } |
350 | ||
351 | /** | |
352 | * Serialize chars from a <code>Reader</code> to bytes on an <code>OutputStream</code>, and | |
353 | * flush the <code>OutputStream</code>. | |
354 | * | |
355 | * @param bufferSize Size of internal buffer to use. | |
356 | */ | |
357 | public static void copy( @Nonnull final Reader input, @Nonnull final OutputStream output, final int bufferSize ) | |
358 | throws IOException | |
359 | { | |
360 | 24 | final OutputStreamWriter out = new OutputStreamWriter( output ); |
361 | 16 | copy( input, out, bufferSize ); |
362 | // NOTE: Unless anyone is planning on rewriting OutputStreamWriter, we have to flush | |
363 | // here. | |
364 | 6 | out.flush(); |
365 | 6 | } |
366 | ||
367 | /////////////////////////////////////////////////////////////// | |
368 | // Reader -> String | |
369 | ||
370 | /** | |
371 | * Get the contents of a <code>Reader</code> as a String. | |
372 | */ | |
373 | public @Nonnull static String toString( @Nonnull final Reader input ) | |
374 | throws IOException | |
375 | { | |
376 | 23 | return toString( input, DEFAULT_BUFFER_SIZE ); |
377 | } | |
378 | ||
379 | /** | |
380 | * Get the contents of a <code>Reader</code> as a String. | |
381 | * | |
382 | * @param bufferSize Size of internal buffer to use. | |
383 | */ | |
384 | public @Nonnull static String toString( @Nonnull final Reader input, final int bufferSize ) | |
385 | throws IOException | |
386 | { | |
387 | 27 | final StringWriter sw = new StringWriter(); |
388 | 27 | copy( input, sw, bufferSize ); |
389 | 24 | return sw.toString(); |
390 | } | |
391 | ||
392 | /////////////////////////////////////////////////////////////// | |
393 | // Reader -> byte[] | |
394 | ||
395 | /** | |
396 | * Get the contents of a <code>Reader</code> as a <code>byte[]</code>. | |
397 | */ | |
398 | public @Nonnull static byte[] toByteArray( @Nonnull final Reader input ) | |
399 | throws IOException | |
400 | { | |
401 | 2 | return toByteArray( input, DEFAULT_BUFFER_SIZE ); |
402 | } | |
403 | ||
404 | /** | |
405 | * Get the contents of a <code>Reader</code> as a <code>byte[]</code>. | |
406 | * | |
407 | * @param bufferSize Size of internal buffer to use. | |
408 | */ | |
409 | public @Nonnull static byte[] toByteArray( @Nonnull final Reader input, final int bufferSize ) | |
410 | throws IOException | |
411 | { | |
412 | 6 | ByteArrayOutputStream output = new ByteArrayOutputStream(); |
413 | 6 | copy( input, output, bufferSize ); |
414 | 2 | return output.toByteArray(); |
415 | } | |
416 | ||
417 | /////////////////////////////////////////////////////////////// | |
418 | // Derived copy methods | |
419 | // String -> * | |
420 | /////////////////////////////////////////////////////////////// | |
421 | ||
422 | /////////////////////////////////////////////////////////////// | |
423 | // String -> OutputStream | |
424 | ||
425 | /** | |
426 | * Serialize chars from a <code>String</code> to bytes on an <code>OutputStream</code>, and | |
427 | * flush the <code>OutputStream</code>. | |
428 | */ | |
429 | public static void copy( @Nonnull final String input, @Nonnull final OutputStream output ) | |
430 | throws IOException | |
431 | { | |
432 | 6 | copy( input, output, DEFAULT_BUFFER_SIZE ); |
433 | 2 | } |
434 | ||
435 | /** | |
436 | * Serialize chars from a <code>String</code> to bytes on an <code>OutputStream</code>, and | |
437 | * flush the <code>OutputStream</code>. | |
438 | * | |
439 | * @param bufferSize Size of internal buffer to use. | |
440 | */ | |
441 | public static void copy( @Nonnull final String input, @Nonnull final OutputStream output, final int bufferSize ) | |
442 | throws IOException | |
443 | { | |
444 | 30 | final StringReader in = new StringReader( input ); |
445 | 19 | final OutputStreamWriter out = new OutputStreamWriter( output ); |
446 | 12 | copy( in, out, bufferSize ); |
447 | // NOTE: Unless anyone is planning on rewriting OutputStreamWriter, we have to flush | |
448 | // here. | |
449 | 9 | out.flush(); |
450 | 9 | } |
451 | ||
452 | /////////////////////////////////////////////////////////////// | |
453 | // String -> Writer | |
454 | ||
455 | /** | |
456 | * Copy chars from a <code>String</code> to a <code>Writer</code>. | |
457 | */ | |
458 | public static void copy( @Nonnull final String input, @Nonnull final Writer output ) | |
459 | throws IOException | |
460 | { | |
461 | 6 | output.write( input ); |
462 | 3 | } |
463 | ||
464 | /////////////////////////////////////////////////////////////// | |
465 | // String -> byte[] | |
466 | ||
467 | /** | |
468 | * Get the contents of a <code>String</code> as a <code>byte[]</code>. | |
469 | */ | |
470 | public @Nonnull static byte[] toByteArray( @Nonnull final String input ) | |
471 | throws IOException | |
472 | { | |
473 | 5 | return toByteArray( input, DEFAULT_BUFFER_SIZE ); |
474 | } | |
475 | ||
476 | /** | |
477 | * Get the contents of a <code>String</code> as a <code>byte[]</code>. | |
478 | * | |
479 | * @param bufferSize Size of internal buffer to use. | |
480 | */ | |
481 | public @Nonnull static byte[] toByteArray( @Nonnull final String input, final int bufferSize ) | |
482 | throws IOException | |
483 | { | |
484 | 9 | ByteArrayOutputStream output = new ByteArrayOutputStream(); |
485 | 9 | copy( input, output, bufferSize ); |
486 | 5 | return output.toByteArray(); |
487 | } | |
488 | ||
489 | /////////////////////////////////////////////////////////////// | |
490 | // Derived copy methods | |
491 | // byte[] -> * | |
492 | /////////////////////////////////////////////////////////////// | |
493 | ||
494 | /////////////////////////////////////////////////////////////// | |
495 | // byte[] -> Writer | |
496 | ||
497 | /** | |
498 | * Copy and convert bytes from a <code>byte[]</code> to chars on a | |
499 | * <code>Writer</code>. | |
500 | * The platform's default encoding is used for the byte-to-char conversion. | |
501 | */ | |
502 | public static void copy( @Nonnull final byte[] input, @Nonnull final Writer output ) | |
503 | throws IOException | |
504 | { | |
505 | 5 | copy( input, output, DEFAULT_BUFFER_SIZE ); |
506 | 2 | } |
507 | ||
508 | /** | |
509 | * Copy and convert bytes from a <code>byte[]</code> to chars on a | |
510 | * <code>Writer</code>. | |
511 | * The platform's default encoding is used for the byte-to-char conversion. | |
512 | * | |
513 | * @param bufferSize Size of internal buffer to use. | |
514 | */ | |
515 | public static void copy( @Nonnull final byte[] input, @Nonnull final Writer output, final int bufferSize ) | |
516 | throws IOException | |
517 | { | |
518 | 29 | final ByteArrayInputStream in = new ByteArrayInputStream( input ); |
519 | 19 | copy( in, output, bufferSize ); |
520 | 8 | } |
521 | ||
522 | /** | |
523 | * Copy and convert bytes from a <code>byte[]</code> to chars on a | |
524 | * <code>Writer</code>, using the specified encoding. | |
525 | * | |
526 | * @param encoding The name of a supported character encoding. See the | |
527 | * <a href="http://www.iana.org/assignments/character-sets">IANA | |
528 | * Charset Registry</a> for a list of valid encoding types. | |
529 | */ | |
530 | public static void copy( @Nonnull final byte[] input, @Nonnull final Writer output, final String encoding ) | |
531 | throws IOException | |
532 | { | |
533 | 17 | final ByteArrayInputStream in = new ByteArrayInputStream( input ); |
534 | 11 | copy( in, output, encoding ); |
535 | 2 | } |
536 | ||
537 | /** | |
538 | * Copy and convert bytes from a <code>byte[]</code> to chars on a | |
539 | * <code>Writer</code>, using the specified encoding. | |
540 | * | |
541 | * @param encoding The name of a supported character encoding. See the | |
542 | * <a href="http://www.iana.org/assignments/character-sets">IANA | |
543 | * Charset Registry</a> for a list of valid encoding types. | |
544 | * @param bufferSize Size of internal buffer to use. | |
545 | */ | |
546 | public static void copy( @Nonnull final byte[] input, @Nonnull final Writer output, @Nonnull final String encoding, final int bufferSize ) | |
547 | throws IOException | |
548 | { | |
549 | 56 | final ByteArrayInputStream in = new ByteArrayInputStream( input ); |
550 | 35 | copy( in, output, encoding, bufferSize ); |
551 | 2 | } |
552 | ||
553 | /////////////////////////////////////////////////////////////// | |
554 | // byte[] -> String | |
555 | ||
556 | /** | |
557 | * Get the contents of a <code>byte[]</code> as a String. | |
558 | * The platform's default encoding is used for the byte-to-char conversion. | |
559 | */ | |
560 | public @Nonnull static String toString( @Nonnull final byte[] input ) | |
561 | throws IOException | |
562 | { | |
563 | 3 | return toString( input, DEFAULT_BUFFER_SIZE ); |
564 | } | |
565 | ||
566 | /** | |
567 | * Get the contents of a <code>byte[]</code> as a String. | |
568 | * The platform's default encoding is used for the byte-to-char conversion. | |
569 | * | |
570 | * @param bufferSize Size of internal buffer to use. | |
571 | */ | |
572 | public @Nonnull static String toString( @Nonnull final byte[] input, final int bufferSize ) | |
573 | throws IOException | |
574 | { | |
575 | 10 | final StringWriter sw = new StringWriter(); |
576 | 10 | copy( input, sw, bufferSize ); |
577 | 4 | return sw.toString(); |
578 | } | |
579 | ||
580 | /** | |
581 | * Get the contents of a <code>byte[]</code> as a String. | |
582 | * | |
583 | * @param encoding The name of a supported character encoding. See the | |
584 | * <a href="http://www.iana.org/assignments/character-sets">IANA | |
585 | * Charset Registry</a> for a list of valid encoding types. | |
586 | */ | |
587 | public @Nonnull static String toString( @Nonnull final byte[] input, @Nonnull final String encoding ) | |
588 | throws IOException | |
589 | { | |
590 | 9 | return toString( input, encoding, DEFAULT_BUFFER_SIZE ); |
591 | } | |
592 | ||
593 | /** | |
594 | * Get the contents of a <code>byte[]</code> as a String. | |
595 | * | |
596 | * @param encoding The name of a supported character encoding. See the | |
597 | * <a href="http://www.iana.org/assignments/character-sets">IANA | |
598 | * Charset Registry</a> for a list of valid encoding types. | |
599 | * @param bufferSize Size of internal buffer to use. | |
600 | */ | |
601 | public @Nonnull static String toString( @Nonnull final byte[] input, @Nonnull final String encoding, final int bufferSize ) | |
602 | throws IOException | |
603 | { | |
604 | 25 | final StringWriter sw = new StringWriter(); |
605 | 25 | copy( input, sw, encoding, bufferSize ); |
606 | 2 | return sw.toString(); |
607 | } | |
608 | ||
609 | /////////////////////////////////////////////////////////////// | |
610 | // byte[] -> OutputStream | |
611 | ||
612 | /** | |
613 | * Copy bytes from a <code>byte[]</code> to an <code>OutputStream</code>. | |
614 | */ | |
615 | public static void copy( @Nonnull final byte[] input, @Nonnull final OutputStream output ) | |
616 | throws IOException | |
617 | { | |
618 | 20 | output.write( input ); |
619 | 8 | } |
620 | ||
621 | /** | |
622 | * Compare the contents of two Streams to determine if they are equal or not. | |
623 | * | |
624 | * @param input1 the first stream | |
625 | * @param input2 the second stream | |
626 | * @return true if the content of the streams are equal or they both don't exist, false otherwise | |
627 | */ | |
628 | public static boolean contentEquals( @Nonnull final InputStream input1, @Nonnull final InputStream input2 ) | |
629 | throws IOException | |
630 | { | |
631 | 19 | final InputStream bufferedInput1 = new BufferedInputStream( input1 ); |
632 | 19 | final InputStream bufferedInput2 = new BufferedInputStream( input2 ); |
633 | ||
634 | 19 | int ch = bufferedInput1.read(); |
635 | 23238 | while ( -1 != ch ) |
636 | { | |
637 | 23225 | final int ch2 = bufferedInput2.read(); |
638 | 23225 | if ( ch != ch2 ) |
639 | { | |
640 | 5 | return false; |
641 | } | |
642 | 23220 | ch = bufferedInput1.read(); |
643 | 23220 | } |
644 | ||
645 | 13 | final int ch2 = bufferedInput2.read(); |
646 | 11 | return -1 == ch2; |
647 | } | |
648 | ||
649 | // ---------------------------------------------------------------------- | |
650 | // closeXXX() | |
651 | // ---------------------------------------------------------------------- | |
652 | ||
653 | /** | |
654 | * Closes a channel. Channel can be null and any IOException's will be swallowed. | |
655 | * | |
656 | * @param channel The stream to close. | |
657 | */ | |
658 | public static void close( @Nullable Channel channel ) | |
659 | { | |
660 | 6 | if ( channel == null ) |
661 | { | |
662 | 0 | return; |
663 | } | |
664 | ||
665 | try | |
666 | { | |
667 | 6 | channel.close(); |
668 | } | |
669 | 0 | catch ( IOException ex ) |
670 | { | |
671 | // ignore | |
672 | 6 | } |
673 | 6 | } |
674 | ||
675 | /** | |
676 | * Closes the input stream. The input stream can be null and any IOException's will be swallowed. | |
677 | * | |
678 | * @param inputStream The stream to close. | |
679 | */ | |
680 | public static void close( @Nullable InputStream inputStream ) | |
681 | { | |
682 | 33 | if ( inputStream == null ) |
683 | { | |
684 | 2 | return; |
685 | } | |
686 | ||
687 | try | |
688 | { | |
689 | 31 | inputStream.close(); |
690 | } | |
691 | 1 | catch ( IOException ex ) |
692 | { | |
693 | // ignore | |
694 | 30 | } |
695 | 31 | } |
696 | ||
697 | /** | |
698 | * Closes the output stream. The output stream can be null and any IOException's will be swallowed. | |
699 | * | |
700 | * @param outputStream The stream to close. | |
701 | */ | |
702 | public static void close( @Nullable OutputStream outputStream ) | |
703 | { | |
704 | 304 | if ( outputStream == null ) |
705 | { | |
706 | 1 | return; |
707 | } | |
708 | ||
709 | try | |
710 | { | |
711 | 303 | outputStream.close(); |
712 | } | |
713 | 1 | catch ( IOException ex ) |
714 | { | |
715 | // ignore | |
716 | 302 | } |
717 | 303 | } |
718 | ||
719 | /** | |
720 | * Closes the reader. The reader can be null and any IOException's will be swallowed. | |
721 | * | |
722 | * @param reader The reader to close. | |
723 | */ | |
724 | public static void close( @Nullable Reader reader ) | |
725 | { | |
726 | 35 | if ( reader == null ) |
727 | { | |
728 | 1 | return; |
729 | } | |
730 | ||
731 | try | |
732 | { | |
733 | 34 | reader.close(); |
734 | } | |
735 | 1 | catch ( IOException ex ) |
736 | { | |
737 | // ignore | |
738 | 33 | } |
739 | 34 | } |
740 | ||
741 | /** | |
742 | * Closes the writer. The writer can be null and any IOException's will be swallowed. | |
743 | * | |
744 | * @param writer The writer to close. | |
745 | */ | |
746 | public static void close( @Nullable Writer writer ) | |
747 | { | |
748 | 14 | if ( writer == null ) |
749 | { | |
750 | 1 | return; |
751 | } | |
752 | ||
753 | try | |
754 | { | |
755 | 13 | writer.close(); |
756 | } | |
757 | 1 | catch ( IOException ex ) |
758 | { | |
759 | // ignore | |
760 | 12 | } |
761 | 13 | } |
762 | } |