Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.net.io.Util |
0% |
0% |

1 |  |
     /*
2 |  |
      * Copyright 2001-2005 The Apache Software Foundation
3 |  |
      *
4 |  |
      * Licensed under the Apache License, Version 2.0 (the "License");
5 |  |
      * you may not use this file except in compliance with the License.
6 |  |
      * You may obtain a copy of the License at
7 |  |
      *
8 |  |
      *     http://www.apache.org/licenses/LICENSE-2.0
9 |  |
      *
10 |  |
      * Unless required by applicable law or agreed to in writing, software
11 |  |
      * distributed under the License is distributed on an "AS IS" BASIS,
12 |  |
      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  |
      * See the License for the specific language governing permissions and
14 |  |
      * limitations under the License.
15 |  |
      */
16 |  |
     package org.apache.commons.net.io;
17 |  |
18 |  |
     import java.io.IOException;
19 |  |
     import java.io.InputStream;
20 |  |
     import java.io.OutputStream;
21 |  |
     import java.io.Reader;
22 |  |
     import java.io.Writer;
23 |  |
24 |  |
     /***
25 |  |
      * The Util class cannot be instantiated and stores short static convenience
26 |  |
      * methods that are often quite useful.
27 |  |
      * <p>
28 |  |
      * <p>
29 |  |
      * @see CopyStreamException
30 |  |
      * @see CopyStreamListener
31 |  |
      * @see CopyStreamAdapter
32 |  |
      * @author Daniel F. Savarese
33 |  |
      ***/
34 |  |
35 |  |
     public final class Util
