com.alachisoft.ncache.serialization.standard.io.ObjectInputStream Maven / Gradle / Ivy
Show all versions of nc-serialization Show documentation
/*
* @(#)ObjectInputStream.java 1.0
*
* Created on September 18, 2008, 12:59 PM
*
* Copyright 2008 NeXtreme Innovations, Inc. All rights reserved.
* "NeXtreme Innovations" PROPRIETARY/CONFIDENTIAL. Use is subject
* to license terms.
*/
package com.alachisoft.ncache.serialization.standard.io;
import com.alachisoft.ncache.serialization.core.io.BlockDataInputStream;
import com.alachisoft.ncache.serialization.core.io.NCacheObjectInput;
import com.alachisoft.ncache.serialization.core.io.SerializationContext;
import com.alachisoft.ncache.serialization.core.io.TypeSurrogateSelector;
import com.alachisoft.ncache.serialization.core.io.surrogates.SerializationSurrogate;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
/**
* ObjectInputStream class.
*
* @version 1.0, September 18, 2008
*/
public class ObjectInputStream
extends InputStream implements NCacheObjectInput {
public static byte[] buf;
/**
* working arrays initialized on demand by readUTF
*/
private BlockDataInputStream mInput;
private SerializationContext mContext;
private TypeSurrogateSelector mSelector;
private String _cacheContext;
/**
* Creates an ObjectInputStream that reads from the specified InputStream.
* A serialization stream header is read from the stream and verified.
*
* If a security manager is installed, this constructor will check for
* the "enableSubclassImplementation" SerializablePermission when invoked
* directly or indirectly by the constructor of a subclass which overrides
* the ObjectInputStream.readFields or ObjectInputStream.readUnshared
* methods.
*
* @param in input stream to read from
* @throws StreamCorruptedException if the stream header is incorrect
* @throws IOException if an I/O error occurs while reading stream header
* @throws SecurityException if untrusted subclass illegally overrides
* security-sensitive methods
* @throws NullPointerException if in is null
*/
public ObjectInputStream(InputStream in, String cacheContext) throws IOException {
this.mInput = new BlockDataInputStream(in);
this.mContext = new SerializationContext(TypeSurrogateSelectorImpl.getDefault());
this.mSelector = this.mContext.getSurrogateSelector();
this.mContext.putUserItem("__bin", this.mInput);
this._cacheContext = cacheContext;
}
/**
* Creates an ObjectInputStream that reads from the specified InputStream.
* A serialization stream header is read from the stream and verified.
* This constructor will block until the corresponding ObjectOutputStream
* has written and flushed the header.
*
*
If a security manager is installed, this constructor will check for
* the "enableSubclassImplementation" SerializablePermission when invoked
* directly or indirectly by the constructor of a subclass which overrides
* the ObjectInputStream.readFields or ObjectInputStream.readUnshared
* methods.
*
* @param in input stream to read from
* @param selector type surrogate selector to use
* @throws StreamCorruptedException if the stream header is incorrect
* @throws IOException if an I/O error occurs while reading stream header
* @throws SecurityException if untrusted subclass illegally overrides
* security-sensitive methods
* @throws NullPointerException if this.mInput is null
*/
public ObjectInputStream(InputStream in, TypeSurrogateSelector selector)
throws IOException {
this.mInput = new BlockDataInputStream(in);
this.mSelector = TypeSurrogateSelectorImpl.getDefault();
this.mContext = new SerializationContext(this.mSelector);
this.mContext.putUserItem("__bin", this.mInput);
}
/**
* Returns the current b. The number of bytes
* read is equal
* to the length of b.
*
* This method blocks until one of the
* following conditions occurs:
*
* b.length
* bytes of input data are available, this.mInput which
* case a normal return is made.
*
* - End of
* file is detected, this.mInput which case an
EOFException
* is thrown.
*
* - An I/O error occurs, this.mInput
* which case an
IOException other
* than EOFException is thrown.
*
*
* If b is null,
* a NullPointerException is thrown.
* If b.length is zero, then
* no bytes are read. Otherwise, the first
* byte read is stored into element b[0],
* the next one into b[1], and
* so on.
* If an exception is thrown from
* this method, then it may be that some but
* not all bytes of b have been
* updated with data from the input stream.
*
* @param b the buffer into which the data is read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
public final void readFully(byte b[]) throws IOException {
this.mInput.readFully(b);
}
/**
* Reads len
* bytes from
* an input stream.
*
* This method
* blocks until one of the following conditions
* occurs:
*
* len bytes
* of input data are available, this.mInput which case
* a normal return is made.
*
* - End of file
* is detected, this.mInput which case an
EOFException
* is thrown.
*
* - An I/O error occurs, this.mInput
* which case an
IOException other
* than EOFException is thrown.
*
*
* If b is null,
* a NullPointerException is thrown.
* If off is negative, or len
* is negative, or off+len is
* greater than the length of the array b,
* then an IndexOutOfBoundsException
* is thrown.
* If len is zero,
* then no bytes are read. Otherwise, the first
* byte read is stored into element b[off],
* the next one into b[off+1],
* and so on. The number of bytes read is,
* at most, equal to len.
*
* @param b the buffer into which the data is read.
* @param off an int specifying the offset into the data.
* @param len an int specifying the number of bytes to read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
public final void readFully(byte b[], int off, int len) throws IOException {
this.mInput.readFully(b, off, len);
}
/**
* Makes an attempt to skip over
* n bytes
* of data from the input
* stream, discarding the skipped bytes. However,
* it may skip
* over some smaller number of
* bytes, possibly zero. This may result from
* any of a
* number of conditions; reaching
* end of file before n bytes
* have been skipped is
* only one possibility.
* This method never throws an EOFException.
* The actual
* number of bytes skipped is returned.
*
* @param n the number of bytes to be skipped.
* @return the number of bytes actually skipped.
* @throws IOException if an I/O error occurs.
*/
public final int skipBytes(int n) throws IOException {
return this.mInput.skipBytes(n);
}
/**
* Reads one input byte and returns
* true if that byte is nonzero,
* false if that byte is zero.
* This method is suitable for reading
* the byte written by the writeBoolean
* method of interface DataOutput.
*
* @return the boolean value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
public final boolean readBoolean() throws IOException {
return this.mInput.readBoolean();
}
/**
* Reads and returns one input byte.
* The byte is treated as a signed value this.mInput
* the range -128 through 127,
* inclusive.
* This method is suitable for
* reading the byte written by the writeByte
* method of interface DataOutput.
*
* @return the 8-bit value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
public final byte readByte() throws IOException {
return this.mInput.readByte();
}
/**
* Reads one input byte, zero-extends
* it to type int, and returns
* the result, which is therefore this.mInput the range
* 0
* through 255.
* This method is suitable for reading
* the byte written by the writeByte
* method of interface DataOutput
* if the argument to writeByte
* was intended to be a value this.mInput the range
* 0 through 255.
*
* @return the unsigned 8-bit value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
public final int readUnsignedByte() throws IOException {
return this.mInput.readUnsignedByte();
}
/**
* Reads two input bytes and returns
* a short value. Let a
* be the first byte read and b
* be the second byte. The value
* returned
* is:
*
(short)((a << 8) | (b & 0xff))
*
* This method
* is suitable for reading the bytes written
* by the writeShort method of
* interface DataOutput.
*
* @return the 16-bit value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
public final short readShort() throws IOException {
return this.mInput.readShort();
}
/**
* Reads two input bytes and returns
* an int value this.mInput the range 0
* through 65535. Let a
* be the first byte read and
* b
* be the second byte. The value returned is:
* (((a & 0xff) << 8) | (b & 0xff))
*
* This method is suitable for reading the bytes
* written by the writeShort method
* of interface DataOutput if
* the argument to writeShort
* was intended to be a value this.mInput the range
* 0 through 65535.
*
* @return the unsigned 16-bit value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
public final int readUnsignedShort() throws IOException {
return this.mInput.readUnsignedShort();
}
/**
* Reads two input bytes and returns a char value.
* Let a
* be the first byte read and b
* be the second byte. The value
* returned is:
* (char)((a << 8) | (b & 0xff))
*
* This method
* is suitable for reading bytes written by
* the writeChar method of interface
* DataOutput.
*
* @return the char value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
public final char readChar() throws IOException {
return this.mInput.readUTF8Char();
}
/**
* Reads four input bytes and returns an
* int value. Let a-d
* be the first through fourth bytes read. The value returned is:
*
*
* (((a & 0xff) << 24) | ((b & 0xff) << 16) |
* ((c & 0xff) << 8) | (d & 0xff))
*
* This method is suitable
* for reading bytes written by the writeInt
* method of interface DataOutput.
*
* @return the int value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
public final int readInt() throws IOException {
return this.mInput.readInt();
}
/**
* Reads eight input bytes and returns
* a long value. Let a-h
* be the first through eighth bytes read.
* The value returned is:
*
* (((long)(a & 0xff) << 56) |
* ((long)(b & 0xff) << 48) |
* ((long)(c & 0xff) << 40) |
* ((long)(d & 0xff) << 32) |
* ((long)(e & 0xff) << 24) |
* ((long)(f & 0xff) << 16) |
* ((long)(g & 0xff) << 8) |
* ((long)(h & 0xff)))
*
*
* This method is suitable
* for reading bytes written by the writeLong
* method of interface DataOutput.
*
* @return the long value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
public final long readLong() throws IOException {
return this.mInput.readLong();
}
/**
* Reads four input bytes and returns
* a float value. It does this
* by first constructing an int
* value this.mInput exactly the manner
* of the readInt
* method, then converting this int
* value to a float this.mInput
* exactly the manner of the method Float.intBitsToFloat.
* This method is suitable for reading
* bytes written by the writeFloat
* method of interface DataOutput.
*
* @return the float value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
public final float readFloat() throws IOException {
return this.mInput.readFloat();
}
/**
* Reads eight input bytes and returns
* a double value. It does this
* by first constructing a long
* value this.mInput exactly the manner
* of the readlong
* method, then converting this long
* value to a double this.mInput exactly
* the manner of the method Double.longBitsToDouble.
* This method is suitable for reading
* bytes written by the writeDouble
* method of interface DataOutput.
*
* @return the double value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
public final double readDouble() throws IOException {
return this.mInput.readDouble();
}
/**
* Reads the next line of text from the input stream.
* It reads successive bytes, converting
* each byte separately into a character,
* until it encounters a line terminator or
* end of
* file; the characters read are then
* returned as a String. Note
* that because this
* method processes bytes,
* it does not support input of the full Unicode
* character set.
*
* If end of file is encountered
* before even one byte can be read, then null
* is returned. Otherwise, each byte that is
* read is converted to type char
* by zero-extension. If the character '\n'
* is encountered, it is discarded and reading
* ceases. If the character '\r'
* is encountered, it is discarded and, if
* the following byte converts to the
* character '\n', then that is
* discarded also; reading then ceases. If
* end of file is encountered before either
* of the characters '\n' and
* '\r' is encountered, reading
* ceases. Once reading has ceased, a String
* is returned that contains all the characters
* read and not discarded, taken this.mInput order.
* Note that every character this.mInput this string
* will have a value less than \u0100,
* that is, (char)256.
*
* @return the next line of text from the input stream,
* or null if the end of file is
* encountered before a byte can be read.
* @throws IOException if an I/O error occurs.
*/
public String readLine() throws IOException {
return this.mInput.readLine();
}
/**
* Reads this.mInput a string that has been encoded using a
* modified UTF-8
* format.
* The general contract of readUTF
* is that it reads a representation of a Unicode
* character string encoded this.mInput modified
* UTF-8 format; this string of characters
* is then returned as a String.
*
* First, two bytes are read and used to
* construct an unsigned 16-bit integer this.mInput
* exactly the manner of the readUnsignedShort
* method . This integer value is called the
* UTF length and specifies the number
* of additional bytes to be read. These bytes
* are then converted to characters by considering
* them this.mInput groups. The length of each group
* is computed from the value of the first
* byte of the group. The byte following a
* group, if any, is the first byte of the
* next group.
*
* If the first byte of a group
* matches the bit pattern 0xxxxxxx
* (where x means "may be 0
* or 1"), then the group consists
* of just that byte. The byte is zero-extended
* to form a character.
*
* If the first byte
* of a group matches the bit pattern 110xxxxx,
* then the group consists of that byte a
* and a second byte b. If there
* is no byte b (because byte
* a was the last of the bytes
* to be read), or if byte b does
* not match the bit pattern 10xxxxxx,
* then a UTFDataFormatException
* is thrown. Otherwise, the group is converted
* to the character:
*
(char)(((a& 0x1F) << 6) | (b & 0x3F))
*
* If the first byte of a group
* matches the bit pattern 1110xxxx,
* then the group consists of that byte a
* and two more bytes b and c.
* If there is no byte c (because
* byte a was one of the last
* two of the bytes to be read), or either
* byte b or byte c
* does not match the bit pattern 10xxxxxx,
* then a UTFDataFormatException
* is thrown. Otherwise, the group is converted
* to the character:
*
* (char)(((a & 0x0F) << 12) | ((b & 0x3F) << 6) | (c & 0x3F))
*
* If the first byte of a group matches the
* pattern 1111xxxx or the pattern
* 10xxxxxx, then a UTFDataFormatException
* is thrown.
*
* If end of file is encountered
* at any time during this entire process,
* then an EOFException is thrown.
*
* After every group has been converted to
* a character by this process, the characters
* are gathered, this.mInput the same order this.mInput which
* their corresponding groups were read from
* the input stream, to form a String,
* which is returned.
*
* The writeUTF
* method of interface DataOutput
* may be used to write data that is suitable
* for reading by this method.
*
* @return a Unicode string.
* @throws EOFException if this stream reaches the end
* before reading all the bytes.
* @throws IOException if an I/O error occurs.
* @throws UTFDataFormatException if the bytes do not represent a
* valid modified UTF-8 encoding of a string.
*/
public String readUTF() throws IOException {
return this.mInput.readUTF();
}
public int readUInt16() throws IOException {
return this.mInput.readUInt16();
}
public long readUInt32() throws IOException {
return this.mInput.readUInt32();
}
public BigInteger readUInt64() throws IOException {
return this.mInput.readUInt64();
}
/**
* Read and return an object. The class that implements this interface
* defines where the object is "read" from.
*
* @return the object read from the stream
* @throws java.lang.ClassNotFoundException If the class of a serialized
* object cannot be found.
* @throws IOException If any of the usual Input/Output
* related exceptions occur.
*/
public Object readObject()
throws ClassNotFoundException, IOException {
try {
// read type handle
short handle = this.readShort();
// Find an appropriate surrogate by handle
SerializationSurrogate surrogate =
this.mSelector.getSurrogateForTypeHandle(handle, _cacheContext);
if (surrogate == null)
surrogate = this.mSelector.GetSurrogateForSubTypeHandle(handle, this.readShort(), _cacheContext);
// if(surrogate instanceof ObjectArraySerializationSurrogate)
// surrogate
return surrogate.readObject(this);
} catch (Exception ex) {
throw new IOException(ex.toString());
}
}
/**
* Read and return an object. The class that implements this interface
* defines where the object is "read" from.
*
* @param objClass the class surrogate to use for reading the object.
* @return the object read from the stream
* @throws java.lang.ClassNotFoundException If the class of a serialized
* object cannot be found.
* @throws IOException If any of the usual Input/Output
* related exceptions occur.
*/
public Object readObjectAs(Class objClass)
throws ClassNotFoundException, IOException {
try {
// Find an appropriate surrogate by handle
SerializationSurrogate surrogate =
this.mSelector.getSurrogateForType(objClass, _cacheContext);
return surrogate.readObject(this);
} catch (Exception ex) {
throw new IOException(ex.toString());
}
}
/**
* Reads a byte of data. This method will block if no input is
* available.
*
* @return the byte read, or -1 if the end of the
* stream is reached.
* @throws IOException If an I/O error has occurred.
*/
public final int read() throws IOException {
return this.mInput.read();
}
/**
* Reads into an array of bytes. This method will
* block until some input is available.
*
* @param b the buffer into which the data is read
* @return the actual number of bytes read, -1 is
* returned when the end of the stream is reached.
* @throws IOException If an I/O error has occurred.
*/
@Override
public final int read(byte b[]) throws IOException {
return this.mInput.read(b);
}
/**
* Reads into an array of bytes. This method will
* block until some input is available.
*
* @param b the buffer into which the data is read
* @param off the start offset of the data
* @param len the maximum number of bytes read
* @return the actual number of bytes read, -1 is
* returned when the end of the stream is reached.
* @throws IOException If an I/O error has occurred.
*/
@Override
public final int read(byte b[], int off, int len) throws IOException {
return this.mInput.read(b, off, len);
}
/**
* Skips n bytes of input.
*
* @param n the number of bytes to be skipped
* @throws IOException If an I/O error has occurred.
* @return the actual number of bytes skipped.
*/
@Override
public final long skip(long n) throws IOException {
return this.mInput.skip(n);
}
/**
* Returns the number of bytes that can be read
* without blocking.
*
* @return the number of available bytes.
* @throws IOException If an I/O error has occurred.
*/
@Override
public final int available() throws IOException {
return this.mInput.available();
}
/**
* Closes the input stream. Must be called
* to release any resources associated with
* the stream.
*
* @throws IOException If an I/O error has occurred.
*/
@Override
public final void close() throws IOException {
this.mInput.close();
}
public String getCacheContext() {
return this._cacheContext;
}
public void skipObject() throws IOException {
try {
// read type handle
short handle = this.readShort();
// Find an appropriate surrogate by handle
SerializationSurrogate surrogate =
this.mSelector.getSurrogateForTypeHandle(handle, _cacheContext);
if (surrogate == null)
surrogate = this.mSelector.GetSurrogateForSubTypeHandle(handle, this.readShort(), _cacheContext);
// if(surrogate instanceof ObjectArraySerializationSurrogate)
// surrogate
surrogate.skipObject(this);
} catch (Exception ex) {
// ex.printStackTrace();
throw new IOException(ex.toString());
}
}
//
public void skipFully(byte[] b) throws IOException {
this.mInput.skipBytes(b.length);
}
public void skipFully(byte[] b, int off, int len) throws IOException {
this.mInput.readFully(b, off, len);
}
public void skipBoolean() throws IOException {
this.mInput.skipBytes(1);
}
public void skipByte() throws IOException {
this.mInput.skipBytes(1);
}
public void skipUnsignedByte() throws IOException {
this.mInput.skipBytes(1);
}
public void skipShort() throws IOException {
this.mInput.skipBytes(2);
}
public void skipUnsignedShort() throws IOException {
this.mInput.skipBytes(2);
}
public void skipChar() throws IOException {
this.mInput.skipBytes(1);
}
public void skipInt() throws IOException {
this.mInput.skipBytes(4);
}
public void skipLong() throws IOException {
this.mInput.skipBytes(8);
}
public void skipFloat() throws IOException {
this.mInput.skipBytes(4);
}
public void skipDouble() throws IOException {
this.mInput.skipBytes(8);
}
public void skipLine() throws IOException {
this.mInput.readLine();
}
public void skipUTF() throws IOException {
this.mInput.readUTF();
}
public void skipUInt16() throws IOException {
this.mInput.skipBytes(2);
}
public void skipUInt32() throws IOException {
this.mInput.skipBytes(4);
}
public void skipUInt64() throws IOException {
this.mInput.skipBytes(8);
}
public void skipUByte() throws IOException {
this.mInput.skipBytes(2);
}
//
public short readUByte() throws IOException {
return this.mInput.readUByte();
}
}