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 OutputStream that buffers data in a byte array and optionally flushes to another OutputStream. Utility methods are provided for efficiently writing primitive types and strings.

Author(s):
Roman Levenstein <romixlev@gmail.com>
 
 public class ByteBufferOutput extends Output {
 	protected ByteBuffer niobuffer;
 
 	protected boolean varIntsEnabled = true;
 
 	// Default byte order is BIG_ENDIAN to be compatible to the base class
 
 	protected final static ByteOrder nativeOrder = ByteOrder.nativeOrder();

Creates an uninitialized Output. A buffer must be set before the Output is used.

 
 	public ByteBufferOutput () {
 	}

Creates a new Output for writing to a direct ByteBuffer.

Parameters:
bufferSize The initial and maximum size of the buffer. An exception is thrown if this size is exceeded.
 
 	public ByteBufferOutput (int bufferSize) {
 		this(bufferSizebufferSize);
 	}

Creates a new Output for writing to a direct ByteBuffer.

Parameters:
bufferSize The initial size of the buffer.
maxBufferSize The buffer is doubled as needed until it exceeds maxBufferSize and an exception is thrown.
 
 	public ByteBufferOutput (int bufferSizeint maxBufferSize) {
 		if (maxBufferSize < -1) throw new IllegalArgumentException("maxBufferSize cannot be < -1: " + maxBufferSize);
 		this. = bufferSize;
 		this. = maxBufferSize == -1 ? . : maxBufferSize;
 		 = ByteBuffer.allocateDirect(bufferSize);
 	}

Creates a new Output for writing to an OutputStream. A buffer size of 4096 is used.
 
 	public ByteBufferOutput (OutputStream outputStream) {
 		this(4096, 4096);
 		if (outputStream == nullthrow new IllegalArgumentException("outputStream cannot be null.");
 		this. = outputStream;
 	}

Creates a new Output for writing to an OutputStream.
 
 	public ByteBufferOutput (OutputStream outputStreamint bufferSize) {
 		this(bufferSizebufferSize);
 		if (outputStream == nullthrow new IllegalArgumentException("outputStream cannot be null.");
 		this. = outputStream;
 	}

Creates a new Output for writing to a ByteBuffer.
 
 	public ByteBufferOutput (ByteBuffer buffer) {
 		setBuffer(buffer);
 	}

Creates a new Output for writing to a ByteBuffer.

Parameters:
maxBufferSize The buffer is doubled as needed until it exceeds maxCapacity and an exception is thrown.
 
 	public ByteBufferOutput (ByteBuffer bufferint maxBufferSize) {
 		setBuffer(buffermaxBufferSize);
 	}

Creates a direct ByteBuffer of a given size at a given address.

Typical usage could look like this snippet:

 // Explicitly allocate memory
 long bufAddress = UnsafeUtil.unsafe().allocateMemory(4096);
 // Create a ByteBufferOutput using the allocated memory region
 ByteBufferOutput buffer = new ByteBufferOutput(bufAddress, 4096);
 
 // Do some operations on this buffer here
 
 // Say that ByteBuffer won't be used anymore
 buffer.release();
 // Release the allocated region
 UnsafeUtil.unsafe().freeMemory(bufAddress);
 

Parameters:
address starting address of a memory region pre-allocated using Unsafe.allocateMemory()
maxBufferSize
	public ByteBufferOutput (long addressint maxBufferSize) {
		 = UnsafeUtil.getDirectBufferAt(addressmaxBufferSize);
		setBuffer(maxBufferSize);
	}

Release a direct buffer. setBuffer(java.nio.ByteBuffer,int) should be called before next write operations can be called. NOTE: If Cleaner is not accessible due to SecurityManager restrictions, reflection could be used to obtain the "clean" method and then invoke it.
	public void release () {
		 = null;
	}
	public ByteOrder order () {
		return ;
	}
	public void order (ByteOrder byteOrder) {
		this. = byteOrder;
	}
		return ;
	}

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

Parameters:
outputStream May be null.
	public void setOutputStream (OutputStream outputStream) {
		this. = outputStream;
		 = 0;
		 = 0;
	}

Sets the buffer that will be written to. maxCapacity is set to the specified buffer's capacity.

	public void setBuffer (ByteBuffer buffer) {
		setBuffer(bufferbuffer.capacity());
	}

Sets the buffer that will be written to. The byte order, position and capacity are set to match the specified buffer. The total is set to 0. The OutputStream is set to null.

Parameters:
maxBufferSize The buffer is doubled as needed until it exceeds maxCapacity and an exception is thrown.
	public void setBuffer (ByteBuffer bufferint maxBufferSize) {
		if (buffer == nullthrow new IllegalArgumentException("buffer cannot be null.");
		if (maxBufferSize < -1) throw new IllegalArgumentException("maxBufferSize cannot be < -1: " + maxBufferSize);
		this. = buffer;
		this. = maxBufferSize == -1 ? . : maxBufferSize;
		 = buffer.order();
		 = buffer.capacity();
		 = buffer.position();
		 = 0;
		 = null;
	}

Returns the buffer. The bytes between zero and Output.position() are the data that has been written.
	public ByteBuffer getByteBuffer () {
		return ;
	}

Returns a new byte array containing the bytes currently in the buffer between zero and Output.position().
	public byte[] toBytes () {
		byte[] newBuffer = new byte[];
		.get(newBuffer, 0, );
		return newBuffer;
	}

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

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

Returns:
true if the buffer has been resized.
	protected boolean require (int requiredthrows KryoException {
		if ( -  >= requiredreturn false;
		if (required > )
			throw new KryoException("Buffer overflow. Max capacity: " +  + ", required: " + required);
		while ( -  < required) {
				throw new KryoException("Buffer overflow. Available: " + ( - ) + ", required: " + required);
			// Grow buffer.
			if ( == 0)  = 1;
			 = Math.min( * 2, );
			if ( < 0)  = ;
			ByteBuffer newBuffer = ( != null && !.isDirect()) ? ByteBuffer.allocate() : ByteBuffer
			// Copy the whole buffer
			newBuffer.put();
			newBuffer.order(.order());
			 = newBuffer;
		}
		return true;
	}
	// OutputStream
Writes the buffered bytes to the underlying OutputStream, if any.
	public void flush () throws KryoException {
		if ( == nullreturn;
		try {
			byte[] tmp = new byte[];
catch (IOException ex) {
			throw new KryoException(ex);
		}
		 = 0;
	}

Flushes any buffered bytes and closes the underlying OutputStream, if any.
	public void close () throws KryoException {
		if ( != null) {
			try {
catch (IOException ignored) {
			}
		}
	}

Writes a byte.
	public void write (int valuethrows KryoException {
		if ( == require(1);
		.put((byte)value);
	}

Writes the bytes. Note the byte[] length is not written.
	public void write (byte[] bytesthrows KryoException {
		if (bytes == nullthrow new IllegalArgumentException("bytes cannot be null.");
		writeBytes(bytes, 0, bytes.length);
	}

Writes the bytes. Note the byte[] length is not written.
	public void write (byte[] bytesint offsetint lengththrows KryoException {
		writeBytes(bytesoffsetlength);
	}
	// byte
	public void writeByte (byte valuethrows KryoException {
		if ( == require(1);
		.put(value);
	}
	public void writeByte (int valuethrows KryoException {
		if ( == require(1);
		.put((byte)value);
	}

Writes the bytes. Note the byte[] length is not written.
	public void writeBytes (byte[] bytesthrows KryoException {
		if (bytes == nullthrow new IllegalArgumentException("bytes cannot be null.");
		writeBytes(bytes, 0, bytes.length);
	}

Writes the bytes. Note the byte[] length is not written.
	public void writeBytes (byte[] bytesint offsetint countthrows KryoException {
		if (bytes == nullthrow new IllegalArgumentException("bytes cannot be null.");
		int copyCount = Math.min( - count);
		while (true) {
			.put(bytesoffsetcopyCount);
			 += copyCount;
			count -= copyCount;
			if (count == 0) return;
			offset += copyCount;
			copyCount = Math.min(count);
			require(copyCount);
		}
	}
	// int
Writes a 4 byte int.
	public void writeInt (int valuethrows KryoException {
		 += 4;
	}
	public int writeInt (int valueboolean optimizePositivethrows KryoException {
			writeInt(value);
			return 4;
else
			return writeVarInt(valueoptimizePositive);
	}
	public int writeVarInt (int valboolean optimizePositivethrows KryoException {
		int value = val;
		if (!optimizePositivevalue = (value << 1) ^ (value >> 31);
		int varInt = 0;
		varInt = (value & 0x7F);
		value >>>= 7;
		if (value == 0) {
			writeByte(varInt);
			return 1;
		}
		varInt |= 0x80;
		varInt |= ((value & 0x7F) << 8);
		value >>>= 7;
		if (value == 0) {
			writeInt(varInt);
			 -= 2;
			return 2;
		}
		varInt |= (0x80 << 8);
		varInt |= ((value & 0x7F) << 16);
		value >>>= 7;
		if (value == 0) {
			writeInt(varInt);
			 -= 1;
			return 3;
		}
		varInt |= (0x80 << 16);
		varInt |= ((value & 0x7F) << 24);
		value >>>= 7;
		if (value == 0) {
			writeInt(varInt);
			 -= 0;
			return 4;
		}
		varInt |= (0x80 << 24);
		long varLong = (varInt & 0xFFFFFFFFL) | (((long)value) << 32);
		writeLong(varLong);
		 -= 3;
		return 5;
	}
	// string
Writes the length and string, or null. Short strings are checked and if ASCII they are written more efficiently, else they are written as UTF8. If a string is known to be ASCII, writeAscii(java.lang.String) may be used. The string can be read using Input.readString() or Input.readStringBuilder().

Parameters:
value May be null.
	public void writeString (String valuethrows KryoException {
		if (value == null) {
			writeByte(0x80); // 0 means null, bit 8 means UTF8.
			return;
		}
		int charCount = value.length();
		if (charCount == 0) {
			writeByte(1 | 0x80); // 1 means empty string, bit 8 means UTF8.
			return;
		}
		// Detect ASCII.
		boolean ascii = false;
		if (charCount > 1 && charCount < 64) {
			ascii = true;
			for (int i = 0; i < charCounti++) {
				int c = value.charAt(i);
				if (c > 127) {
					ascii = false;
					break;
				}
			}
		}
		if (ascii) {
			if ( -  < charCount)
				writeAscii_slow(valuecharCount);
			else {
				byte[] tmp = value.getBytes();
				.put(tmp, 0, tmp.length);
				 += charCount;
			}
			.put( - 1, (byte)(.get( - 1) | 0x80));
else {
			writeUtf8Length(charCount + 1);
			int charIndex = 0;
			if ( -  >= charCount) {
				// Try to write 8 bit chars.
				int position = this.;
				for (; charIndex < charCountcharIndex++) {
					int c = value.charAt(charIndex);
					if (c > 127) break;
					.put(position++, (byte)c);
				}
				this. = position;
			}
			if (charIndex < charCountwriteString_slow(valuecharCountcharIndex);
		}
	}

Writes the length and CharSequence as UTF8, or null. The string can be read using Input.readString() or Input.readStringBuilder().

Parameters:
value May be null.
	public void writeString (CharSequence valuethrows KryoException {
		if (value == null) {
			writeByte(0x80); // 0 means null, bit 8 means UTF8.
			return;
		}
		int charCount = value.length();
		if (charCount == 0) {
			writeByte(1 | 0x80); // 1 means empty string, bit 8 means UTF8.
			return;
		}
		writeUtf8Length(charCount + 1);
		int charIndex = 0;
		if ( -  >= charCount) {
			// Try to write 8 bit chars.
			int position = this.;
			for (; charIndex < charCountcharIndex++) {
				int c = value.charAt(charIndex);
				if (c > 127) break;
				.put(position++, (byte)c);
			}
			this. = position;
		}
		if (charIndex < charCountwriteString_slow(valuecharCountcharIndex);
	}

Writes a string that is known to contain only ASCII characters. Non-ASCII strings passed to this method will be corrupted. Each byte is a 7 bit character with the remaining byte denoting if another character is available. This is slightly more efficient than writeString(java.lang.String). The string can be read using Input.readString() or Input.readStringBuilder().

Parameters:
value May be null.
	public void writeAscii (String valuethrows KryoException {
		if (value == null) {
			writeByte(0x80); // 0 means null, bit 8 means UTF8.
			return;
		}
		int charCount = value.length();
		if (charCount == 0) {
			writeByte(1 | 0x80); // 1 means empty string, bit 8 means UTF8.
			return;
		}
		if ( -  < charCount)
			writeAscii_slow(valuecharCount);
		else {
			byte[] tmp = value.getBytes();
			.put(tmp, 0, tmp.length);
			 += charCount;
		}
		.put( - 1, (byte)(.get( - 1) | 0x80)); // Bit 8 means end of ASCII.
	}

Writes the length of a string, which is a variable length encoded int except the first byte uses bit 8 to denote UTF8 and bit 7 to denote if another byte is present.
	private void writeUtf8Length (int value) {
		if (value >>> 6 == 0) {
			.put((byte)(value | 0x80)); // Set bit 8.
			 += 1;
else if (value >>> 13 == 0) {
			.put((byte)(value | 0x40 | 0x80)); // Set bit 7 and 8.
			.put((byte)(value >>> 6));
			 += 2;
else if (value >>> 20 == 0) {
			.put((byte)(value | 0x40 | 0x80)); // Set bit 7 and 8.
			.put((byte)((value >>> 6) | 0x80)); // Set bit 8.
			.put((byte)(value >>> 13));
			 += 3;
else if (value >>> 27 == 0) {
			.put((byte)(value | 0x40 | 0x80)); // Set bit 7 and 8.
			.put((byte)((value >>> 6) | 0x80)); // Set bit 8.
			.put((byte)((value >>> 13) | 0x80)); // Set bit 8.
			.put((byte)(value >>> 20));
			 += 4;
else {
			.put((byte)(value | 0x40 | 0x80)); // Set bit 7 and 8.
			.put((byte)((value >>> 6) | 0x80)); // Set bit 8.
			.put((byte)((value >>> 13) | 0x80)); // Set bit 8.
			.put((byte)((value >>> 20) | 0x80)); // Set bit 8.
			.put((byte)(value >>> 27));
			 += 5;
		}
	}
	private void writeString_slow (CharSequence valueint charCountint charIndex) {
		for (; charIndex < charCountcharIndex++) {
			if ( == require(Math.min(charCount - charIndex));
			int c = value.charAt(charIndex);
			if (c <= 0x007F) {
				.put(++, (byte)c);
else if (c > 0x07FF) {
				.put(++, (byte)(0xE0 | c >> 12 & 0x0F));
				.put(++, (byte)(0x80 | c >> 6 & 0x3F));
				.put(++, (byte)(0x80 | c & 0x3F));
else {
				.put(++, (byte)(0xC0 | c >> 6 & 0x1F));
				.put(++, (byte)(0x80 | c & 0x3F));
			}
		}
	}
	private void writeAscii_slow (String valueint charCountthrows KryoException {
		ByteBuffer buffer = this.;
		int charIndex = 0;
		int charsToWrite = Math.min(charCount - );
		while (charIndex < charCount) {
			byte[] tmp = new byte[charCount];
			value.getBytes(charIndexcharIndex + charsToWritetmp, 0);
			buffer.put(tmp, 0, charsToWrite);
// value.getBytes(charIndex, charIndex + charsToWrite, buffer, position);
			charIndex += charsToWrite;
			 += charsToWrite;
			charsToWrite = Math.min(charCount - charIndex);
			if (require(charsToWrite)) buffer = this.;
		}
	}
	// float
Writes a 4 byte float.
	public void writeFloat (float valuethrows KryoException {
		 += 4;
	}

Writes a 1-5 byte float with reduced precision.

Parameters:
optimizePositive If true, small positive numbers will be more efficient (1 byte) and small negative numbers will be inefficient (5 bytes).
	public int writeFloat (float valuefloat precisionboolean optimizePositivethrows KryoException {
		return writeInt((int)(value * precision), optimizePositive);
	}
	// short
Writes a 2 byte short.
	public void writeShort (int valuethrows KryoException {
		.putShort((short)value);
		 += 2;
	}
	// long
Writes an 8 byte long.
	public void writeLong (long valuethrows KryoException {
		 += 8;
	}
	public int writeLong (long valueboolean optimizePositivethrows KryoException {
			writeLong(value);
			return 8;
else
			return writeVarLong(valueoptimizePositive);
	}
	public int writeVarLong (long valueboolean optimizePositivethrows KryoException {
		if (!optimizePositivevalue = (value << 1) ^ (value >> 63);
		int varInt = 0;
		varInt = (int)(value & 0x7F);
		value >>>= 7;
		if (value == 0) {
			writeByte(varInt);
			return 1;
		}
		varInt |= 0x80;
		varInt |= ((value & 0x7F) << 8);
		value >>>= 7;
		if (value == 0) {
			writeInt(varInt);
			 -= 2;
			return 2;
		}
		varInt |= (0x80 << 8);
		varInt |= ((value & 0x7F) << 16);
		value >>>= 7;
		if (value == 0) {
			writeInt(varInt);
			 -= 1;
			return 3;
		}
		varInt |= (0x80 << 16);
		varInt |= ((value & 0x7F) << 24);
		value >>>= 7;
		if (value == 0) {
			writeInt(varInt);
			 -= 0;
			return 4;
		}
		varInt |= (0x80 << 24);
		long varLong = (varInt & 0xFFFFFFFFL);
		varLong |= (((long)(value & 0x7F)) << 32);
		value >>>= 7;
		if (value == 0) {
			writeLong(varLong);
			 -= 3;
			return 5;
		}
		varLong |= (0x80L << 32);
		varLong |= (((long)(value & 0x7F)) << 40);
		value >>>= 7;
		if (value == 0) {
			writeLong(varLong);
			 -= 2;
			return 6;
		}
		varLong |= (0x80L << 40);
		varLong |= (((long)(value & 0x7F)) << 48);
		value >>>= 7;
		if (value == 0) {
			writeLong(varLong);
			 -= 1;
			return 7;
		}
		varLong |= (0x80L << 48);
		varLong |= (((long)(value & 0x7F)) << 56);
		value >>>= 7;
		if (value == 0) {
			writeLong(varLong);
			return 8;
		}
		varLong |= (0x80L << 56);
		writeLong(varLong);
		write((byte)(value));
		return 9;
	}

Writes a 1-9 byte long.

Parameters:
optimizePositive If true, small positive numbers will be more efficient (1 byte) and small negative numbers will be inefficient (9 bytes).
	public int writeLongS (long valueboolean optimizePositivethrows KryoException {
		if (!optimizePositivevalue = (value << 1) ^ (value >> 63);
		if (value >>> 7 == 0) {
			.put((byte)value);
			 += 1;
			return 1;
		}
		if (value >>> 14 == 0) {
			.put((byte)((value & 0x7F) | 0x80));
			.put((byte)(value >>> 7));
			 += 2;
			return 2;
		}
		if (value >>> 21 == 0) {
			.put((byte)((value & 0x7F) | 0x80));
			.put((byte)(value >>> 7 | 0x80));
			.put((byte)(value >>> 14));
			 += 3;
			return 3;
		}
		if (value >>> 28 == 0) {
			.put((byte)((value & 0x7F) | 0x80));
			.put((byte)(value >>> 7 | 0x80));
			.put((byte)(value >>> 14 | 0x80));
			.put((byte)(value >>> 21));
			 += 4;
			return 4;
		}
		if (value >>> 35 == 0) {
			.put((byte)((value & 0x7F) | 0x80));
			.put((byte)(value >>> 7 | 0x80));
			.put((byte)(value >>> 14 | 0x80));
			.put((byte)(value >>> 21 | 0x80));
			.put((byte)(value >>> 28));
			 += 5;
			return 5;
		}
		if (value >>> 42 == 0) {
			.put((byte)((value & 0x7F) | 0x80));
			.put((byte)(value >>> 7 | 0x80));
			.put((byte)(value >>> 14 | 0x80));
			.put((byte)(value >>> 21 | 0x80));
			.put((byte)(value >>> 28 | 0x80));
			.put((byte)(value >>> 35));
			 += 6;
			return 6;
		}
		if (value >>> 49 == 0) {
			.put((byte)((value & 0x7F) | 0x80));
			.put((byte)(value >>> 7 | 0x80));
			.put((byte)(value >>> 14 | 0x80));
			.put((byte)(value >>> 21 | 0x80));
			.put((byte)(value >>> 28 | 0x80));
			.put((byte)(value >>> 35 | 0x80));
			.put((byte)(value >>> 42));
			 += 7;
			return 7;
		}
		if (value >>> 56 == 0) {
			.put((byte)((value & 0x7F) | 0x80));
			.put((byte)(value >>> 7 | 0x80));
			.put((byte)(value >>> 14 | 0x80));
			.put((byte)(value >>> 21 | 0x80));
			.put((byte)(value >>> 28 | 0x80));
			.put((byte)(value >>> 35 | 0x80));
			.put((byte)(value >>> 42 | 0x80));
			.put((byte)(value >>> 49));
			 += 8;
			return 8;
		}
		.put((byte)((value & 0x7F) | 0x80));
		.put((byte)(value >>> 7 | 0x80));
		.put((byte)(value >>> 14 | 0x80));
		.put((byte)(value >>> 21 | 0x80));
		.put((byte)(value >>> 28 | 0x80));
		.put((byte)(value >>> 35 | 0x80));
		.put((byte)(value >>> 42 | 0x80));
		.put((byte)(value >>> 49 | 0x80));
		.put((byte)(value >>> 56));
		 += 9;
		return 9;
	}
	// boolean
Writes a 1 byte boolean.
	public void writeBoolean (boolean valuethrows KryoException {
		.put((byte)(value ? 1 : 0));
	}
	// char
Writes a 2 byte char.
	public void writeChar (char valuethrows KryoException {
		 += 2;
	}
	// double
Writes an 8 byte double.
	public void writeDouble (double valuethrows KryoException {
		 += 8;
	}

Writes a 1-9 byte double with reduced precision.

Parameters:
optimizePositive If true, small positive numbers will be more efficient (1 byte) and small negative numbers will be inefficient (9 bytes).
	public int writeDouble (double valuedouble precisionboolean optimizePositivethrows KryoException {
		return writeLong((long)(value * precision), optimizePositive);
	}
	// Methods implementing bulk operations on arrays of primitive types
Bulk output of an int array.
	public void writeInts (int[] objectthrows KryoException {
		if ( -  >= object.length * 4 && isNativeOrder()) {
			buf.put(object);
			 += object.length * 4;
else
			super.writeInts(object);
	}

Bulk output of an long array.
	public void writeLongs (long[] objectthrows KryoException {
		if ( -  >= object.length * 8 && isNativeOrder()) {
			buf.put(object);
			 += object.length * 8;
else
			super.writeLongs(object);
	}

Bulk output of a float array.
	public void writeFloats (float[] objectthrows KryoException {
		if ( -  >= object.length * 4 && isNativeOrder()) {
			buf.put(object);
			 += object.length * 4;
else
			super.writeFloats(object);
	}

Bulk output of a short array.
	public void writeShorts (short[] objectthrows KryoException {
		if ( -  >= object.length * 2 && isNativeOrder()) {
			buf.put(object);
			 += object.length * 2;
else
			super.writeShorts(object);
	}

Bulk output of a char array.
	public void writeChars (char[] objectthrows KryoException {
		if ( -  >= object.length * 2 && isNativeOrder()) {
			buf.put(object);
			 += object.length * 2;
else
			super.writeChars(object);
	}

Bulk output of a double array.
	public void writeDoubles (double[] objectthrows KryoException {
		if ( -  >= object.length * 8 && isNativeOrder()) {
			buf.put(object);
			 += object.length * 8;
else
			super.writeDoubles(object);
	}
	private boolean isNativeOrder () {
		return  == ;
	}

Return current setting for variable length encoding of integers

Returns:
current setting for variable length encoding of integers
	public boolean getVarIntsEnabled () {
	}

Controls if a variable length encoding for integer types should be used when serializers suggest it.

Parameters:
varIntsEnabled
	public void setVarIntsEnabled (boolean varIntsEnabled) {
		this. = varIntsEnabled;
	}
New to GrepCode? Check out our FAQ X