36 |  |
     {
37 |  |
         /***
38 |  |
          * The default buffer size used by {@link #copyStream  copyStream }
39 |  |
          * and {@link #copyReader  copyReader }. It's value is 1024.
40 |  |
          ***/
41 |  |
         public static final int DEFAULT_COPY_BUFFER_SIZE = 1024;
42 |  |
43 |  |
         // Cannot be instantiated
44 |  |
         private Util()
45 | 0 |
         { }
46 |  |
47 |  |
48 |  |
         /***
49 |  |
          * Copies the contents of an InputStream to an OutputStream using a
50 |  |
          * copy buffer of a given size and notifies the provided
51 |  |
          * CopyStreamListener of the progress of the copy operation by calling
52 |  |
          * its bytesTransferred(long, int) method after each write to the
53 |  |
          * destination.  If you wish to notify more than one listener you should
54 |  |
          * use a CopyStreamAdapter as the listener and register the additional
55 |  |
          * listeners with the CopyStreamAdapter.
56 |  |
          * <p>
57 |  |
          * The contents of the InputStream are
58 |  |
          * read until the end of the stream is reached, but neither the
59 |  |
          * source nor the destination are closed.  You must do this yourself
60 |  |
          * outside of the method call.  The number of bytes read/written is
61 |  |
          * returned.
62 |  |
          * <p>
63 |  |
          * @param source  The source InputStream.
64 |  |
          * @param dest    The destination OutputStream.
65 |  |
          * @param bufferSize  The number of bytes to buffer during the copy.
66 |  |
          * @param streamSize  The number of bytes in the stream being copied.
67 |  |
          *          Should be set to CopyStreamEvent.UNKNOWN_STREAM_SIZE if unknown.
68 |  |
          * @param listener  The CopyStreamListener to notify of progress.  If
69 |  |
          *      this parameter is null, notification is not attempted.
70 |  |
          * @param flush Whether to flush the output stream after every
71 |  |
          *        write.  This is necessary for interactive sessions that rely on
72 |  |
          *        buffered streams.  If you don't flush, the data will stay in
73 |  |
          *        the stream buffer.
74 |  |
          * @exception CopyStreamException  If an error occurs while reading from the
75 |  |
          *            source or writing to the destination.  The CopyStreamException
76 |  |
          *            will contain the number of bytes confirmed to have been
77 |  |
          *            transferred before an
78 |  |
          *            IOException occurred, and it will also contain the IOException
79 |  |
          *            that caused the error.  These values can be retrieved with
80 |  |
          *            the CopyStreamException getTotalBytesTransferred() and
81 |  |
          *            getIOException() methods.
82 |  |
          ***/
83 |  |
         public static final long copyStream(InputStream source, OutputStream dest,
84 |  |
                                             int bufferSize, long streamSize,
85 |  |
                                             CopyStreamListener listener,
86 |  |
                                             boolean flush)
87 |  |
         throws CopyStreamException
88 |  |
         {
89 |  |
             int bytes;
90 |  |
             long total;
91 |  |
             byte[] buffer;
92 |  |
93 | 0 |
             buffer = new byte[bufferSize];
94 | 0 |
             total = 0;
95 |  |
96 |  |
             try
97 |  |
             {
98 | 0 |
                 while ((bytes = source.read(buffer)) != -1)
99 |  |
                 {
100 |  |
                     // Technically, some read(byte[]) methods may return 0 and we cannot
101 |  |
                     // accept that as an indication of EOF.
102 |  |
103 | 0 |
                     if (bytes == 0)
104 |  |
                     {
105 | 0 |
                         bytes = source.read();
106 | 0 |
                         if (bytes < 0)
107 | 0 |
                             break;
108 | 0 |
                         dest.write(bytes);
109 | 0 |
                         if(flush)
110 | 0 |
                           dest.flush();
111 | 0 |
                         ++total;
112 | 0 |
                         if (listener != null)
113 | 0 |
                             listener.bytesTransferred(total, 1, streamSize);
114 |  |
                         continue;
115 |  |
                     }
116 |  |
117 | 0 |
                     dest.write(buffer, 0, bytes);
118 | 0 |
                     if(flush)
119 | 0 |
                       dest.flush();
120 | 0 |
                     total += bytes;
121 | 0 |
                     if (listener != null)
122 | 0 |
                         listener.bytesTransferred(total, bytes, streamSize);
123 |  |
                 }
124 |  |
             }
125 | 0 |
             catch (IOException e)
126 |  |
             {
127 | 0 |
                 throw new CopyStreamException("IOException caught while copying.",
128 |  |
                                               total, e);
129 | 0 |
             }
130 |  |
131 | 0 |
             return total;
132 |  |
         }
133 |  |
134 |  |
135 |  |
         /***
136 |  |
          * Copies the contents of an InputStream to an OutputStream using a
137 |  |
          * copy buffer of a given size and notifies the provided
138 |  |
          * CopyStreamListener of the progress of the copy operation by calling
139 |  |
          * its bytesTransferred(long, int) method after each write to the
140 |  |
          * destination.  If you wish to notify more than one listener you should
141 |  |
          * use a CopyStreamAdapter as the listener and register the additional
142 |  |
          * listeners with the CopyStreamAdapter.
143 |  |
          * <p>
144 |  |
          * The contents of the InputStream are
145 |  |
          * read until the end of the stream is reached, but neither the
146 |  |
          * source nor the destination are closed.  You must do this yourself
147 |  |
          * outside of the method call.  The number of bytes read/written is
148 |  |
          * returned.
149 |  |
          * <p>
150 |  |
          * @param source  The source InputStream.
151 |  |
          * @param dest    The destination OutputStream.
152 |  |
          * @param bufferSize  The number of bytes to buffer during the copy.
153 |  |
          * @param streamSize  The number of bytes in the stream being copied.
154 |  |
          *          Should be set to CopyStreamEvent.UNKNOWN_STREAM_SIZE if unknown.
155 |  |
          * @param listener  The CopyStreamListener to notify of progress.  If
156 |  |
          *      this parameter is null, notification is not attempted.
157 |  |
          * @exception CopyStreamException  If an error occurs while reading from the
158 |  |
          *            source or writing to the destination.  The CopyStreamException
159 |  |
          *            will contain the number of bytes confirmed to have been
160 |  |
          *            transferred before an
161 |  |
          *            IOException occurred, and it will also contain the IOException
162 |  |
          *            that caused the error.  These values can be retrieved with
163 |  |
          *            the CopyStreamException getTotalBytesTransferred() and
164 |  |
          *            getIOException() methods.
165 |  |
          ***/
166 |  |
         public static final long copyStream(InputStream source, OutputStream dest,
167 |  |
                                             int bufferSize, long streamSize,
168 |  |
                                             CopyStreamListener listener)
169 |  |
         throws CopyStreamException
170 |  |
         {
171 | 0 |
           return copyStream(source, dest, bufferSize, streamSize, listener,
172 |  |
                             true);
173 |  |
         }
174 |  |
175 |  |
176 |  |
         /***
177 |  |
          * Copies the contents of an InputStream to an OutputStream using a
178 |  |
          * copy buffer of a given size.  The contents of the InputStream are
179 |  |
          * read until the end of the stream is reached, but neither the
180 |  |
          * source nor the destination are closed.  You must do this yourself
181 |  |
          * outside of the method call.  The number of bytes read/written is
182 |  |
          * returned.
183 |  |
          * <p>
184 |  |
          * @param source  The source InputStream.
185 |  |
          * @param dest    The destination OutputStream.
186 |  |
          * @return  The number of bytes read/written in the copy operation.
187 |  |
          * @exception CopyStreamException  If an error occurs while reading from the
188 |  |
          *            source or writing to the destination.  The CopyStreamException
189 |  |
          *            will contain the number of bytes confirmed to have been
190 |  |
          *            transferred before an
191 |  |
          *            IOException occurred, and it will also contain the IOException
192 |  |
          *            that caused the error.  These values can be retrieved with
193 |  |
          *            the CopyStreamException getTotalBytesTransferred() and
194 |  |
          *            getIOException() methods.
195 |  |
          ***/
196 |  |
         public static final long copyStream(InputStream source, OutputStream dest,
197 |  |
                                             int bufferSize)
198 |  |
         throws CopyStreamException
199 |  |
         {
200 | 0 |
             return copyStream(source, dest, bufferSize,
201 |  |
                               CopyStreamEvent.UNKNOWN_STREAM_SIZE, null);
202 |  |
         }
203 |  |
204 |  |
205 |  |
         /***
206 |  |
          * Same as <code> copyStream(source, dest, DEFAULT_COPY_BUFFER_SIZE); </code>
207 |  |
          ***/
208 |  |
         public static final long copyStream(InputStream source, OutputStream dest)
209 |  |
         throws CopyStreamException
210 |  |
         {
211 | 0 |
             return copyStream(source, dest, DEFAULT_COPY_BUFFER_SIZE);
212 |  |
         }
213 |  |
214 |  |
215 |  |
         /***
216 |  |
          * Copies the contents of a Reader to a Writer using a
217 |  |
          * copy buffer of a given size and notifies the provided
218 |  |
          * CopyStreamListener of the progress of the copy operation by calling
219 |  |
          * its bytesTransferred(long, int) method after each write to the
220 |  |
          * destination.  If you wish to notify more than one listener you should
221 |  |
          * use a CopyStreamAdapter as the listener and register the additional
222 |  |
          * listeners with the CopyStreamAdapter.
223 |  |
          * <p>
224 |  |
          * The contents of the Reader are
225 |  |
          * read until its end is reached, but neither the source nor the
226 |  |
          * destination are closed.  You must do this yourself outside of the
227 |  |
          * method call.  The number of characters read/written is returned.
228 |  |
          * <p>
229 |  |
          * @param source  The source Reader.
230 |  |
          * @param dest    The destination writer.
231 |  |
          * @param bufferSize  The number of characters to buffer during the copy.
232 |  |
          * @param streamSize  The number of characters in the stream being copied.
233 |  |
          *          Should be set to CopyStreamEvent.UNKNOWN_STREAM_SIZE if unknown.
234 |  |
          * @param listener  The CopyStreamListener to notify of progress.  If
235 |  |
          *      this parameter is null, notification is not attempted.
236 |  |
          * @return  The number of characters read/written in the copy operation.
237 |  |
          * @exception CopyStreamException  If an error occurs while reading from the
238 |  |
          *            source or writing to the destination.  The CopyStreamException
239 |  |
          *            will contain the number of bytes confirmed to have been
240 |  |
          *            transferred before an
241 |  |
          *            IOException occurred, and it will also contain the IOException
242 |  |
          *            that caused the error.  These values can be retrieved with
243 |  |
          *            the CopyStreamException getTotalBytesTransferred() and
244 |  |
          *            getIOException() methods.
245 |  |
          ***/
246 |  |
         public static final long copyReader(Reader source, Writer dest,
247 |  |
                                             int bufferSize, long streamSize,
248 |  |
                                             CopyStreamListener listener)
249 |  |
         throws CopyStreamException
250 |  |
         {
251 |  |
             int chars;
252 |  |
             long total;
253 |  |
             char[] buffer;
254 |  |
255 | 0 |
             buffer = new char[bufferSize];
256 | 0 |
             total = 0;
257 |  |
258 |  |
             try
259 |  |
             {
260 | 0 |
                 while ((chars = source.read(buffer)) != -1)
261 |  |
                 {
262 |  |
                     // Technically, some read(char[]) methods may return 0 and we cannot
263 |  |
                     // accept that as an indication of EOF.
264 | 0 |
                     if (chars == 0)
265 |  |
                     {
266 | 0 |
                         chars = source.read();
267 | 0 |
                         if (chars < 0)
268 | 0 |
                             break;
269 | 0 |
                         dest.write(chars);
270 | 0 |
                         dest.flush();
271 | 0 |
                         ++total;
272 | 0 |
                         if (listener != null)
273 | 0 |
                             listener.bytesTransferred(total, chars, streamSize);
274 |  |
                         continue;
275 |  |
                     }
276 |  |
277 | 0 |
                     dest.write(buffer, 0, chars);
278 | 0 |
                     dest.flush();
279 | 0 |
                     total += chars;
280 | 0 |
                     if (listener != null)
281 | 0 |
                         listener.bytesTransferred(total, chars, streamSize);
282 |  |
                 }
283 |  |
             }
284 | 0 |
             catch (IOException e)
285 |  |
             {
286 | 0 |
                 throw new CopyStreamException("IOException caught while copying.",
287 |  |
                                               total, e);
288 | 0 |
             }
289 |  |
290 | 0 |
             return total;
291 |  |
         }
292 |  |
293 |  |
294 |  |
         /***
295 |  |
          * Copies the contents of a Reader to a Writer using a
296 |  |
          * copy buffer of a given size.  The contents of the Reader are
297 |  |
          * read until its end is reached, but neither the source nor the
298 |  |
          * destination are closed.  You must do this yourself outside of the
299 |  |
          * method call.  The number of characters read/written is returned.
300 |  |
          * <p>
301 |  |
          * @param source  The source Reader.
302 |  |
          * @param dest    The destination writer.
303 |  |
          * @param bufferSize  The number of characters to buffer during the copy.
304 |  |
          * @return  The number of characters read/written in the copy operation.
305 |  |
          * @exception CopyStreamException  If an error occurs while reading from the
306 |  |
          *            source or writing to the destination.  The CopyStreamException
307 |  |
          *            will contain the number of bytes confirmed to have been
308 |  |
          *            transferred before an
309 |  |
          *            IOException occurred, and it will also contain the IOException
310 |  |
          *            that caused the error.  These values can be retrieved with
311 |  |
          *            the CopyStreamException getTotalBytesTransferred() and
312 |  |
          *            getIOException() methods.
313 |  |
          ***/
314 |  |
         public static final long copyReader(Reader source, Writer dest,
315 |  |
                                             int bufferSize)
316 |  |
         throws CopyStreamException
317 |  |
         {
318 | 0 |
             return copyReader(source, dest, bufferSize,
319 |  |
                               CopyStreamEvent.UNKNOWN_STREAM_SIZE, null);
320 |  |
         }
321 |  |
322 |  |
323 |  |
         /***
324 |  |
          * Same as <code> copyReader(source, dest, DEFAULT_COPY_BUFFER_SIZE); </code>
325 |  |
          ***/
326 |  |
         public static final long copyReader(Reader source, Writer dest)
327 |  |
         throws CopyStreamException
328 |  |
         {
329 | 0 |
             return copyReader(source, dest, DEFAULT_COPY_BUFFER_SIZE);
330 |  |
         }
331 |  |
332 |  |
     }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.