com.gemstone.gemfire.internal.tcp.MsgOutputStream Maven / Gradle / Ivy
Show all versions of gemfire-core Show documentation
/*
* Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
*
* 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. See accompanying
* LICENSE file.
*/
package com.gemstone.gemfire.internal.tcp;
import java.io.*;
import java.nio.*;
import com.gemstone.gemfire.DataSerializer;
import com.gemstone.gemfire.internal.*;
import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
/** MsgOutputStream is deprecated. MsgStreamer should be used instead.
* The one non-deprecated use is in Connection for the handshake.
@author Darrel
@since 3.0
*/
public class MsgOutputStream extends OutputStream implements ObjToByteArraySerializer {
final ByteBuffer buffer;
/**
* The caller of this constructor is responsible for managing
* the allocated instance.
*/
public MsgOutputStream(int allocSize) {
if (TCPConduit.useDirectBuffers) {
this.buffer = ByteBuffer.allocateDirect(allocSize);
} else {
this.buffer = ByteBuffer.allocate(allocSize);
}
this.buffer.position(Connection.MSG_HEADER_BYTES);
}
/** write the low-order 8 bits of the given int */
@Override
public final void write(int b) {
buffer.put((byte)b);
}
/** override OutputStream's write() */
@Override
public final void write(byte[] source, int offset, int len) {
this.buffer.put(source, offset, len);
}
private int size() {
return this.buffer.position() - Connection.MSG_HEADER_BYTES;
}
/** write the header after the message has been written to the
stream */
public final void setMessageHeader(int msgType, int processorType, short msgId) {
buffer.putInt(Connection.MSG_HEADER_SIZE_OFFSET, Connection.calcHdrSize(size()));
buffer.put(Connection.MSG_HEADER_TYPE_OFFSET, (byte)(msgType&0xff));
buffer.putShort(Connection.MSG_HEADER_ID_OFFSET, msgId);
}
public final void reset() {
this.buffer.clear();
this.buffer.position(Connection.MSG_HEADER_BYTES);
}
/** gets the content ByteBuffer, ready for reading. The stream should
not be written to past this point until it has been reset. */
public final ByteBuffer getContentBuffer() {
buffer.flip();
return buffer;
}
// DataOutput methods
/**
* Writes a boolean value to this output stream.
* If the argument v
* is true, the value (byte)1
* is written; if v is false,
* the value (byte)0 is written.
* The byte written by this method may
* be read by the readBoolean
* method of interface DataInput,
* which will then return a boolean
* equal to v.
*
* @param v the boolean to be written.
* @exception IOException if an I/O error occurs.
*/
public final void writeBoolean(boolean v) throws IOException {
write(v ? 1 : 0);
}
/**
* Writes to the output stream the eight low-
* order bits of the argument v.
* The 24 high-order bits of v
* are ignored. (This means that writeByte
* does exactly the same thing as write
* for an integer argument.) The byte written
* by this method may be read by the readByte
* method of interface DataInput,
* which will then return a byte
* equal to (byte)v.
*
* @param v the byte value to be written.
* @exception IOException if an I/O error occurs.
*/
public final void writeByte(int v) throws IOException {
write(v);
}
/**
* Writes two bytes to the output
* stream to represent the value of the argument.
* The byte values to be written, in the order
* shown, are:
*
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be
* read by the readShort method
* of interface DataInput , which
* will then return a short equal
* to (short)v.
*
* @param v the short value to be written.
* @exception IOException if an I/O error occurs.
*/
public final void writeShort(int v) throws IOException {
buffer.putShort((short)v);
}
/**
* Writes a char value, wich
* is comprised of two bytes, to the
* output stream.
* The byte values to be written, in the order
* shown, are:
*
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be
* read by the readChar method
* of interface DataInput , which
* will then return a char equal
* to (char)v.
*
* @param v the char value to be written.
* @exception IOException if an I/O error occurs.
*/
public final void writeChar(int v) throws IOException {
buffer.putChar((char)v);
}
/**
* Writes an int value, which is
* comprised of four bytes, to the output stream.
* The byte values to be written, in the order
* shown, are:
*
* (byte)(0xff & (v >> 24))
* (byte)(0xff & (v >> 16))
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read
* by the readInt method of interface
* DataInput , which will then
* return an int equal to v.
*
* @param v the int value to be written.
* @exception IOException if an I/O error occurs.
*/
public final void writeInt(int v) throws IOException {
buffer.putInt(v);
}
/**
* Writes a long value, which is
* comprised of eight bytes, to the output stream.
* The byte values to be written, in the order
* shown, are:
*
* (byte)(0xff & (v >> 56))
* (byte)(0xff & (v >> 48))
* (byte)(0xff & (v >> 40))
* (byte)(0xff & (v >> 32))
* (byte)(0xff & (v >> 24))
* (byte)(0xff & (v >> 16))
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be
* read by the readLong method
* of interface DataInput , which
* will then return a long equal
* to v.
*
* @param v the long value to be written.
* @exception IOException if an I/O error occurs.
*/
public final void writeLong(long v) throws IOException {
buffer.putLong(v);
}
/**
* Writes a float value,
* which is comprised of four bytes, to the output stream.
* It does this as if it first converts this
* float value to an int
* in exactly the manner of the Float.floatToIntBits
* method and then writes the int
* value in exactly the manner of the writeInt
* method. The bytes written by this method
* may be read by the readFloat
* method of interface DataInput,
* which will then return a float
* equal to v.
*
* @param v the float value to be written.
* @exception IOException if an I/O error occurs.
*/
public final void writeFloat(float v) throws IOException {
buffer.putFloat(v);
}
/**
* Writes a double value,
* which is comprised of eight bytes, to the output stream.
* It does this as if it first converts this
* double value to a long
* in exactly the manner of the Double.doubleToLongBits
* method and then writes the long
* value in exactly the manner of the writeLong
* method. The bytes written by this method
* may be read by the readDouble
* method of interface DataInput,
* which will then return a double
* equal to v.
*
* @param v the double value to be written.
* @exception IOException if an I/O error occurs.
*/
public final void writeDouble(double v) throws IOException {
buffer.putDouble(v);
}
/**
* Writes a string to the output stream.
* For every character in the string
* s, taken in order, one byte
* is written to the output stream. If
* s is null, a NullPointerException
* is thrown.
If s.length
* is zero, then no bytes are written. Otherwise,
* the character s[0] is written
* first, then s[1], and so on;
* the last character written is s[s.length-1].
* For each character, one byte is written,
* the low-order byte, in exactly the manner
* of the writeByte method . The
* high-order eight bits of each character
* in the string are ignored.
*
* @param str the string of bytes to be written.
* @exception IOException if an I/O error occurs.
*/
public final void writeBytes(String str) throws IOException {
int strlen = str.length();
if (strlen > 0) {
// I know this is a deprecated method but it is PERFECT for this impl.
if (this.buffer.hasArray()) {
// I know this is a deprecated method but it is PERFECT for this impl.
int pos = this.buffer.position();
str.getBytes(0, strlen, this.buffer.array(), this.buffer.arrayOffset() + pos);
this.buffer.position(pos+strlen);
} else {
byte[] bytes = new byte[strlen];
str.getBytes(0, strlen, bytes, 0);
this.buffer.put(bytes);
}
// for (int i = 0 ; i < len ; i++) {
// this.buffer.put((byte)s.charAt(i));
// }
}
}
/**
* Writes every character in the string s,
* to the output stream, in order,
* two bytes per character. If s
* is null, a NullPointerException
* is thrown. If s.length
* is zero, then no characters are written.
* Otherwise, the character s[0]
* is written first, then s[1],
* and so on; the last character written is
* s[s.length-1]. For each character,
* two bytes are actually written, high-order
* byte first, in exactly the manner of the
* writeChar method.
*
* @param s the string value to be written.
* @exception IOException if an I/O error occurs.
*/
public final void writeChars(String s) throws IOException {
int len = s.length();
if (len > 0) {
for (int i=0; i < len; i++) {
this.buffer.putChar(s.charAt(i));
}
}
}
/**
* Writes two bytes of length information
* to the output stream, followed
* by the Java modified UTF representation
* of every character in the string s.
* If s is null,
* a NullPointerException is thrown.
* Each character in the string s
* is converted to a group of one, two, or
* three bytes, depending on the value of the
* character.
* If a character c
* is in the range \u0001 through
* \u007f, it is represented
* by one byte:
*
(byte)c
* If a character c is \u0000
* or is in the range \u0080
* through \u07ff, then it is
* represented by two bytes, to be written
* in the order shown:
* (byte)(0xc0 | (0x1f & (c >> 6)))
* (byte)(0x80 | (0x3f & c))
*
If a character
* c is in the range \u0800
* through uffff, then it is
* represented by three bytes, to be written
* in the order shown:
* (byte)(0xe0 | (0x0f & (c >> 12)))
* (byte)(0x80 | (0x3f & (c >> 6)))
* (byte)(0x80 | (0x3f & c))
*
First,
* the total number of bytes needed to represent
* all the characters of s is
* calculated. If this number is larger than
* 65535, then a UTFDataFormatException
* is thrown. Otherwise, this length is written
* to the output stream in exactly the manner
* of the writeShort method;
* after this, the one-, two-, or three-byte
* representation of each character in the
* string s is written.
The
* bytes written by this method may be read
* by the readUTF method of interface
* DataInput , which will then
* return a String equal to s.
*
* @param str the string value to be written.
* @exception IOException if an I/O error occurs.
*/
public final void writeUTF(String str) throws IOException {
writeFullUTF(str);
}
private final void writeFullUTF(String str) throws IOException {
int strlen = str.length();
if (strlen > 65535) {
throw new UTFDataFormatException(LocalizedStrings.MsgOutputStream_STRING_TOO_LONG_FOR_JAVA_SERIALIZATION.toLocalizedString());
}
// make room for worst case space 3 bytes for each char and 2 for len
int utfSizeIdx = this.buffer.position();
// skip bytes reserved for length
this.buffer.position(utfSizeIdx+2);
for (int i = 0; i < strlen; i++) {
int c = str.charAt(i);
if ((c >= 0x0001) && (c <= 0x007F)) {
this.buffer.put((byte)c);
} else if (c > 0x07FF) {
this.buffer.put((byte) (0xE0 | ((c >> 12) & 0x0F)));
this.buffer.put((byte) (0x80 | ((c >> 6) & 0x3F)));
this.buffer.put((byte) (0x80 | ((c >> 0) & 0x3F)));
} else {
this.buffer.put((byte) (0xC0 | ((c >> 6) & 0x1F)));
this.buffer.put((byte) (0x80 | ((c >> 0) & 0x3F)));
}
}
int utflen = this.buffer.position() - (utfSizeIdx+2);
if (utflen > 65535) {
// act as if we wrote nothing to this buffer
this.buffer.position(utfSizeIdx);
throw new UTFDataFormatException(LocalizedStrings.MsgOutputStream_STRING_TOO_LONG_FOR_JAVA_SERIALIZATION.toLocalizedString());
}
this.buffer.putShort(utfSizeIdx, (short)utflen);
}
/**
* Writes the given object to this stream as a byte array.
* The byte array is produced by serializing v. The serialization
* is done by calling DataSerializer.writeObject.
*/
public void writeAsSerializedByteArray(Object v) throws IOException {
ByteBuffer sizeBuf = this.buffer;
int sizePos = sizeBuf.position();
sizeBuf.position(sizePos+5);
final int preArraySize = size();
DataSerializer.writeObject(v, this);
int arraySize = size() - preArraySize;
sizeBuf.put(sizePos, InternalDataSerializer.INT_ARRAY_LEN);
sizeBuf.putInt(sizePos+1, arraySize);
}
}