Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Copyright (c) 2008, Nathan Sweet
   * All rights reserved.
   * 
   * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
   * conditions are met:
   * 
   * - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
   * - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
   * disclaimer in the documentation and/or other materials provided with the distribution.
  * - Neither the name of Esoteric Software nor the names of its contributors may be used to endorse or promote products derived
  * from this software without specific prior written permission.
  * 
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  * SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
 
 package com.esotericsoftware.kryo.io;
 
 
An InputStream that reads data from a byte array and optionally fills the byte array from another InputStream as needed. Utility methods are provided for efficiently reading primitive types and strings.

The byte[] buffer may be modified and then returned to its original state during some read operations, so the same byte[] should not be used concurrently in separate threads.

Author(s):
Nathan Sweet <misc@n4te.com>
 
 public class Input extends InputStream {
 	protected byte[] buffer;
 	protected int position;
 	protected int capacity;
 	protected int limit;
 	protected long total;
 	protected char[] chars = new char[32];
 	protected InputStream inputStream;

Creates an uninitialized Input. setBuffer(byte[]) must be called before the Input is used.
 
 	public Input () {
 	}

Creates a new Input for reading from a byte array.

Parameters:
bufferSize The size of the buffer. An exception is thrown if more bytes than this are read.
 
 	public Input (int bufferSize) {
 		this. = bufferSize;
 		 = new byte[bufferSize];
 	}

Creates a new Input for reading from a byte array.

Parameters:
buffer An exception is thrown if more bytes than this are read.
 
 	public Input (byte[] buffer) {
 		setBuffer(buffer, 0, buffer.length);
 	}

Creates a new Input for reading from a byte array.

Parameters:
buffer An exception is thrown if more bytes than this are read.
 
 	public Input (byte[] bufferint offsetint count) {
 		setBuffer(bufferoffsetcount);
 	}

Creates a new Input for reading from an InputStream with a buffer size of 4096.
 
 	public Input (InputStream inputStream) {
 		this(4096);
 		if (inputStream == nullthrow new IllegalArgumentException("inputStream cannot be null.");
 		this. = inputStream;
 	}

Creates a new Input for reading from an InputStream.
 
 	public Input (InputStream inputStreamint bufferSize) {
 		this(bufferSize);
 		if (inputStream == nullthrow new IllegalArgumentException("inputStream cannot be null.");
 		this. = inputStream;
 	}

Sets a new buffer. The position and total are reset, discarding any buffered bytes.
 
 	public void setBuffer (byte[] bytes) {
 		setBuffer(bytes, 0, bytes.length);
 	}

Sets a new buffer. The position and total are reset, discarding any buffered bytes.
 
 	public void setBuffer (byte[] bytesint offsetint count) {
 		if (bytes == nullthrow new IllegalArgumentException("bytes cannot be null.");
 		 = bytes;
 		 = offset;
 		 = offset + count;
 		 = bytes.length;
 		 = 0;
 		 = null;
 	}
 
 	public byte[] getBuffer () {
 		return ;
 	}
 
 	public InputStream getInputStream () {
		return ;
	}

Sets a new InputStream. The position and total are reset, discarding any buffered bytes.

Parameters:
inputStream May be null.
	public void setInputStream (InputStream inputStream) {
		this. = inputStream;
		 = 0;
	}

Returns the number of bytes read.
	public long total () {
		return  + ;
	}

Sets the number of bytes read.
	public void setTotal (long total) {
		this. = total;
	}

Returns the current position in the buffer.
	public int position () {
		return ;
	}

Sets the current position in the buffer.
	public void setPosition (int position) {
		this. = position;
	}

Returns the limit for the buffer.
	public int limit () {
		return ;
	}

Sets the limit in the buffer.
	public void setLimit (int limit) {
		this. = limit;
	}

Sets the position and total to zero.
	public void rewind () {
		 = 0;
		 = 0;
	}

Discards the specified number of bytes.
	public void skip (int countthrows KryoException {
		int skipCount = Math.min( - count);
		while (true) {
			 += skipCount;
			count -= skipCount;
			if (count == 0) break;
			skipCount = Math.min(count);
			require(skipCount);
		}
	}

Fills the buffer with more bytes. Can be overridden to fill the bytes from a source other than the InputStream.

Returns:
-1 if there are no more bytes.
	protected int fill (byte[] bufferint offsetint countthrows KryoException {
		if ( == nullreturn -1;
		try {
			return .read(bufferoffsetcount);
catch (IOException ex) {
			throw new KryoException(ex);
		}
	}

Parameters:
required Must be > 0. The buffer is filled until it has at least this many bytes.
Returns:
the number of bytes remaining.
Throws:
com.esotericsoftware.kryo.KryoException if EOS is reached before required bytes are read (buffer underflow).
	protected int require (int requiredthrows KryoException {
		int remaining =  - ;
		if (remaining >= requiredreturn remaining;
		if (required > throw new KryoException("Buffer too small: capacity: " +  + ", required: " + required);
		int count;
		// Try to fill the buffer.
		if (remaining > 0) {
			count = fill( - );
			if (count == -1) throw new KryoException("Buffer underflow.");
			remaining += count;
			if (remaining >= required) {
				 += count;
				return remaining;
			}
		}
		// Was not enough, compact and try again.
		System.arraycopy(, 0, remaining);
		 = 0;
		while (true) {
			count = fill(remaining - remaining);
			if (count == -1) {
				if (remaining >= requiredbreak;
				throw new KryoException("Buffer underflow.");
			}
			remaining += count;
			if (remaining >= requiredbreak// Enough has been read.
		}
		 = remaining;
		return remaining;
	}

Parameters:
optional Try to fill the buffer with this many bytes.
Returns:
the number of bytes remaining, but not more than optional, or -1 if the EOS was reached and the buffer is empty.
	private int optional (int optionalthrows KryoException {
		int remaining =  - ;
		if (remaining >= optionalreturn optional;
		optional = Math.min(optional);
		int count;
		// Try to fill the buffer.
		count = fill( - );
		if (count == -1) return remaining == 0 ? -1 : Math.min(remainingoptional);
		remaining += count;
		if (remaining >= optional) {
			 += count;
			return optional;
		}
		// Was not enough, compact and try again.
		System.arraycopy(, 0, remaining);
		 = 0;
		while (true) {
			count = fill(remaining - remaining);
			if (count == -1) break;
			remaining += count;
			if (remaining >= optionalbreak// Enough has been read.
		}
		 = remaining;
		return remaining == 0 ? -1 : Math.min(remainingoptional);
	}
	public boolean eof () {
		return optional(1) <= 0;
	}
	// InputStream
	public int available () throws IOException {
		return  -  + ((null != ) ? .available() : 0);
	}

Reads a single byte as an int from 0 to 255, or -1 if there are no more bytes are available.
	public int read () throws KryoException {
		if (optional(1) <= 0) return -1;
		return [++] & 0xFF;
	}

Reads bytes.length bytes or less and writes them to the specified byte[], starting at 0, and returns the number of bytes read.
	public int read (byte[] bytesthrows KryoException {
		return read(bytes, 0, bytes.length);
	}

Reads count bytes or less and writes them to the specified byte[], starting at offset, and returns the number of bytes read or -1 if no more bytes are available.
	public int read (byte[] bytesint offsetint countthrows KryoException {
		if (bytes == nullthrow new IllegalArgumentException("bytes cannot be null.");
		int startingCount = count;
		int copyCount = Math.min( - count);
		while (true) {
			System.arraycopy(bytesoffsetcopyCount);
			 += copyCount;
			count -= copyCount;
			if (count == 0) break;
			offset += copyCount;
			copyCount = optional(count);
			if (copyCount == -1) {
				// End of data.
				if (startingCount == countreturn -1;
				break;
			}
			if ( == break;
		}
		return startingCount - count;
	}

Discards the specified number of bytes.
	public long skip (long countthrows KryoException {
		long remaining = count;
		while (remaining > 0) {
			int skip = (int)Math.min(.remaining);
			skip(skip);
			remaining -= skip;
		}
		return count;
	}

Closes the underlying InputStream, if any.
	public void close () throws KryoException {
		if ( != null) {
			try {
catch (IOException ignored) {
			}
		}
	}
	// byte
Reads a single byte.
	public byte readByte () throws KryoException {
		return [++];
	}

Reads a byte as an int from 0 to 255.
	public int readByteUnsigned () throws KryoException {
		return [++] & 0xFF;
	}

Reads the specified number of bytes into a new byte[].
	public byte[] readBytes (int lengththrows KryoException {
		byte[] bytes = new byte[length];
		readBytes(bytes, 0, length);
		return bytes;
	}

Reads bytes.length bytes and writes them to the specified byte[], starting at index 0.
	public void readBytes (byte[] bytesthrows KryoException {
		readBytes(bytes, 0, bytes.length);
	}

Reads count bytes and writes them to the specified byte[], starting at offset.
	public void readBytes (byte[] bytesint offsetint countthrows KryoException {
		if (bytes == nullthrow new IllegalArgumentException("bytes cannot be null.");
		int copyCount = Math.min( - count);
		while (true) {
			System.arraycopy(bytesoffsetcopyCount);
			 += copyCount;
			count -= copyCount;
			if (count == 0) break;
			offset += copyCount;
			copyCount = Math.min(count);
			require(copyCount);
		}
	}
	// int
Reads a 4 byte int.
	public int readInt () throws KryoException {
		byte[] buffer = this.;
		int position = this.;
		this. = position + 4;
		return (buffer[position] & 0xFF) << 24 //
			| (buffer[position + 1] & 0xFF) << 16 //
			| (buffer[position + 2] & 0xFF) << 8 //
buffer[position + 3] & 0xFF;
	}

Reads a 1-5 byte int. This stream may consider such a variable length encoding request as a hint. It is not guaranteed that a variable length encoding will be really used. The stream may decide to use native-sized integer representation for efficiency reasons.
	public int readInt (boolean optimizePositivethrows KryoException {
		return readVarInt(optimizePositive);
	}

Reads a 1-5 byte int. It is guaranteed that a varible length encoding will be used.
	public int readVarInt (boolean optimizePositivethrows KryoException {
		if (require(1) < 5) return readInt_slow(optimizePositive);
		int b = [++];
		int result = b & 0x7F;
		if ((b & 0x80) != 0) {
			byte[] buffer = this.;
			b = buffer[++];
			result |= (b & 0x7F) << 7;
			if ((b & 0x80) != 0) {
				b = buffer[++];
				result |= (b & 0x7F) << 14;
				if ((b & 0x80) != 0) {
					b = buffer[++];
					result |= (b & 0x7F) << 21;
					if ((b & 0x80) != 0) {
						b = buffer[++];
						result |= (b & 0x7F) << 28;
					}
				}
			}
		}
		return optimizePositive ? result : ((result >>> 1) ^ -(result & 1));
	}
	private int readInt_slow (boolean optimizePositive) {
		// The buffer is guaranteed to have at least 1 byte.
		int b = [++];
		int result = b & 0x7F;
		if ((b & 0x80) != 0) {
			byte[] buffer = this.;
			b = buffer[++];
			result |= (b & 0x7F) << 7;
			if ((b & 0x80) != 0) {
				b = buffer[++];
				result |= (b & 0x7F) << 14;
				if ((b & 0x80) != 0) {
					b = buffer[++];
					result |= (b & 0x7F) << 21;
					if ((b & 0x80) != 0) {
						b = buffer[++];
						result |= (b & 0x7F) << 28;
					}
				}
			}
		}
		return optimizePositive ? result : ((result >>> 1) ^ -(result & 1));
	}

Returns true if enough bytes are available to read an int with readInt(boolean).
	public boolean canReadInt () throws KryoException {
		if ( -  >= 5) return true;
		if (optional(5) <= 0) return false;
		int p = ;
		if (([p++] & 0x80) == 0) return true;
		if (p == return false;
		if (([p++] & 0x80) == 0) return true;
		if (p == return false;
		if (([p++] & 0x80) == 0) return true;
		if (p == return false;
		if (([p++] & 0x80) == 0) return true;
		if (p == return false;
		return true;
	}

Returns true if enough bytes are available to read a long with readLong(boolean).
	public boolean canReadLong () throws KryoException {
		if ( -  >= 9) return true;
		if (optional(5) <= 0) return false;
		int p = ;
		if (([p++] & 0x80) == 0) return true;
		if (p == return false;
		if (([p++] & 0x80) == 0) return true;
		if (p == return false;
		if (([p++] & 0x80) == 0) return true;
		if (p == return false;
		if (([p++] & 0x80) == 0) return true;
		if (p == return false;
		if (([p++] & 0x80) == 0) return true;
		if (p == return false;
		if (([p++] & 0x80) == 0) return true;
		if (p == return false;
		if (([p++] & 0x80) == 0) return true;
		if (p == return false;
		if (([p++] & 0x80) == 0) return true;
		if (p == return false;
		return true;
	}
	// string
Reads the length and string of UTF8 characters, or null. This can read strings written by Output.writeString(java.lang.String) , Output.writeString(java.lang.CharSequence), and Output.writeAscii(java.lang.String).

Returns:
May be null.
	public String readString () {
		int available = require(1);
		int b = [++];
		if ((b & 0x80) == 0) return readAscii(); // ASCII.
		// Null, empty, or UTF8.
		int charCount = available >= 5 ? readUtf8Length(b) : readUtf8Length_slow(b);
		switch (charCount) {
		case 0:
			return null;
		case 1:
			return "";
		}
		charCount--;
		if (. < charCount = new char[charCount];
		readUtf8(charCount);
		return new String(, 0, charCount);
	}
	private int readUtf8Length (int b) {
		int result = b & 0x3F; // Mask all but first 6 bits.
		if ((b & 0x40) != 0) { // Bit 7 means another byte, bit 8 means UTF8.
			byte[] buffer = this.;
			b = buffer[++];
			result |= (b & 0x7F) << 6;
			if ((b & 0x80) != 0) {
				b = buffer[++];
				result |= (b & 0x7F) << 13;
				if ((b & 0x80) != 0) {
					b = buffer[++];
					result |= (b & 0x7F) << 20;
					if ((b & 0x80) != 0) {
						b = buffer[++];
						result |= (b & 0x7F) << 27;
					}
				}
			}
		}
		return result;
	}
	private int readUtf8Length_slow (int b) {
		int result = b & 0x3F; // Mask all but first 6 bits.
		if ((b & 0x40) != 0) { // Bit 7 means another byte, bit 8 means UTF8.
			byte[] buffer = this.;
			b = buffer[++];
			result |= (b & 0x7F) << 6;
			if ((b & 0x80) != 0) {
				b = buffer[++];
				result |= (b & 0x7F) << 13;
				if ((b & 0x80) != 0) {
					b = buffer[++];
					result |= (b & 0x7F) << 20;
					if ((b & 0x80) != 0) {
						b = buffer[++];
						result |= (b & 0x7F) << 27;
					}
				}
			}
		}
		return result;
	}
	private void readUtf8 (int charCount) {
		byte[] buffer = this.;
		char[] chars = this.;
		// Try to read 7 bit ASCII chars.
		int charIndex = 0;
		int count = Math.min(require(1), charCount);
		int position = this.;
		int b;
		while (charIndex < count) {
			b = buffer[position++];
			if (b < 0) {
				position--;
				break;
			}
			chars[charIndex++] = (char)b;
		}
		this. = position;
		// If buffer didn't hold all chars or any were not ASCII, use slow path for remainder.
		if (charIndex < charCountreadUtf8_slow(charCountcharIndex);
	}
	private void readUtf8_slow (int charCountint charIndex) {
		char[] chars = this.;
		byte[] buffer = this.;
		while (charIndex < charCount) {
			if ( == require(1);
			int b = buffer[++] & 0xFF;
			switch (b >> 4) {
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
			case 6:
			case 7:
				chars[charIndex] = (char)b;
				break;
			case 12:
			case 13:
				if ( == require(1);
				chars[charIndex] = (char)((b & 0x1F) << 6 | buffer[++] & 0x3F);
				break;
			case 14:
				chars[charIndex] = (char)((b & 0x0F) << 12 | (buffer[++] & 0x3F) << 6 | buffer[++] & 0x3F);
				break;
			}
			charIndex++;
		}
	}
	private String readAscii () {
		byte[] buffer = this.;
		int end = ;
		int start = end - 1;
		int limit = this.;
		int b;
		do {
			if (end == limitreturn readAscii_slow();
			b = buffer[end++];
while ((b & 0x80) == 0);
		buffer[end - 1] &= 0x7F; // Mask end of ascii bit.
		String value = new String(buffer, 0, startend - start);
		buffer[end - 1] |= 0x80;
		 = end;
		return value;
	}
	private String readAscii_slow () {
		--; // Re-read the first byte.
		// Copy chars currently in buffer.
		int charCount =  - ;
		if (charCount > . = new char[charCount * 2];
		char[] chars = this.;
		byte[] buffer = this.;
		for (int i = ii = 0, n = i < ni++, ii++)
			chars[ii] = (char)buffer[i];
		// Copy additional chars one by one.
		while (true) {
			int b = buffer[++];
			if (charCount == chars.length) {
				char[] newChars = new char[charCount * 2];
				System.arraycopy(chars, 0, newChars, 0, charCount);
				chars = newChars;
				this. = newChars;
			}
			if ((b & 0x80) == 0x80) {
				chars[charCount++] = (char)(b & 0x7F);
				break;
			}
			chars[charCount++] = (char)b;
		}
		return new String(chars, 0, charCount);
	}

Reads the length and string of UTF8 characters, or null. This can read strings written by Output.writeString(java.lang.String) , Output.writeString(java.lang.CharSequence), and Output.writeAscii(java.lang.String).

Returns:
May be null.
		int available = require(1);
		int b = [++];
		if ((b & 0x80) == 0) return new StringBuilder(readAscii()); // ASCII.
		// Null, empty, or UTF8.
		int charCount = available >= 5 ? readUtf8Length(b) : readUtf8Length_slow(b);
		switch (charCount) {
		case 0:
			return null;
		case 1:
			return new StringBuilder("");
		}
		charCount--;
		if (. < charCount = new char[charCount];
		readUtf8(charCount);
		StringBuilder builder = new StringBuilder(charCount);
		builder.append(, 0, charCount);
		return builder;
	}
	// float
Reads a 4 byte float.
	public float readFloat () throws KryoException {
		return Float.intBitsToFloat(readInt());
	}

Reads a 1-5 byte float with reduced precision.
	public float readFloat (float precisionboolean optimizePositivethrows KryoException {
		return readInt(optimizePositive) / (float)precision;
	}
	// short
Reads a 2 byte short.
	public short readShort () throws KryoException {
		return (short)((([++] & 0xFF) << 8) | ([++] & 0xFF));
	}

Reads a 2 byte short as an int from 0 to 65535.
	public int readShortUnsigned () throws KryoException {
		return (([++] & 0xFF) << 8) | ([++] & 0xFF);
	}
	// long
Reads an 8 byte long.
	public long readLong () throws KryoException {
		byte[] buffer = this.;
		return (long)buffer[++] << 56 //
			| (long)(buffer[++] & 0xFF) << 48 //
			| (long)(buffer[++] & 0xFF) << 40 //
			| (long)(buffer[++] & 0xFF) << 32 //
			| (long)(buffer[++] & 0xFF) << 24 //
			| (buffer[++] & 0xFF) << 16 //
			| (buffer[++] & 0xFF) << 8 //
buffer[++] & 0xFF;
	}

Reads a 1-9 byte long. This stream may consider such a variable length encoding request as a hint. It is not guaranteed that a variable length encoding will be really used. The stream may decide to use native-sized integer representation for efficiency reasons.
	public long readLong (boolean optimizePositivethrows KryoException {
		return readVarLong(optimizePositive);
	}

Reads a 1-9 byte long. It is guaranteed that a varible length encoding will be used.
	public long readVarLong (boolean optimizePositivethrows KryoException {
		if (require(1) < 9) return readLong_slow(optimizePositive);
		int b = [++];
		long result = b & 0x7F;
		if ((b & 0x80) != 0) {
			byte[] buffer = this.;
			b = buffer[++];
			result |= (b & 0x7F) << 7;
			if ((b & 0x80) != 0) {
				b = buffer[++];
				result |= (b & 0x7F) << 14;
				if ((b & 0x80) != 0) {
					b = buffer[++];
					result |= (b & 0x7F) << 21;
					if ((b & 0x80) != 0) {
						b = buffer[++];
						result |= (long)(b & 0x7F) << 28;
						if ((b & 0x80) != 0) {
							b = buffer[++];
							result |= (long)(b & 0x7F) << 35;
							if ((b & 0x80) != 0) {
								b = buffer[++];
								result |= (long)(b & 0x7F) << 42;
								if ((b & 0x80) != 0) {
									b = buffer[++];
									result |= (long)(b & 0x7F) << 49;
									if ((b & 0x80) != 0) {
										b = buffer[++];
										result |= (long)b << 56;
									}
								}
							}
						}
					}
				}
			}
		}
		if (!optimizePositiveresult = (result >>> 1) ^ -(result & 1);
		return result;
	}
	private long readLong_slow (boolean optimizePositive) {
		// The buffer is guaranteed to have at least 1 byte.
		int b = [++];
		long result = b & 0x7F;
		if ((b & 0x80) != 0) {
			byte[] buffer = this.;
			b = buffer[++];
			result |= (b & 0x7F) << 7;
			if ((b & 0x80) != 0) {
				b = buffer[++];
				result |= (b & 0x7F) << 14;
				if ((b & 0x80) != 0) {
					b = buffer[++];
					result |= (b & 0x7F) << 21;
					if ((b & 0x80) != 0) {
						b = buffer[++];
						result |= (long)(b & 0x7F) << 28;
						if ((b & 0x80) != 0) {
							b = buffer[++];
							result |= (long)(b & 0x7F) << 35;
							if ((b & 0x80) != 0) {
								b = buffer[++];
								result |= (long)(b & 0x7F) << 42;
								if ((b & 0x80) != 0) {
									b = buffer[++];
									result |= (long)(b & 0x7F) << 49;
									if ((b & 0x80) != 0) {
										b = buffer[++];
										result |= (long)b << 56;
									}
								}
							}
						}
					}
				}
			}
		}
		if (!optimizePositiveresult = (result >>> 1) ^ -(result & 1);
		return result;
	}
	// boolean
Reads a 1 byte boolean.
	public boolean readBoolean () throws KryoException {
		return [++] == 1;
	}
	// char
Reads a 2 byte char.
	public char readChar () throws KryoException {
		return (char)((([++] & 0xFF) << 8) | ([++] & 0xFF));
	}
	// double
Reads an 8 bytes double.
	public double readDouble () throws KryoException {
		return Double.longBitsToDouble(readLong());
	}

Reads a 1-9 byte double with reduced precision.
	public double readDouble (double precisionboolean optimizePositivethrows KryoException {
		return readLong(optimizePositive) / (double)precision;
	}
	// Methods implementing bulk operations on arrays of primitive types
Bulk input of an int array.
	public int[] readInts (int lengthboolean optimizePositivethrows KryoException {
		int[] array = new int[length];
		for (int i = 0; i < lengthi++)
			array[i] = readInt(optimizePositive);
		return array;
	}

Bulk input of a long array.
	public long[] readLongs (int lengthboolean optimizePositivethrows KryoException {
		long[] array = new long[length];
		for (int i = 0; i < lengthi++)
			array[i] = readLong(optimizePositive);
		return array;
	}

Bulk input of an int array.
	public int[] readInts (int lengththrows KryoException {
		int[] array = new int[length];
		for (int i = 0; i < lengthi++)
			array[i] = readInt();
		return array;
	}

Bulk input of a long array.
	public long[] readLongs (int lengththrows KryoException {
		long[] array = new long[length];
		for (int i = 0; i < lengthi++)
			array[i] = readLong();
		return array;
	}

Bulk input of a float array.
	public float[] readFloats (int lengththrows KryoException {
		float[] array = new float[length];
		for (int i = 0; i < lengthi++)
			array[i] = readFloat();
		return array;
	}

Bulk input of a short array.
	public short[] readShorts (int lengththrows KryoException {
		short[] array = new short[length];
		for (int i = 0; i < lengthi++)
			array[i] = readShort();
		return array;
	}

Bulk input of a char array.
	public char[] readChars (int lengththrows KryoException {
		char[] array = new char[length];
		for (int i = 0; i < lengthi++)
			array[i] = readChar();
		return array;
	}

Bulk input of a double array.
	public double[] readDoubles (int lengththrows KryoException {
		double[] array = new double[length];
		for (int i = 0; i < lengthi++)
			array[i] = readDouble();
		return array;
	}
New to GrepCode? Check out our FAQ X