org.apache.geode.internal.NullDataOutputStream Maven / Gradle / Ivy
Show all versions of geode-core Show documentation
/*
* Licensed to the Apache Software Foundation (ASF) under one or more contributor license
* agreements. See the NOTICE file distributed with this work for additional information regarding
* copyright ownership. The ASF licenses this file to You 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 org.apache.geode.internal;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UTFDataFormatException;
import org.apache.geode.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
*
* @since GemFire 5.0.2
*
*/
public 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 void write(int b) {
this.size++;
}
/** override OutputStream's write() */
@Override
public void write(byte[] source, int offset, int len) {
this.size += len;
}
public int size() {
return this.size;
}
@Override
public void flush() {}
@Override
public void close() {}
// 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.
*/
@Override
public 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.
*/
@Override
public 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.
*/
@Override
public 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.
*/
@Override
public 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.
*/
@Override
public 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.
*/
@Override
public 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.
*/
@Override
public 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.
*/
@Override
public 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.
*/
@Override
public 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.
*/
@Override
public 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.
*/
@Override
public 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.
*/
@Override
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);
}
}
}