%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.