android-34/libcore/io/Streams.java - platform/prebuilts/fullsdk/sources - Gitiles

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package libcore.io;

 import static android.annotation.SystemApi.Client.MODULE_LIBRARIES;

 import android.annotation.SystemApi;
 import android.compat.annotation.UnsupportedAppUsage;

 import java.io.ByteArrayOutputStream;
 import java.io.EOFException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.Reader;
 import java.io.StringWriter;
 import java.util.concurrent.atomic.AtomicReference;
 import libcore.util.ArrayUtils;
 import libcore.util.NonNull;
 import libcore.util.Nullable;

 /**
  * Convenience class for reading and writing streams of bytes.
  *
  * @hide
  */
 @SystemApi(client = MODULE_LIBRARIES)
 public final class Streams {
     private static AtomicReference<byte[]> skipBuffer = new AtomicReference<byte[]>();

     private Streams() {}

     /**
      * Implements {@link InputStream#read(int)} in terms of {@link InputStream#read(byte[], int, int)}.
      * {@link InputStream} assumes that you implement {@link InputStream#read(int)} and provides default
      * implementations of the others, but often the opposite is more efficient.
      *
      * @param in {@link InputStream} to read byte from
      * @return singlge byte read from {@code in}
      * @throws IOException in case of I/O error
      *
      * @hide
      */
     @UnsupportedAppUsage
     @SystemApi(client = MODULE_LIBRARIES)
     public static int readSingleByte(@NonNull InputStream in) throws IOException {
         byte[] buffer = new byte[1];
         int result = in.read(buffer, 0, 1);
         return (result != -1) ? buffer[0] & 0xff : -1;
     }

     /**
      * Implements {@link OutputStream#write(int)} in terms of {@link OutputStream#write(byte[], int, int)}.
      * {@link OutputStream} assumes that you implement {@link OutputStream#write(int)} and provides default
      * implementations of the others, but often the opposite is more efficient.
      *
      * @param out {@link OutputStream} to write byte to
      * @param b byte to write to stream {@code out}
      * @throws IOException in case of I/O error
      *
      * @hide
      */
     @UnsupportedAppUsage
     @SystemApi(client = MODULE_LIBRARIES)
     public static void writeSingleByte(@NonNull OutputStream out, int b) throws IOException {
         byte[] buffer = new byte[1];
         buffer[0] = (byte) (b & 0xff);
         out.write(buffer);
     }

     /**
      * Fills byte buffer {@code dst} with bytes from {@link InputStream} {@code in}, throwing
      * {@link EOFException} if insufficient bytes are available.
      *
      * @param in {@link InputStream} to read data from
      * @param dst byte buffer to write data to
      * @throws IOException in case of I/O error
      *
      * @hide
      */
     @UnsupportedAppUsage
     @SystemApi(client = MODULE_LIBRARIES)
     public static void readFully(@NonNull InputStream in, @NonNull byte[] dst) throws IOException {
         readFully(in, dst, 0, dst.length);
     }

     /**
      * Reads exactly 'byteCount' bytes from 'in' (into 'dst' at offset 'offset'), and throws
      * EOFException if insufficient bytes are available.
      *
      * Used to implement {@link java.io.DataInputStream#readFully(byte[], int, int)}.
      *
      * @hide
      */
     public static void readFully(InputStream in, byte[] dst, int offset, int byteCount) throws IOException {
         if (byteCount == 0) {
             return;
         }
         if (in == null) {
             throw new NullPointerException("in == null");
         }
         if (dst == null) {
             throw new NullPointerException("dst == null");
         }
         ArrayUtils.throwsIfOutOfBounds(dst.length, offset, byteCount);
         while (byteCount > 0) {
             int bytesRead = in.read(dst, offset, byteCount);
             if (bytesRead < 0) {
                 throw new EOFException();
             }
             offset += bytesRead;
             byteCount -= bytesRead;
         }
     }

     /**
      * Returns a {@code byte[]} containing the remainder of {@code in} stream and
      * closes it. Also see {@link #readFullyNoClose(InputStream)}.
      *
      * @param in {@link InputStream} to read data from
      * @return remaining bytes in {@code in} stream.
      * @throws IOException thrown by {@link InputStream#read(byte[])}.
      *
      * @hide
      */
     @UnsupportedAppUsage
     @SystemApi(client = MODULE_LIBRARIES)
     public static @NonNull byte[] readFully(@NonNull InputStream in) throws IOException {
         try {
             return readFullyNoClose(in);
         } finally {
             in.close();
         }
     }

     /**
      * Returns a {@code byte[]} containing the remainder of {@code in} stream, without
      * closing it.
      *
      * @param in {@link InputStream} to read data from
      * @return remaining bytes in {@code in} stream.
      * @throws IOException thrown by {@link InputStream#read(byte[])}.
      *
      * @hide
      */
     @SystemApi(client = MODULE_LIBRARIES)
     public static @NonNull byte[] readFullyNoClose(@NonNull InputStream in) throws IOException {
         ByteArrayOutputStream bytes = new ByteArrayOutputStream();
         byte[] buffer = new byte[1024];
         int count;
         while ((count = in.read(buffer)) != -1) {
             bytes.write(buffer, 0, count);
         }
         return bytes.toByteArray();
     }

     /**
      * Reads the remainder of {@code reader} as a string, closing it when done.
      *
      * @param reader {@link Reader} instance.
      * @return remainder of {@code reader} as {@link String}.
      * @throws IOException thrown by {@link Reader#read(java.nio.CharBuffer)}.
      *
      * @hide
      */
     @SystemApi(client = MODULE_LIBRARIES)
     public static @NonNull String readFully(@NonNull Reader reader) throws IOException {
         try {
             StringWriter writer = new StringWriter();
             char[] buffer = new char[1024];
             int count;
             while ((count = reader.read(buffer)) != -1) {
                 writer.write(buffer, 0, count);
             }
             return writer.toString();
         } finally {
             reader.close();
         }
     }

     /**
      * @hide
      */
     @UnsupportedAppUsage
     public static void skipAll(InputStream in) throws IOException {
         do {
             in.skip(Long.MAX_VALUE);
         } while (in.read() != -1);
     }

     /**
      * Skip <b>at most</b> {@code byteCount} bytes from {@code in} by calling read
      * repeatedly until either the stream is exhausted or we read fewer bytes than
      * we ask for.
      *
      * <p>This method reuses the skip buffer but is careful to never use it at
      * the same time that another stream is using it. Otherwise streams that use
      * the caller's buffer for consistency checks like CRC could be clobbered by
      * other threads. A thread-local buffer is also insufficient because some
      * streams may call other streams in their skip() method, also clobbering the
      * buffer.
      *
      * @param in {@link InputStream} to skip data from
      * @param byteCount number of bytes to skip from {@code in}
      * @return number of bytes skipped from {@code in}
      * @throws IOException in case of I/O error
      *
      * @hide
      */
     @SystemApi(client = MODULE_LIBRARIES)
     public static long skipByReading(@NonNull InputStream in, long byteCount) throws IOException {
         // acquire the shared skip buffer.
         byte[] buffer = skipBuffer.getAndSet(null);
         if (buffer == null) {
             buffer = new byte[4096];
         }

         long skipped = 0;
         while (skipped < byteCount) {
             int toRead = (int) Math.min(byteCount - skipped, buffer.length);
             int read = in.read(buffer, 0, toRead);
             if (read == -1) {
                 break;
             }
             skipped += read;
             if (read < toRead) {
                 break;
             }
         }

         // release the shared skip buffer.
         skipBuffer.set(buffer);

         return skipped;
     }

     /**
      * Copies all of the bytes from {@code in} to {@code out}. Neither stream is
      * closed.
      *
      * @param in {@link InputStream} to copy data from
      * @param out {@link InputStream} to write copied data to
      * @return the total number of bytes transferred.
      * @throws IOException reading from {@link InputStream} or writing to {@link OutputStream}.
      *
      * @hide
      */
     @UnsupportedAppUsage
     @SystemApi(client = MODULE_LIBRARIES)
     public static int copy(@NonNull InputStream in, @NonNull OutputStream out) throws IOException {
         int total = 0;
         byte[] buffer = new byte[8192];
         int c;
         while ((c = in.read(buffer)) != -1) {
             total += c;
             out.write(buffer, 0, c);
         }
         return total;
     }

     /**
      * Returns the ASCII characters up to but not including the next "\r\n", or
      * "\n".
      *
      * @throws java.io.EOFException if the stream is exhausted before the next newline
      *     character.
      *
      * @hide
      */
     @UnsupportedAppUsage
     public static String readAsciiLine(InputStream in) throws IOException {
         // TODO: support UTF-8 here instead

         StringBuilder result = new StringBuilder(80);
         while (true) {
             int c = in.read();
             if (c == -1) {
                 throw new EOFException();
             } else if (c == '\n') {
                 break;
             }

             result.append((char) c);
         }
         int length = result.length();
         if (length > 0 && result.charAt(length - 1) == '\r') {
             result.setLength(length - 1);
         }
         return result.toString();
     }
 }
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package libcore.io;

	import static android.annotation.SystemApi.Client.MODULE_LIBRARIES;

	import android.annotation.SystemApi;
	import android.compat.annotation.UnsupportedAppUsage;

	import java.io.ByteArrayOutputStream;
	import java.io.EOFException;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.io.Reader;
	import java.io.StringWriter;
	import java.util.concurrent.atomic.AtomicReference;
	import libcore.util.ArrayUtils;
	import libcore.util.NonNull;
	import libcore.util.Nullable;

	/**
	* Convenience class for reading and writing streams of bytes.
	*
	* @hide
	*/
	@SystemApi(client = MODULE_LIBRARIES)
	public final class Streams {
	private static AtomicReference<byte[]> skipBuffer = new AtomicReference<byte[]>();

	private Streams() {}

	/**
	* Implements {@link InputStream#read(int)} in terms of {@link InputStream#read(byte[], int, int)}.
	* {@link InputStream} assumes that you implement {@link InputStream#read(int)} and provides default
	* implementations of the others, but often the opposite is more efficient.
	*
	* @param in {@link InputStream} to read byte from
	* @return singlge byte read from {@code in}
	* @throws IOException in case of I/O error
	*
	* @hide
	*/
	@UnsupportedAppUsage
	@SystemApi(client = MODULE_LIBRARIES)
	public static int readSingleByte(@NonNull InputStream in) throws IOException {
	byte[] buffer = new byte[1];
	int result = in.read(buffer, 0, 1);
	return (result != -1) ? buffer[0] & 0xff : -1;
	}

	/**
	* Implements {@link OutputStream#write(int)} in terms of {@link OutputStream#write(byte[], int, int)}.
	* {@link OutputStream} assumes that you implement {@link OutputStream#write(int)} and provides default
	* implementations of the others, but often the opposite is more efficient.
	*
	* @param out {@link OutputStream} to write byte to
	* @param b byte to write to stream {@code out}
	* @throws IOException in case of I/O error
	*
	* @hide
	*/
	@UnsupportedAppUsage
	@SystemApi(client = MODULE_LIBRARIES)
	public static void writeSingleByte(@NonNull OutputStream out, int b) throws IOException {
	byte[] buffer = new byte[1];
	buffer[0] = (byte) (b & 0xff);
	out.write(buffer);
	}

	/**
	* Fills byte buffer {@code dst} with bytes from {@link InputStream} {@code in}, throwing
	* {@link EOFException} if insufficient bytes are available.
	*
	* @param in {@link InputStream} to read data from
	* @param dst byte buffer to write data to
	* @throws IOException in case of I/O error
	*
	* @hide
	*/
	@UnsupportedAppUsage
	@SystemApi(client = MODULE_LIBRARIES)
	public static void readFully(@NonNull InputStream in, @NonNull byte[] dst) throws IOException {
	readFully(in, dst, 0, dst.length);
	}

	/**
	* Reads exactly 'byteCount' bytes from 'in' (into 'dst' at offset 'offset'), and throws
	* EOFException if insufficient bytes are available.
	*
	* Used to implement {@link java.io.DataInputStream#readFully(byte[], int, int)}.
	*
	* @hide
	*/
	public static void readFully(InputStream in, byte[] dst, int offset, int byteCount) throws IOException {
	if (byteCount == 0) {
	return;
	}
	if (in == null) {
	throw new NullPointerException("in == null");
	}
	if (dst == null) {
	throw new NullPointerException("dst == null");
	}
	ArrayUtils.throwsIfOutOfBounds(dst.length, offset, byteCount);
	while (byteCount > 0) {
	int bytesRead = in.read(dst, offset, byteCount);
	if (bytesRead < 0) {
	throw new EOFException();
	}
	offset += bytesRead;
	byteCount -= bytesRead;
	}
	}

	/**
	* Returns a {@code byte[]} containing the remainder of {@code in} stream and
	* closes it. Also see {@link #readFullyNoClose(InputStream)}.
	*
	* @param in {@link InputStream} to read data from
	* @return remaining bytes in {@code in} stream.
	* @throws IOException thrown by {@link InputStream#read(byte[])}.
	*
	* @hide
	*/
	@UnsupportedAppUsage
	@SystemApi(client = MODULE_LIBRARIES)
	public static @NonNull byte[] readFully(@NonNull InputStream in) throws IOException {
	try {
	return readFullyNoClose(in);
	} finally {
	in.close();
	}
	}

	/**
	* Returns a {@code byte[]} containing the remainder of {@code in} stream, without
	* closing it.
	*
	* @param in {@link InputStream} to read data from
	* @return remaining bytes in {@code in} stream.
	* @throws IOException thrown by {@link InputStream#read(byte[])}.
	*
	* @hide
	*/
	@SystemApi(client = MODULE_LIBRARIES)
	public static @NonNull byte[] readFullyNoClose(@NonNull InputStream in) throws IOException {
	ByteArrayOutputStream bytes = new ByteArrayOutputStream();
	byte[] buffer = new byte[1024];
	int count;
	while ((count = in.read(buffer)) != -1) {
	bytes.write(buffer, 0, count);
	}
	return bytes.toByteArray();
	}

	/**
	* Reads the remainder of {@code reader} as a string, closing it when done.
	*
	* @param reader {@link Reader} instance.
	* @return remainder of {@code reader} as {@link String}.
	* @throws IOException thrown by {@link Reader#read(java.nio.CharBuffer)}.
	*
	* @hide
	*/
	@SystemApi(client = MODULE_LIBRARIES)
	public static @NonNull String readFully(@NonNull Reader reader) throws IOException {
	try {
	StringWriter writer = new StringWriter();
	char[] buffer = new char[1024];
	int count;
	while ((count = reader.read(buffer)) != -1) {
	writer.write(buffer, 0, count);
	}
	return writer.toString();
	} finally {
	reader.close();
	}
	}

	/**
	* @hide
	*/
	@UnsupportedAppUsage
	public static void skipAll(InputStream in) throws IOException {
	do {
	in.skip(Long.MAX_VALUE);
	} while (in.read() != -1);
	}

	/**
	* Skip <b>at most</b> {@code byteCount} bytes from {@code in} by calling read
	* repeatedly until either the stream is exhausted or we read fewer bytes than
	* we ask for.
	*
	* <p>This method reuses the skip buffer but is careful to never use it at
	* the same time that another stream is using it. Otherwise streams that use
	* the caller's buffer for consistency checks like CRC could be clobbered by
	* other threads. A thread-local buffer is also insufficient because some
	* streams may call other streams in their skip() method, also clobbering the
	* buffer.
	*
	* @param in {@link InputStream} to skip data from
	* @param byteCount number of bytes to skip from {@code in}
	* @return number of bytes skipped from {@code in}
	* @throws IOException in case of I/O error
	*
	* @hide
	*/
	@SystemApi(client = MODULE_LIBRARIES)
	public static long skipByReading(@NonNull InputStream in, long byteCount) throws IOException {
	// acquire the shared skip buffer.
	byte[] buffer = skipBuffer.getAndSet(null);
	if (buffer == null) {
	buffer = new byte[4096];
	}

	long skipped = 0;
	while (skipped < byteCount) {
	int toRead = (int) Math.min(byteCount - skipped, buffer.length);
	int read = in.read(buffer, 0, toRead);
	if (read == -1) {
	break;
	}
	skipped += read;
	if (read < toRead) {
	break;
	}
	}

	// release the shared skip buffer.
	skipBuffer.set(buffer);

	return skipped;
	}

	/**
	* Copies all of the bytes from {@code in} to {@code out}. Neither stream is
	* closed.
	*
	* @param in {@link InputStream} to copy data from
	* @param out {@link InputStream} to write copied data to
	* @return the total number of bytes transferred.
	* @throws IOException reading from {@link InputStream} or writing to {@link OutputStream}.
	*
	* @hide
	*/
	@UnsupportedAppUsage
	@SystemApi(client = MODULE_LIBRARIES)
	public static int copy(@NonNull InputStream in, @NonNull OutputStream out) throws IOException {
	int total = 0;
	byte[] buffer = new byte[8192];
	int c;
	while ((c = in.read(buffer)) != -1) {
	total += c;
	out.write(buffer, 0, c);
	}
	return total;
	}

	/**
	* Returns the ASCII characters up to but not including the next "\r\n", or
	* "\n".
	*
	* @throws java.io.EOFException if the stream is exhausted before the next newline
	* character.
	*
	* @hide
	*/
	@UnsupportedAppUsage
	public static String readAsciiLine(InputStream in) throws IOException {
	// TODO: support UTF-8 here instead

	StringBuilder result = new StringBuilder(80);
	while (true) {
	int c = in.read();
	if (c == -1) {
	throw new EOFException();
	} else if (c == '\n') {
	break;
	}

	result.append((char) c);
	}
	int length = result.length();
	if (length > 0 && result.charAt(length - 1) == '\r') {
	result.setLength(length - 1);
	}
	return result.toString();
	}
	}