guava/src/com/google/common/io/ByteSource.java - platform/external/guava - Git at Google

 /*
  * Copyright (C) 2012 The Guava Authors
  *
  * 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 com.google.common.io;

 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;

 import com.google.common.annotations.Beta;
 import com.google.common.base.Ascii;
 import com.google.common.collect.ImmutableList;
 import com.google.common.hash.Funnels;
 import com.google.common.hash.HashCode;
 import com.google.common.hash.HashFunction;
 import com.google.common.hash.Hasher;

 import java.io.BufferedInputStream;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.Reader;
 import java.nio.charset.Charset;
 import java.util.Arrays;
 import java.util.Iterator;

 /**
  * A readable source of bytes, such as a file. Unlike an {@link InputStream}, a
  * {@code ByteSource} is not an open, stateful stream for input that can be read and closed.
  * Instead, it is an immutable <i>supplier</i> of {@code InputStream} instances.
  *
  * <p>{@code ByteSource} provides two kinds of methods:
  * <ul>
  *   <li><b>Methods that return a stream:</b> These methods should return a <i>new</i>, independent
  *   instance each time they are called. The caller is responsible for ensuring that the returned
  *   stream is closed.
  *   <li><b>Convenience methods:</b> These are implementations of common operations that are
  *   typically implemented by opening a stream using one of the methods in the first category, doing
  *   something and finally closing the stream that was opened.
  * </ul>
  *
  * @since 14.0
  * @author Colin Decker
  */
 public abstract class ByteSource {

   private static final int BUF_SIZE = 0x1000; // 4K

   /**
    * Constructor for use by subclasses.
    */
   protected ByteSource() {}

   /**
    * Returns a {@link CharSource} view of this byte source that decodes bytes read from this source
    * as characters using the given {@link Charset}.
    */
   public CharSource asCharSource(Charset charset) {
     return new AsCharSource(charset);
   }

   /**
    * Opens a new {@link InputStream} for reading from this source. This method should return a new,
    * independent stream each time it is called.
    *
    * <p>The caller is responsible for ensuring that the returned stream is closed.
    *
    * @throws IOException if an I/O error occurs in the process of opening the stream
    */
   public abstract InputStream openStream() throws IOException;

   /**
    * Opens a new buffered {@link InputStream} for reading from this source. The returned stream is
    * not required to be a {@link BufferedInputStream} in order to allow implementations to simply
    * delegate to {@link #openStream()} when the stream returned by that method does not benefit
    * from additional buffering (for example, a {@code ByteArrayInputStream}). This method should
    * return a new, independent stream each time it is called.
    *
    * <p>The caller is responsible for ensuring that the returned stream is closed.
    *
    * @throws IOException if an I/O error occurs in the process of opening the stream
    * @since 15.0 (in 14.0 with return type {@link BufferedInputStream})
    */
   public InputStream openBufferedStream() throws IOException {
     InputStream in = openStream();
     return (in instanceof BufferedInputStream)
         ? (BufferedInputStream) in
         : new BufferedInputStream(in);
   }

   /**
    * Returns a view of a slice of this byte source that is at most {@code length} bytes long
    * starting at the given {@code offset}.
    *
    * @throws IllegalArgumentException if {@code offset} or {@code length} is negative
    */
   public ByteSource slice(long offset, long length) {
     return new SlicedByteSource(offset, length);
   }

   /**
    * Returns whether the source has zero bytes. The default implementation is to open a stream and
    * check for EOF.
    *
    * @throws IOException if an I/O error occurs
    * @since 15.0
    */
   public boolean isEmpty() throws IOException {
     Closer closer = Closer.create();
     try {
       InputStream in = closer.register(openStream());
       return in.read() == -1;
     } catch (Throwable e) {
       throw closer.rethrow(e);
     } finally {
       closer.close();
     }
   }

   /**
    * Returns the size of this source in bytes. For most implementations, this is a heavyweight
    * operation that will open a stream, read (or {@link InputStream#skip(long) skip}, if possible)
    * to the end of the stream and return the total number of bytes that were read.
    *
    * <p>For some sources, such as a file, this method may use a more efficient implementation. Note
    * that in such cases, it is <i>possible</i> that this method will return a different number of
    * bytes than would be returned by reading all of the bytes (for example, some special files may
    * return a size of 0 despite actually having content when read).
    *
    * <p>In either case, if this is a mutable source such as a file, the size it returns may not be
    * the same number of bytes a subsequent read would return.
    *
    * @throws IOException if an I/O error occurs in the process of reading the size of this source
    */
   public long size() throws IOException {
     Closer closer = Closer.create();
     try {
       InputStream in = closer.register(openStream());
       return countBySkipping(in);
     } catch (IOException e) {
       // skip may not be supported... at any rate, try reading
     } finally {
       closer.close();
     }

     closer = Closer.create();
     try {
       InputStream in = closer.register(openStream());
       return countByReading(in);
     } catch (Throwable e) {
       throw closer.rethrow(e);
     } finally {
       closer.close();
     }
   }

   /**
    * Counts the bytes in the given input stream using skip if possible. Returns SKIP_FAILED if the
    * first call to skip threw, in which case skip may just not be supported.
    */
   private long countBySkipping(InputStream in) throws IOException {
     long count = 0;
     while (true) {
       // don't try to skip more than available()
       // things may work really wrong with FileInputStream otherwise
       long skipped = in.skip(Math.min(in.available(), Integer.MAX_VALUE));
       if (skipped <= 0) {
         if (in.read() == -1) {
           return count;
         } else if (count == 0 && in.available() == 0) {
           // if available is still zero after reading a single byte, it
           // will probably always be zero, so we should countByReading
           throw new IOException();
         }
         count++;
       } else {
         count += skipped;
       }
     }
   }

   private static final byte[] countBuffer = new byte[BUF_SIZE];

   private long countByReading(InputStream in) throws IOException {
     long count = 0;
     long read;
     while ((read = in.read(countBuffer)) != -1) {
       count += read;
     }
     return count;
   }

   /**
    * Copies the contents of this byte source to the given {@code OutputStream}. Does not close
    * {@code output}.
    *
    * @throws IOException if an I/O error occurs in the process of reading from this source or
    *     writing to {@code output}
    */
   public long copyTo(OutputStream output) throws IOException {
     checkNotNull(output);

     Closer closer = Closer.create();
     try {
       InputStream in = closer.register(openStream());
       return ByteStreams.copy(in, output);
     } catch (Throwable e) {
       throw closer.rethrow(e);
     } finally {
       closer.close();
     }
   }

   /**
    * Copies the contents of this byte source to the given {@code ByteSink}.
    *
    * @throws IOException if an I/O error occurs in the process of reading from this source or
    *     writing to {@code sink}
    */
   public long copyTo(ByteSink sink) throws IOException {
     checkNotNull(sink);

     Closer closer = Closer.create();
     try {
       InputStream in = closer.register(openStream());
       OutputStream out = closer.register(sink.openStream());
       return ByteStreams.copy(in, out);
     } catch (Throwable e) {
       throw closer.rethrow(e);
     } finally {
       closer.close();
     }
   }

   /**
    * Reads the full contents of this byte source as a byte array.
    *
    * @throws IOException if an I/O error occurs in the process of reading from this source
    */
   public byte[] read() throws IOException {
     Closer closer = Closer.create();
     try {
       InputStream in = closer.register(openStream());
       return ByteStreams.toByteArray(in);
     } catch (Throwable e) {
       throw closer.rethrow(e);
     } finally {
       closer.close();
     }
   }

   /**
    * Reads the contents of this byte source using the given {@code processor} to process bytes as
    * they are read. Stops when all bytes have been read or the consumer returns {@code false}.
    * Returns the result produced by the processor.
    *
    * @throws IOException if an I/O error occurs in the process of reading from this source or if
    *     {@code processor} throws an {@code IOException}
    * @since 16.0
    */
   @Beta
   public <T> T read(ByteProcessor<T> processor) throws IOException {
     checkNotNull(processor);

     Closer closer = Closer.create();
     try {
       InputStream in = closer.register(openStream());
       return ByteStreams.readBytes(in, processor);
     } catch (Throwable e) {
       throw closer.rethrow(e);
     } finally {
       closer.close();
     }
   }

   /**
    * Hashes the contents of this byte source using the given hash function.
    *
    * @throws IOException if an I/O error occurs in the process of reading from this source
    */
   public HashCode hash(HashFunction hashFunction) throws IOException {
     Hasher hasher = hashFunction.newHasher();
     copyTo(Funnels.asOutputStream(hasher));
     return hasher.hash();
   }

   /**
    * Checks that the contents of this byte source are equal to the contents of the given byte
    * source.
    *
    * @throws IOException if an I/O error occurs in the process of reading from this source or
    *     {@code other}
    */
   public boolean contentEquals(ByteSource other) throws IOException {
     checkNotNull(other);

     byte[] buf1 = new byte[BUF_SIZE];
     byte[] buf2 = new byte[BUF_SIZE];

     Closer closer = Closer.create();
     try {
       InputStream in1 = closer.register(openStream());
       InputStream in2 = closer.register(other.openStream());
       while (true) {
         int read1 = ByteStreams.read(in1, buf1, 0, BUF_SIZE);
         int read2 = ByteStreams.read(in2, buf2, 0, BUF_SIZE);
         if (read1 != read2 || !Arrays.equals(buf1, buf2)) {
           return false;
         } else if (read1 != BUF_SIZE) {
           return true;
         }
       }
     } catch (Throwable e) {
       throw closer.rethrow(e);
     } finally {
       closer.close();
     }
   }

   /**
    * Concatenates multiple {@link ByteSource} instances into a single source. Streams returned from
    * the source will contain the concatenated data from the streams of the underlying sources.
    *
    * <p>Only one underlying stream will be open at a time. Closing the concatenated stream will
    * close the open underlying stream.
    *
    * @param sources the sources to concatenate
    * @return a {@code ByteSource} containing the concatenated data
    * @since 15.0
    */
   public static ByteSource concat(Iterable<? extends ByteSource> sources) {
     return new ConcatenatedByteSource(sources);
   }

   /**
    * Concatenates multiple {@link ByteSource} instances into a single source. Streams returned from
    * the source will contain the concatenated data from the streams of the underlying sources.
    *
    * <p>Only one underlying stream will be open at a time. Closing the concatenated stream will
    * close the open underlying stream.
    *
    * <p>Note: The input {@code Iterator} will be copied to an {@code ImmutableList} when this
    * method is called. This will fail if the iterator is infinite and may cause problems if the
    * iterator eagerly fetches data for each source when iterated (rather than producing sources
    * that only load data through their streams). Prefer using the {@link #concat(Iterable)}
    * overload if possible.
    *
    * @param sources the sources to concatenate
    * @return a {@code ByteSource} containing the concatenated data
    * @throws NullPointerException if any of {@code sources} is {@code null}
    * @since 15.0
    */
   public static ByteSource concat(Iterator<? extends ByteSource> sources) {
     return concat(ImmutableList.copyOf(sources));
   }

   /**
    * Concatenates multiple {@link ByteSource} instances into a single source. Streams returned from
    * the source will contain the concatenated data from the streams of the underlying sources.
    *
    * <p>Only one underlying stream will be open at a time. Closing the concatenated stream will
    * close the open underlying stream.
    *
    * @param sources the sources to concatenate
    * @return a {@code ByteSource} containing the concatenated data
    * @throws NullPointerException if any of {@code sources} is {@code null}
    * @since 15.0
    */
   public static ByteSource concat(ByteSource... sources) {
     return concat(ImmutableList.copyOf(sources));
   }

   /**
    * Returns a view of the given byte array as a {@link ByteSource}. To view only a specific range
    * in the array, use {@code ByteSource.wrap(b).slice(offset, length)}.
    *
    * @since 15.0 (since 14.0 as {@code ByteStreams.asByteSource(byte[])}).
    */
   public static ByteSource wrap(byte[] b) {
     return new ByteArrayByteSource(b);
   }

   /**
    * Returns an immutable {@link ByteSource} that contains no bytes.
    *
    * @since 15.0
    */
   public static ByteSource empty() {
     return EmptyByteSource.INSTANCE;
   }

   /**
    * A char source that reads bytes from this source and decodes them as characters using a
    * charset.
    */
   private final class AsCharSource extends CharSource {

     private final Charset charset;

     private AsCharSource(Charset charset) {
       this.charset = checkNotNull(charset);
     }

     @Override
     public Reader openStream() throws IOException {
       return new InputStreamReader(ByteSource.this.openStream(), charset);
     }

     @Override
     public String toString() {
       return ByteSource.this.toString() + ".asCharSource(" + charset + ")";
     }
   }

   /**
    * A view of a subsection of the containing byte source.
    */
   private final class SlicedByteSource extends ByteSource {

     private final long offset;
     private final long length;

     private SlicedByteSource(long offset, long length) {
       checkArgument(offset >= 0, "offset (%s) may not be negative", offset);
       checkArgument(length >= 0, "length (%s) may not be negative", length);
       this.offset = offset;
       this.length = length;
     }

     @Override
     public InputStream openStream() throws IOException {
       return sliceStream(ByteSource.this.openStream());
     }

     @Override
     public InputStream openBufferedStream() throws IOException {
       return sliceStream(ByteSource.this.openBufferedStream());
     }

     private InputStream sliceStream(InputStream in) throws IOException {
       if (offset > 0) {
         try {
           ByteStreams.skipFully(in, offset);
         } catch (Throwable e) {
           Closer closer = Closer.create();
           closer.register(in);
           try {
             throw closer.rethrow(e);
           } finally {
             closer.close();
           }
         }
       }
       return ByteStreams.limit(in, length);
     }

     @Override
     public ByteSource slice(long offset, long length) {
       checkArgument(offset >= 0, "offset (%s) may not be negative", offset);
       checkArgument(length >= 0, "length (%s) may not be negative", length);
       long maxLength = this.length - offset;
       return ByteSource.this.slice(this.offset + offset, Math.min(length, maxLength));
     }

     @Override
     public boolean isEmpty() throws IOException {
       return length == 0 || super.isEmpty();
     }

     @Override
     public String toString() {
       return ByteSource.this.toString() + ".slice(" + offset + ", " + length + ")";
     }
   }

   private static class ByteArrayByteSource extends ByteSource {

     protected final byte[] bytes;

     protected ByteArrayByteSource(byte[] bytes) {
       this.bytes = checkNotNull(bytes);
     }

     @Override
     public InputStream openStream() {
       return new ByteArrayInputStream(bytes);
     }

     @Override
     public InputStream openBufferedStream() throws IOException {
       return openStream();
     }

     @Override
     public boolean isEmpty() {
       return bytes.length == 0;
     }

     @Override
     public long size() {
       return bytes.length;
     }

     @Override
     public byte[] read() {
       return bytes.clone();
     }

     @Override
     public long copyTo(OutputStream output) throws IOException {
       output.write(bytes);
       return bytes.length;
     }

     @Override
     public <T> T read(ByteProcessor<T> processor) throws IOException {
       processor.processBytes(bytes, 0, bytes.length);
       return processor.getResult();
     }

     @Override
     public HashCode hash(HashFunction hashFunction) throws IOException {
       return hashFunction.hashBytes(bytes);
     }

     // TODO(user): Possibly override slice()

     @Override
     public String toString() {
       return "ByteSource.wrap("
           + Ascii.truncate(BaseEncoding.base16().encode(bytes), 30, "...") + ")";
     }
   }

   private static final class EmptyByteSource extends ByteArrayByteSource {

     private static final EmptyByteSource INSTANCE = new EmptyByteSource();

     private EmptyByteSource() {
       super(new byte[0]);
     }

     @Override
     public CharSource asCharSource(Charset charset) {
       checkNotNull(charset);
       return CharSource.empty();
     }

     @Override
     public byte[] read() {
       return bytes; // length is 0, no need to clone
     }

     @Override
     public String toString() {
       return "ByteSource.empty()";
     }
   }

   private static final class ConcatenatedByteSource extends ByteSource {

     private final Iterable<? extends ByteSource> sources;

     ConcatenatedByteSource(Iterable<? extends ByteSource> sources) {
       this.sources = checkNotNull(sources);
     }

     @Override
     public InputStream openStream() throws IOException {
       return new MultiInputStream(sources.iterator());
     }

     @Override
     public boolean isEmpty() throws IOException {
       for (ByteSource source : sources) {
         if (!source.isEmpty()) {
           return false;
         }
       }
       return true;
     }

     @Override
     public long size() throws IOException {
       long result = 0L;
       for (ByteSource source : sources) {
         result += source.size();
       }
       return result;
     }

     @Override
     public String toString() {
       return "ByteSource.concat(" + sources + ")";
     }
   }
 }
	/*
	* Copyright (C) 2012 The Guava Authors
	*
	* 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 com.google.common.io;

	import static com.google.common.base.Preconditions.checkArgument;
	import static com.google.common.base.Preconditions.checkNotNull;

	import com.google.common.annotations.Beta;
	import com.google.common.base.Ascii;
	import com.google.common.collect.ImmutableList;
	import com.google.common.hash.Funnels;
	import com.google.common.hash.HashCode;
	import com.google.common.hash.HashFunction;
	import com.google.common.hash.Hasher;

	import java.io.BufferedInputStream;
	import java.io.ByteArrayInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.OutputStream;
	import java.io.Reader;
	import java.nio.charset.Charset;
	import java.util.Arrays;
	import java.util.Iterator;

	/**
	* A readable source of bytes, such as a file. Unlike an {@link InputStream}, a
	* {@code ByteSource} is not an open, stateful stream for input that can be read and closed.
	* Instead, it is an immutable <i>supplier</i> of {@code InputStream} instances.
	*
	* <p>{@code ByteSource} provides two kinds of methods:
	* <ul>
	* <li><b>Methods that return a stream:</b> These methods should return a <i>new</i>, independent
	* instance each time they are called. The caller is responsible for ensuring that the returned
	* stream is closed.
	* <li><b>Convenience methods:</b> These are implementations of common operations that are
	* typically implemented by opening a stream using one of the methods in the first category, doing
	* something and finally closing the stream that was opened.
	* </ul>
	*
	* @since 14.0
	* @author Colin Decker
	*/
	public abstract class ByteSource {

	private static final int BUF_SIZE = 0x1000; // 4K

	/**
	* Constructor for use by subclasses.
	*/
	protected ByteSource() {}

	/**
	* Returns a {@link CharSource} view of this byte source that decodes bytes read from this source
	* as characters using the given {@link Charset}.
	*/
	public CharSource asCharSource(Charset charset) {
	return new AsCharSource(charset);
	}

	/**
	* Opens a new {@link InputStream} for reading from this source. This method should return a new,
	* independent stream each time it is called.
	*
	* <p>The caller is responsible for ensuring that the returned stream is closed.
	*
	* @throws IOException if an I/O error occurs in the process of opening the stream
	*/
	public abstract InputStream openStream() throws IOException;

	/**
	* Opens a new buffered {@link InputStream} for reading from this source. The returned stream is
	* not required to be a {@link BufferedInputStream} in order to allow implementations to simply
	* delegate to {@link #openStream()} when the stream returned by that method does not benefit
	* from additional buffering (for example, a {@code ByteArrayInputStream}). This method should
	* return a new, independent stream each time it is called.
	*
	* <p>The caller is responsible for ensuring that the returned stream is closed.
	*
	* @throws IOException if an I/O error occurs in the process of opening the stream
	* @since 15.0 (in 14.0 with return type {@link BufferedInputStream})
	*/
	public InputStream openBufferedStream() throws IOException {
	InputStream in = openStream();
	return (in instanceof BufferedInputStream)
	? (BufferedInputStream) in
	: new BufferedInputStream(in);
	}

	/**
	* Returns a view of a slice of this byte source that is at most {@code length} bytes long
	* starting at the given {@code offset}.
	*
	* @throws IllegalArgumentException if {@code offset} or {@code length} is negative
	*/
	public ByteSource slice(long offset, long length) {
	return new SlicedByteSource(offset, length);
	}

	/**
	* Returns whether the source has zero bytes. The default implementation is to open a stream and
	* check for EOF.
	*
	* @throws IOException if an I/O error occurs
	* @since 15.0
	*/
	public boolean isEmpty() throws IOException {
	Closer closer = Closer.create();
	try {
	InputStream in = closer.register(openStream());
	return in.read() == -1;
	} catch (Throwable e) {
	throw closer.rethrow(e);
	} finally {
	closer.close();
	}
	}

	/**
	* Returns the size of this source in bytes. For most implementations, this is a heavyweight
	* operation that will open a stream, read (or {@link InputStream#skip(long) skip}, if possible)
	* to the end of the stream and return the total number of bytes that were read.
	*
	* <p>For some sources, such as a file, this method may use a more efficient implementation. Note
	* that in such cases, it is <i>possible</i> that this method will return a different number of
	* bytes than would be returned by reading all of the bytes (for example, some special files may
	* return a size of 0 despite actually having content when read).
	*
	* <p>In either case, if this is a mutable source such as a file, the size it returns may not be
	* the same number of bytes a subsequent read would return.
	*
	* @throws IOException if an I/O error occurs in the process of reading the size of this source
	*/
	public long size() throws IOException {
	Closer closer = Closer.create();
	try {
	InputStream in = closer.register(openStream());
	return countBySkipping(in);
	} catch (IOException e) {
	// skip may not be supported... at any rate, try reading
	} finally {
	closer.close();
	}

	closer = Closer.create();
	try {
	InputStream in = closer.register(openStream());
	return countByReading(in);
	} catch (Throwable e) {
	throw closer.rethrow(e);
	} finally {
	closer.close();
	}
	}

	/**
	* Counts the bytes in the given input stream using skip if possible. Returns SKIP_FAILED if the
	* first call to skip threw, in which case skip may just not be supported.
	*/
	private long countBySkipping(InputStream in) throws IOException {
	long count = 0;
	while (true) {
	// don't try to skip more than available()
	// things may work really wrong with FileInputStream otherwise
	long skipped = in.skip(Math.min(in.available(), Integer.MAX_VALUE));
	if (skipped <= 0) {
	if (in.read() == -1) {
	return count;
	} else if (count == 0 && in.available() == 0) {
	// if available is still zero after reading a single byte, it
	// will probably always be zero, so we should countByReading
	throw new IOException();
	}
	count++;
	} else {
	count += skipped;
	}
	}
	}

	private static final byte[] countBuffer = new byte[BUF_SIZE];

	private long countByReading(InputStream in) throws IOException {
	long count = 0;
	long read;
	while ((read = in.read(countBuffer)) != -1) {
	count += read;
	}
	return count;
	}

	/**
	* Copies the contents of this byte source to the given {@code OutputStream}. Does not close
	* {@code output}.
	*
	* @throws IOException if an I/O error occurs in the process of reading from this source or
	* writing to {@code output}
	*/
	public long copyTo(OutputStream output) throws IOException {
	checkNotNull(output);

	Closer closer = Closer.create();
	try {
	InputStream in = closer.register(openStream());
	return ByteStreams.copy(in, output);
	} catch (Throwable e) {
	throw closer.rethrow(e);
	} finally {
	closer.close();
	}
	}

	/**
	* Copies the contents of this byte source to the given {@code ByteSink}.
	*
	* @throws IOException if an I/O error occurs in the process of reading from this source or
	* writing to {@code sink}
	*/
	public long copyTo(ByteSink sink) throws IOException {
	checkNotNull(sink);

	Closer closer = Closer.create();
	try {
	InputStream in = closer.register(openStream());
	OutputStream out = closer.register(sink.openStream());
	return ByteStreams.copy(in, out);
	} catch (Throwable e) {
	throw closer.rethrow(e);
	} finally {
	closer.close();
	}
	}

	/**
	* Reads the full contents of this byte source as a byte array.
	*
	* @throws IOException if an I/O error occurs in the process of reading from this source
	*/
	public byte[] read() throws IOException {
	Closer closer = Closer.create();
	try {
	InputStream in = closer.register(openStream());
	return ByteStreams.toByteArray(in);
	} catch (Throwable e) {
	throw closer.rethrow(e);
	} finally {
	closer.close();
	}
	}

	/**
	* Reads the contents of this byte source using the given {@code processor} to process bytes as
	* they are read. Stops when all bytes have been read or the consumer returns {@code false}.
	* Returns the result produced by the processor.
	*
	* @throws IOException if an I/O error occurs in the process of reading from this source or if
	* {@code processor} throws an {@code IOException}
	* @since 16.0
	*/
	@Beta
	public <T> T read(ByteProcessor<T> processor) throws IOException {
	checkNotNull(processor);

	Closer closer = Closer.create();
	try {
	InputStream in = closer.register(openStream());
	return ByteStreams.readBytes(in, processor);
	} catch (Throwable e) {
	throw closer.rethrow(e);
	} finally {
	closer.close();
	}
	}

	/**
	* Hashes the contents of this byte source using the given hash function.
	*
	* @throws IOException if an I/O error occurs in the process of reading from this source
	*/
	public HashCode hash(HashFunction hashFunction) throws IOException {
	Hasher hasher = hashFunction.newHasher();
	copyTo(Funnels.asOutputStream(hasher));
	return hasher.hash();
	}

	/**
	* Checks that the contents of this byte source are equal to the contents of the given byte
	* source.
	*
	* @throws IOException if an I/O error occurs in the process of reading from this source or
	* {@code other}
	*/
	public boolean contentEquals(ByteSource other) throws IOException {
	checkNotNull(other);

	byte[] buf1 = new byte[BUF_SIZE];
	byte[] buf2 = new byte[BUF_SIZE];

	Closer closer = Closer.create();
	try {
	InputStream in1 = closer.register(openStream());
	InputStream in2 = closer.register(other.openStream());
	while (true) {
	int read1 = ByteStreams.read(in1, buf1, 0, BUF_SIZE);
	int read2 = ByteStreams.read(in2, buf2, 0, BUF_SIZE);
	if (read1 != read2 \|\| !Arrays.equals(buf1, buf2)) {
	return false;
	} else if (read1 != BUF_SIZE) {
	return true;
	}
	}
	} catch (Throwable e) {
	throw closer.rethrow(e);
	} finally {
	closer.close();
	}
	}

	/**
	* Concatenates multiple {@link ByteSource} instances into a single source. Streams returned from
	* the source will contain the concatenated data from the streams of the underlying sources.
	*
	* <p>Only one underlying stream will be open at a time. Closing the concatenated stream will
	* close the open underlying stream.
	*
	* @param sources the sources to concatenate
	* @return a {@code ByteSource} containing the concatenated data
	* @since 15.0
	*/
	public static ByteSource concat(Iterable<? extends ByteSource> sources) {
	return new ConcatenatedByteSource(sources);
	}

	/**
	* Concatenates multiple {@link ByteSource} instances into a single source. Streams returned from
	* the source will contain the concatenated data from the streams of the underlying sources.
	*
	* <p>Only one underlying stream will be open at a time. Closing the concatenated stream will
	* close the open underlying stream.
	*
	* <p>Note: The input {@code Iterator} will be copied to an {@code ImmutableList} when this
	* method is called. This will fail if the iterator is infinite and may cause problems if the
	* iterator eagerly fetches data for each source when iterated (rather than producing sources
	* that only load data through their streams). Prefer using the {@link #concat(Iterable)}
	* overload if possible.
	*
	* @param sources the sources to concatenate
	* @return a {@code ByteSource} containing the concatenated data
	* @throws NullPointerException if any of {@code sources} is {@code null}
	* @since 15.0
	*/
	public static ByteSource concat(Iterator<? extends ByteSource> sources) {
	return concat(ImmutableList.copyOf(sources));
	}

	/**
	* Concatenates multiple {@link ByteSource} instances into a single source. Streams returned from
	* the source will contain the concatenated data from the streams of the underlying sources.
	*
	* <p>Only one underlying stream will be open at a time. Closing the concatenated stream will
	* close the open underlying stream.
	*
	* @param sources the sources to concatenate
	* @return a {@code ByteSource} containing the concatenated data
	* @throws NullPointerException if any of {@code sources} is {@code null}
	* @since 15.0
	*/
	public static ByteSource concat(ByteSource... sources) {
	return concat(ImmutableList.copyOf(sources));
	}

	/**
	* Returns a view of the given byte array as a {@link ByteSource}. To view only a specific range
	* in the array, use {@code ByteSource.wrap(b).slice(offset, length)}.
	*
	* @since 15.0 (since 14.0 as {@code ByteStreams.asByteSource(byte[])}).
	*/
	public static ByteSource wrap(byte[] b) {
	return new ByteArrayByteSource(b);
	}

	/**
	* Returns an immutable {@link ByteSource} that contains no bytes.
	*
	* @since 15.0
	*/
	public static ByteSource empty() {
	return EmptyByteSource.INSTANCE;
	}

	/**
	* A char source that reads bytes from this source and decodes them as characters using a
	* charset.
	*/
	private final class AsCharSource extends CharSource {

	private final Charset charset;

	private AsCharSource(Charset charset) {
	this.charset = checkNotNull(charset);
	}

	@Override
	public Reader openStream() throws IOException {
	return new InputStreamReader(ByteSource.this.openStream(), charset);
	}

	@Override
	public String toString() {
	return ByteSource.this.toString() + ".asCharSource(" + charset + ")";
	}
	}

	/**
	* A view of a subsection of the containing byte source.
	*/
	private final class SlicedByteSource extends ByteSource {

	private final long offset;
	private final long length;

	private SlicedByteSource(long offset, long length) {
	checkArgument(offset >= 0, "offset (%s) may not be negative", offset);
	checkArgument(length >= 0, "length (%s) may not be negative", length);
	this.offset = offset;
	this.length = length;
	}

	@Override
	public InputStream openStream() throws IOException {
	return sliceStream(ByteSource.this.openStream());
	}

	@Override
	public InputStream openBufferedStream() throws IOException {
	return sliceStream(ByteSource.this.openBufferedStream());
	}

	private InputStream sliceStream(InputStream in) throws IOException {
	if (offset > 0) {
	try {
	ByteStreams.skipFully(in, offset);
	} catch (Throwable e) {
	Closer closer = Closer.create();
	closer.register(in);
	try {
	throw closer.rethrow(e);
	} finally {
	closer.close();
	}
	}
	}
	return ByteStreams.limit(in, length);
	}

	@Override
	public ByteSource slice(long offset, long length) {
	checkArgument(offset >= 0, "offset (%s) may not be negative", offset);
	checkArgument(length >= 0, "length (%s) may not be negative", length);
	long maxLength = this.length - offset;
	return ByteSource.this.slice(this.offset + offset, Math.min(length, maxLength));
	}

	@Override
	public boolean isEmpty() throws IOException {
	return length == 0 \|\| super.isEmpty();
	}

	@Override
	public String toString() {
	return ByteSource.this.toString() + ".slice(" + offset + ", " + length + ")";
	}
	}

	private static class ByteArrayByteSource extends ByteSource {

	protected final byte[] bytes;

	protected ByteArrayByteSource(byte[] bytes) {
	this.bytes = checkNotNull(bytes);
	}

	@Override
	public InputStream openStream() {
	return new ByteArrayInputStream(bytes);
	}

	@Override
	public InputStream openBufferedStream() throws IOException {
	return openStream();
	}

	@Override
	public boolean isEmpty() {
	return bytes.length == 0;
	}

	@Override
	public long size() {
	return bytes.length;
	}

	@Override
	public byte[] read() {
	return bytes.clone();
	}

	@Override
	public long copyTo(OutputStream output) throws IOException {
	output.write(bytes);
	return bytes.length;
	}

	@Override
	public <T> T read(ByteProcessor<T> processor) throws IOException {
	processor.processBytes(bytes, 0, bytes.length);
	return processor.getResult();
	}

	@Override
	public HashCode hash(HashFunction hashFunction) throws IOException {
	return hashFunction.hashBytes(bytes);
	}

	// TODO(user): Possibly override slice()

	@Override
	public String toString() {
	return "ByteSource.wrap("
	+ Ascii.truncate(BaseEncoding.base16().encode(bytes), 30, "...") + ")";
	}
	}

	private static final class EmptyByteSource extends ByteArrayByteSource {

	private static final EmptyByteSource INSTANCE = new EmptyByteSource();

	private EmptyByteSource() {
	super(new byte[0]);
	}

	@Override
	public CharSource asCharSource(Charset charset) {
	checkNotNull(charset);
	return CharSource.empty();
	}

	@Override
	public byte[] read() {
	return bytes; // length is 0, no need to clone
	}

	@Override
	public String toString() {
	return "ByteSource.empty()";
	}
	}

	private static final class ConcatenatedByteSource extends ByteSource {

	private final Iterable<? extends ByteSource> sources;

	ConcatenatedByteSource(Iterable<? extends ByteSource> sources) {
	this.sources = checkNotNull(sources);
	}

	@Override
	public InputStream openStream() throws IOException {
	return new MultiInputStream(sources.iterator());
	}

	@Override
	public boolean isEmpty() throws IOException {
	for (ByteSource source : sources) {
	if (!source.isEmpty()) {
	return false;
	}
	}
	return true;
	}

	@Override
	public long size() throws IOException {
	long result = 0L;
	for (ByteSource source : sources) {
	result += source.size();
	}
	return result;
	}

	@Override
	public String toString() {
	return "ByteSource.concat(" + sources + ")";
	}
	}
	}