com.gemstone.gemfire.internal.NullDataOutputStream 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;
import java.io.*;
import com.gemstone.gemfire.DataSerializer;
/** NullDataOutputStream is an OutputStream that also implements DataOutput
* and does not store any data written to it.
* This makes it useful for calculating the size of a stream without
* consuming any memory.
* This class is not thread safe
*
* @author Darrel
* @since 5.0.2
*
*/
public final class NullDataOutputStream extends OutputStream implements
ObjToByteArraySerializer {
private int size;
public NullDataOutputStream() {
this.size = 0;
}
/** write the low-order 8 bits of the given int */
@Override
public final void write(int b) {
this.size++;
}
/** override OutputStream's write() */
@Override
public final void write(byte[] source, int offset, int len) {
this.size += len;
}
public final int size() {
return this.size;
}
@Override
public void flush() {
}
@Override
public void close() {
}
public void reset() {
this.size = 0;
}
// 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 {
this.size += 2;
}
/**
* 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 {
this.size += 2;
}
/**
* 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 {
this.size += 4;
}
/**
* 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 {
this.size += 8;
}
/**
* 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 {
this.size += 4;
}
/**
* 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 {
this.size += 8;
}
/**
* 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) {
this.size += strlen;
}
}
/**
* 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) {
this.size += len*2;
}
}
/**
* 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 {
int strlen = str.length();
if (strlen > 65535) {
throw new UTFDataFormatException();
}
int utfSize = 0;
for (int i = 0; i < strlen; i++) {
int c = str.charAt(i);
if ((c >= 0x0001) && (c <= 0x007F)) {
utfSize += 1;
} else if (c > 0x07FF) {
utfSize += 3;
} else {
utfSize += 2;
}
}
if (utfSize > 65535) {
throw new UTFDataFormatException();
}
this.size += utfSize + 2; // +2 for the short that the length is encoded in
}
/**
* 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 {
if (v instanceof HeapDataOutputStream) {
this.size += 4; // length is encoded as an int (or less)
this.size += ((HeapDataOutputStream)v).size();
} else {
this.size += 5; // length is encoded as a byte + an int
DataSerializer.writeObject(v, this);
}
}
}