AfflictionNetworks/narya
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New object streaming code is born!

Browse Source 
git-svn-id: svn+ssh://src.earth.threerings.net/narya/trunk@1605 542714f4-19e9-0310-aa3c-eee0fc999fb1
This commit is contained in:
Michael Bayne
2002-07-23 05:42:34 +00:00
parent 2601ab2321
commit 2330afc3cd
11 changed files with 2203 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/java/com/threerings/io/ArrayMask.java
+73
View File
@@ -0,0 +1,73 @@
//
// $Id: ArrayMask.java,v 1.1 2002/07/23 05:42:34 mdb Exp $
package com.threerings.io;
import java.io.IOException;
/**
* Used to keep track of which entries in an array are null and which are
* not. <em>Note:</em> only arrays up to 262,144 elements in length can be
* handled by this class.
*/
public class ArrayMask
{
/**
* Creates an array mask suitable for unserializing.
*/
public ArrayMask ()
{
}
/**
* Creates an array mask for an array of the specified length.
*/
public ArrayMask (int length)
{
int mlength = length/8;
if (length % 8 != 0) {
mlength++;
}
_mask = new byte[mlength];
}
/**
* Sets the bit indicating that the specified array index is non-null.
*/
public void set (int index)
{
_mask[index/8] |= (1 << (index%8));
}
/**
* Returns true if the specified array index should be non-null.
*/
public boolean isSet (int index)
{
return (_mask[index/8] & (1 << (index%8))) != 0;
}
/**
* Writes this mask to the specified output stream.
*/
public void writeTo (ObjectOutputStream out)
throws IOException
{
out.writeShort(_mask.length);
out.write(_mask);
}
/**
* Reads this mask from the specified input stream.
*/
public void readFrom (ObjectInputStream in)
throws IOException
{
int length = in.readShort();
_mask = new byte[length];
in.read(_mask);
}
/** A byte array with bits for every entry in the source array. */
protected byte[] _mask;
}
src/java/com/threerings/io/BasicStreamers.java
+629
View File
@@ -0,0 +1,629 @@
//
// $Id: BasicStreamers.java,v 1.1 2002/07/23 05:42:34 mdb Exp $
package com.threerings.io;
import java.io.EOFException;
import java.io.IOException;
import java.util.HashMap;
/**
* Code to read and write basic object types (like arrays of primitives,
* {@link Integer} instances, {@link Double} instances, etc.).
*/
public class BasicStreamers
{
/** An array of types for all of the basic streamers. */
public static Class[] BSTREAMER_TYPES = {
Boolean.class,
Byte.class,
Short.class,
Character.class,
Integer.class,
Long.class,
Float.class,
Double.class,
String.class,
(new boolean[0]).getClass(),
(new byte[0]).getClass(),
(new short[0]).getClass(),
(new char[0]).getClass(),
(new int[0]).getClass(),
(new long[0]).getClass(),
(new float[0]).getClass(),
(new double[0]).getClass(),
(new Object[0]).getClass(),
};
/** An array of instances of all of the basic streamers. */
public static Streamer[] BSTREAMER_INSTANCES = {
new BooleanStreamer(),
new ByteStreamer(),
new ShortStreamer(),
new CharacterStreamer(),
new IntegerStreamer(),
new LongStreamer(),
new FloatStreamer(),
new DoubleStreamer(),
new StringStreamer(),
new BooleanArrayStreamer(),
new ByteArrayStreamer(),
new ShortArrayStreamer(),
new CharArrayStreamer(),
new IntArrayStreamer(),
new LongArrayStreamer(),
new FloatArrayStreamer(),
new DoubleArrayStreamer(),
new ObjectArrayStreamer(),
};
/** Streams {@link Boolean} instances. */
public static class BooleanStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new Boolean(in.readBoolean());
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
out.writeBoolean(((Boolean)object).booleanValue());
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
// nothing to do here
}
}
/** Streams {@link Byte} instances. */
public static class ByteStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new Byte(in.readByte());
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
out.writeByte(((Byte)object).byteValue());
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
// nothing to do here
}
}
/** Streams {@link Short} instances. */
public static class ShortStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new Short(in.readShort());
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
out.writeShort(((Short)object).shortValue());
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
// nothing to do here
}
}
/** Streams {@link Character} instances. */
public static class CharacterStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new Character(in.readChar());
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
out.writeChar(((Character)object).charValue());
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
// nothing to do here
}
}
/** Streams {@link Integer} instances. */
public static class IntegerStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new Integer(in.readInt());
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
out.writeInt(((Integer)object).intValue());
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
// nothing to do here
}
}
/** Streams {@link Long} instances. */
public static class LongStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new Long(in.readLong());
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
out.writeLong(((Long)object).longValue());
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
// nothing to do here
}
}
/** Streams {@link Float} instances. */
public static class FloatStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new Float(in.readFloat());
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
out.writeFloat(((Float)object).floatValue());
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
// nothing to do here
}
}
/** Streams {@link Double} instances. */
public static class DoubleStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new Double(in.readDouble());
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
out.writeDouble(((Double)object).doubleValue());
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
// nothing to do here
}
}
/** Streams {@link String} instances. */
public static class StringStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return in.readUTF();
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
out.writeUTF((String)object);
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
// nothing to do here
}
}
/** Streams arrays of booleans. */
public static class BooleanArrayStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new boolean[in.readInt()];
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
boolean[] value = (boolean[])object;
int ecount = value.length;
out.writeInt(ecount);
for (int ii = 0; ii < ecount; ii++) {
out.writeBoolean(value[ii]);
}
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
boolean[] value = (boolean[])object;
int ecount = value.length;
for (int ii = 0; ii < ecount; ii++) {
value[ii] = in.readBoolean();
}
}
}
/** Streams arrays of bytes. */
public static class ByteArrayStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new byte[in.readInt()];
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
byte[] value = (byte[])object;
int ecount = value.length;
out.writeInt(ecount);
out.write(value);
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
byte[] value = (byte[])object;
int remain = value.length, offset = 0, read;
while (remain > 0) {
if ((read = in.read(value, offset, remain)) > 0) {
remain -= read;
offset += read;
} else {
throw new EOFException();
}
}
}
}
/** Streams arrays of shorts. */
public static class ShortArrayStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new short[in.readInt()];
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
short[] value = (short[])object;
int ecount = value.length;
out.writeInt(ecount);
for (int ii = 0; ii < ecount; ii++) {
out.writeShort(value[ii]);
}
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
short[] value = (short[])object;
int ecount = value.length;
for (int ii = 0; ii < ecount; ii++) {
value[ii] = in.readShort();
}
}
}
/** Streams arrays of chars. */
public static class CharArrayStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new char[in.readInt()];
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
char[] value = (char[])object;
int ecount = value.length;
out.writeInt(ecount);
for (int ii = 0; ii < ecount; ii++) {
out.writeChar(value[ii]);
}
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
char[] value = (char[])object;
int ecount = value.length;
for (int ii = 0; ii < ecount; ii++) {
value[ii] = in.readChar();
}
}
}
/** Streams arrays of ints. */
public static class IntArrayStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new int[in.readInt()];
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
int[] value = (int[])object;
int ecount = value.length;
out.writeInt(ecount);
for (int ii = 0; ii < ecount; ii++) {
out.writeInt(value[ii]);
}
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
int[] value = (int[])object;
int ecount = value.length;
for (int ii = 0; ii < ecount; ii++) {
value[ii] = in.readInt();
}
}
}
/** Streams arrays of longs. */
public static class LongArrayStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new long[in.readInt()];
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
long[] value = (long[])object;
int ecount = value.length;
out.writeInt(ecount);
for (int ii = 0; ii < ecount; ii++) {
out.writeLong(value[ii]);
}
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
long[] value = (long[])object;
int ecount = value.length;
for (int ii = 0; ii < ecount; ii++) {
value[ii] = in.readLong();
}
}
}
/** Streams arrays of floats. */
public static class FloatArrayStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new float[in.readInt()];
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
float[] value = (float[])object;
int ecount = value.length;
out.writeInt(ecount);
for (int ii = 0; ii < ecount; ii++) {
out.writeFloat(value[ii]);
}
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
float[] value = (float[])object;
int ecount = value.length;
for (int ii = 0; ii < ecount; ii++) {
value[ii] = in.readFloat();
}
}
}
/** Streams arrays of doubles. */
public static class DoubleArrayStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new double[in.readInt()];
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
double[] value = (double[])object;
int ecount = value.length;
out.writeInt(ecount);
for (int ii = 0; ii < ecount; ii++) {
out.writeDouble(value[ii]);
}
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
double[] value = (double[])object;
int ecount = value.length;
for (int ii = 0; ii < ecount; ii++) {
value[ii] = in.readDouble();
}
}
}
/** Streams arrays of Object instances. */
public static class ObjectArrayStreamer extends Streamer
{
// documentation inherited
public Object createObject (ObjectInputStream in)
throws IOException
{
return new Object[in.readInt()];
}
// documentation inherited
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
Object[] value = (Object[])object;
int ecount = value.length;
out.writeInt(ecount);
for (int ii = 0; ii < ecount; ii++) {
out.writeObject(value[ii]);
}
}
// documentation inherited
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
Object[] value = (Object[])object;
int ecount = value.length;
for (int ii = 0; ii < ecount; ii++) {
value[ii] = in.readObject();
}
}
}
}
src/java/com/threerings/io/ClassMapping.java
+27
View File
@@ -0,0 +1,27 @@
//
// $Id: ClassMapping.java,v 1.1 2002/07/23 05:42:34 mdb Exp $
package com.threerings.io;
/**
* Used by the {@link ObjectOutputStream} and {@link ObjectInputStream} to
* map classes to codes during a session.
*/
class ClassMapping
{
public short code;
public Class sclass;
public Streamer streamer;
public ClassMapping (short code, Class sclass, Streamer streamer)
{
this.code = code;
this.sclass = sclass;
this.streamer = streamer;
}
public String toString ()
{
return "[code=" + code + ", class=" + sclass.getName() + "]";
}
}
src/java/com/threerings/io/FieldMarshaller.java
+244
View File
@@ -0,0 +1,244 @@
//
// $Id: FieldMarshaller.java,v 1.1 2002/07/23 05:42:34 mdb Exp $
package com.threerings.io;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.HashMap;
import com.threerings.presents.Log;
/**
* Used to read and write a single field of a {@link Streamable} instance.
*/
public abstract class FieldMarshaller
{
/**
* Reads the contents of the supplied field from the supplied stream
* and sets it in the supplied object.
*/
public abstract void readField (
Field field, Object target, ObjectInputStream in) throws Exception;
/**
* Writes the contents of the supplied field in the supplied object to
* the supplied stream.
*/
public abstract void writeField (
Field field, Object source, ObjectOutputStream out) throws Exception;
/**
* Returns a field marshaller appropriate for the supplied field or
* null if no marshaller exists for the type contained by the field in
* question.
*/
public static FieldMarshaller getFieldMarshaller (Field field)
{
if (_marshallers == null) {
createMarshallers();
}
// if we have an exact match, use that
Class ftype = field.getType();
FieldMarshaller fm = (FieldMarshaller)_marshallers.get(ftype);
// otherwise if the class is a streamable, use the streamable
// marshaller
if (fm == null && Streamer.isStreamable(ftype)) {
fm = (FieldMarshaller)_marshallers.get(Streamable.class);
}
return fm;
}
/**
* Used to marshall and unmarshall classes for which we have a basic
* {@link Streamer}.
*/
protected static class StreamerMarshaller extends FieldMarshaller
{
public StreamerMarshaller (Streamer streamer)
{
_streamer = streamer;
}
// documentation inherited
public void readField (
Field field, Object target, ObjectInputStream in)
throws Exception
{
if (in.readBoolean()) {
Object value = _streamer.createObject(in);
_streamer.readObject(value, in, true);
field.set(target, value);
} else {
field.set(target, null);
}
}
// documentation inherited
public void writeField (
Field field, Object source, ObjectOutputStream out)
throws Exception
{
Object value = field.get(source);
if (value == null) {
out.writeBoolean(false);
} else {
out.writeBoolean(true);
_streamer.writeObject(value, out, true);
}
}
/** The streamer we use to read and write our field. */
protected Streamer _streamer;
}
/**
* Creates instances of all known field marshaller types and populates
* the {@link _marshallers} table with them. This is called the first
* time a marshaller is requested.
*/
protected static void createMarshallers ()
{
// create our table
_marshallers = new HashMap();
// create a marshaller for streamable instances
_marshallers.put(Streamable.class, new FieldMarshaller() {
public void readField (
Field field, Object target, ObjectInputStream in)
throws Exception {
field.set(target, in.readObject());
}
public void writeField (
Field field, Object source, ObjectOutputStream out)
throws Exception {
out.writeObject(field.get(source));
}
});
// create marshallers for the primitive types
_marshallers.put(Boolean.TYPE, new FieldMarshaller() {
public void readField (
Field field, Object target, ObjectInputStream in)
throws Exception {
field.setBoolean(target, in.readBoolean());
}
public void writeField (
Field field, Object source, ObjectOutputStream out)
throws Exception {
out.writeBoolean(field.getBoolean(source));
}
});
_marshallers.put(Byte.TYPE, new FieldMarshaller() {
public void readField (
Field field, Object target, ObjectInputStream in)
throws Exception {
field.setByte(target, in.readByte());
}
public void writeField (
Field field, Object source, ObjectOutputStream out)
throws Exception {
out.writeByte(field.getByte(source));
}
});
_marshallers.put(Character.TYPE, new FieldMarshaller() {
public void readField (
Field field, Object target, ObjectInputStream in)
throws Exception {
field.setChar(target, in.readChar());
}
public void writeField (
Field field, Object source, ObjectOutputStream out)
throws Exception {
out.writeChar(field.getChar(source));
}
});
_marshallers.put(Short.TYPE, new FieldMarshaller() {
public void readField (
Field field, Object target, ObjectInputStream in)
throws Exception {
field.setShort(target, in.readShort());
}
public void writeField (
Field field, Object source, ObjectOutputStream out)
throws Exception {
out.writeShort(field.getShort(source));
}
});
_marshallers.put(Integer.TYPE, new FieldMarshaller() {
public void readField (
Field field, Object target, ObjectInputStream in)
throws Exception {
field.setInt(target, in.readInt());
}
public void writeField (
Field field, Object source, ObjectOutputStream out)
throws Exception {
out.writeInt(field.getInt(source));
}
});
_marshallers.put(Long.TYPE, new FieldMarshaller() {
public void readField (
Field field, Object target, ObjectInputStream in)
throws Exception {
field.setLong(target, in.readLong());
}
public void writeField (
Field field, Object source, ObjectOutputStream out)
throws Exception {
out.writeLong(field.getLong(source));
}
});
_marshallers.put(Float.TYPE, new FieldMarshaller() {
public void readField (
Field field, Object target, ObjectInputStream in)
throws Exception {
field.setFloat(target, in.readFloat());
}
public void writeField (
Field field, Object source, ObjectOutputStream out)
throws Exception {
out.writeFloat(field.getFloat(source));
}
});
_marshallers.put(Double.TYPE, new FieldMarshaller() {
public void readField (
Field field, Object target, ObjectInputStream in)
throws Exception {
field.setDouble(target, in.readDouble());
}
public void writeField (
Field field, Object source, ObjectOutputStream out)
throws Exception {
out.writeDouble(field.getDouble(source));
}
});
_marshallers.put(String.class, new FieldMarshaller() {
public void readField (
Field field, Object target, ObjectInputStream in)
throws Exception {
field.set(target, in.readUTF());
}
public void writeField (
Field field, Object source, ObjectOutputStream out)
throws Exception {
out.writeUTF((String)field.get(source));
}
});
// create field marshallers for all of the basic types
int bscount = BasicStreamers.BSTREAMER_TYPES.length;
for (int ii = 0; ii < bscount; ii++) {
_marshallers.put(BasicStreamers.BSTREAMER_TYPES[ii],
new StreamerMarshaller(
BasicStreamers.BSTREAMER_INSTANCES[ii]));
}
}
/** Contains a mapping from field type to field marshaller instance
* for that type. */
protected static HashMap _marshallers;
}
src/java/com/threerings/io/FramedInputStream.java
+261
View File
@@ -0,0 +1,261 @@
//
// $Id: FramedInputStream.java,v 1.1 2002/07/23 05:42:34 mdb Exp $
package com.threerings.io;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import com.samskivert.util.StringUtil;
import com.threerings.presents.Log;
/**
* The framed input stream reads input that was framed by a framing output
* stream. Framing in this case simply means writing the length of the
* frame followed by the data associated with the frame so that an entire
* frame can be loaded from the network layer before any higher layer
* attempts to process it. Additionally, any failure in decoding a frame
* won't result in the entire stream being skewed due to the remainder of
* the undecoded frame remaining in the input stream.
*
* <p>The framed input stream reads an entire frame worth of data into its
* internal buffer when <code>readFrame()</code> is called. It then
* behaves as if this is the only data available on the stream (meaning
* that when the data in the frame is exhausted, it will behave as if the
* end of the stream has been reached). The buffer can only contain a
* single frame at a time, so any data left over from a previous frame
* will disappear when <code>readFrame()</code> is called again.
*
* <p><em>Note:</em> The framing input stream does not synchronize reads
* from its internal buffer. It is intended to only be accessed from a
* single thread.
*
* <p>Implementation note: maybe this should derive from
* <code>FilterInputStream</code> and be tied to a single
* <code>InputStream</code> for its lifetime.
*/
public class FramedInputStream extends InputStream
{
public FramedInputStream ()
{
_header = new byte[HEADER_SIZE];
_buffer = new byte[INITIAL_BUFFER_SIZE];
}
/**
* Reads a frame from the provided input stream, or appends to a
* partially read frame. Appends the read data to the existing data
* available via the framed input stream's read methods. If the entire
* frame data is not yet available, <code>readFrame</code> will return
* false, otherwise true.
*
* <p> The code assumes that it will be able to read the entire frame
* header in a single read. The header is only four bytes and should
* always arrive at the beginning of a packet, so unless something is
* very funky with the networking layer, this should be a safe
* assumption.
*
* @return true if the entire frame has been read, false if the buffer
* contains only a partial frame.
*/
public boolean readFrame (InputStream source)
throws IOException
{
// if the buffer currently contains a complete frame, that means
// we're not halfway through reading a frame and that we can start
// anew.
if (_count == _length) {
// read in the frame length
int got = source.read(_header, 0, HEADER_SIZE);
if (got < 0) {
throw new EOFException();
} else if (got == 0) {
// TBD: don't log this for now, but look into it later
// Log.info("Woke up to read data, but there ain't none. Sigh.");
return false;
} else if (got < HEADER_SIZE) {
String errmsg = "FramedInputStream does not support " +
"partially reading the header. Needed " + HEADER_SIZE +
" bytes, got " + got + " bytes.";
throw new RuntimeException(errmsg);
}
// now that we've read our new frame length, we can clear out
// any prior data
_pos = 0;
_count = 0;
// decode the frame length
_length = (_header[0] & 0xFF) << 24;
_length += (_header[1] & 0xFF) << 16;
_length += (_header[2] & 0xFF) << 8;
_length += (_header[3] & 0xFF);
// if necessary, expand our buffer to accomodate the frame
if (_length > _buffer.length) {
// increase the buffer size in large increments
_buffer = new byte[Math.max(_buffer.length << 1, _length)];
}
}
// read the data into the buffer
int got = source.read(_buffer, _count, _length-_count);
if (got < 0) {
throw new EOFException();
}
_count += got;
// System.err.println("Read frame " + _count +
// " (want " + _length + " pos " + _pos + ")");
return (_count == _length);
}
/**
* Reads the next byte of data from this input stream. The value byte
* is returned as an <code>int</code> in the range <code>0</code> to
* <code>255</code>. If no byte is available because the end of the
* stream has been reached, the value <code>-1</code> is returned.
*
* <p>This <code>read</code> method cannot block.
*
* @return the next byte of data, or <code>-1</code> if the end of the
* stream has been reached.
*/
public int read ()
{
return (_pos < _count) ? (_buffer[_pos++] & 0xFF) : -1;
}
/**
* Reads up to <code>len</code> bytes of data into an array of bytes
* from this input stream. If <code>pos</code> equals
* <code>count</code>, then <code>-1</code> is returned to indicate
* end of file. Otherwise, the number <code>k</code> of bytes read is
* equal to the smaller of <code>len</code> and
* <code>count-pos</code>. If <code>k</code> is positive, then bytes
* <code>buf[pos]</code> through <code>buf[pos+k-1]</code> are copied
* into <code>b[off]</code> through <code>b[off+k-1]</code> in the
* manner performed by <code>System.arraycopy</code>. The value
* <code>k</code> is added into <code>pos</code> and <code>k</code> is
* returned.
*
* <p>This <code>read</code> method cannot block.
*
* @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 total number of bytes read into the buffer, or
* <code>-1</code> if there is no more data because the end of the
* stream has been reached.
*/
public int read (byte[] b, int off, int len)
{
// sanity check the arguments
if (b == null) {
throw new NullPointerException();
} else if ((off < 0) || (off > b.length) || (len < 0) ||
((off + len) > b.length) || ((off + len) < 0)) {
throw new IndexOutOfBoundsException();
}
// figure out how much data we'll return
if (_pos >= _count) {
// if they asked to read zero bytes and we have no bytes
// remaining; we're supposed to return 0 rather than EOF
return (len == 0) ? 0 : -1;
}
if (_pos + len > _count) {
len = _count - _pos;
}
if (len <= 0) {
return 0;
}
// copy and advance
System.arraycopy(_buffer, _pos, b, off, len);
_pos += len;
return len;
}
/**
* Skips <code>n</code> bytes of input from this input stream. Fewer
* bytes might be skipped if the end of the input stream is reached.
* The actual number <code>k</code> of bytes to be skipped is equal to
* the smaller of <code>n</code> and <code>count-pos</code>. The value
* <code>k</code> is added into <code>pos</code> and <code>k</code> is
* returned.
*
* @param n the number of bytes to be skipped.
*
* @return the actual number of bytes skipped.
*/
public long skip (long n)
{
if (_pos + n > _count) {
n = _count - _pos;
}
if (n <= 0) {
return 0;
}
_pos += n;
return n;
}
/**
* Returns the number of bytes that can be read from this input stream
* without blocking. The value returned is <code>count - pos</code>,
* which is the number of bytes remaining to be read from the input
* buffer.
*
* @return the number of bytes remaining to be read from the buffered
* frames.
*/
public int available ()
{
return _count - _pos;
}
/**
* Always returns false as framed input streams do not support
* marking.
*/
public boolean markSupported ()
{
return false;
}
/**
* Does nothing, as marking is not supported.
*/
public void mark (int readAheadLimit)
{
// not supported; do nothing
}
/**
* Resets the buffer to the beginning of the buffered frames.
*/
public void reset ()
{
_pos = 0;
}
protected byte[] _header;
protected int _length;
protected byte[] _buffer;
protected int _pos;
protected int _count;
/** The size of the frame header (a 32-bit integer). */
protected static final int HEADER_SIZE = 4;
/** The default initial size of the internal buffer. */
protected static final int INITIAL_BUFFER_SIZE = 32;
}
src/java/com/threerings/io/FramingOutputStream.java
+125
View File
@@ -0,0 +1,125 @@
//
// $Id: FramingOutputStream.java,v 1.1 2002/07/23 05:42:34 mdb Exp $
package com.threerings.io;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* The framing output stream accumulates output into a byte array just
* like the byte array output stream, but can then be instructed to send
* its contents down another output stream, prefixed by the length
* (written as an integer) of those contents. It does this efficiently so
* that data is copied as little as possible and so that the output stream
* to which the data is written need not be buffered because the framed
* output is written in a single call to <code>write()</code>.
*
* <p><em>Note:</em> The framing output stream does not synchronize writes
* to its internal buffer. It is intended to only be accessed from a
* single thread.
*
* <p>Implementation note: maybe this should derive from
* <code>FilterOutputStream</code> and be tied to a single
* <code>OutputStream</code> for its lifetime.
*/
public class FramingOutputStream extends OutputStream
{
public FramingOutputStream ()
{
_buffer = new byte[INITIAL_BUFFER_SIZE];
_count = 4; // leave room for the frame size at the beginning
}
/**
* Writes the specified byte to this framing output stream.
*
* @param b the byte to be written.
*/
public void write (int b)
{
// expand our buffer if necessary
int newcount = _count + 1;
if (newcount > _buffer.length) {
// increase the buffer size in large increments
byte[] newbuf = new byte[Math.max(_buffer.length << 1, newcount)];
System.arraycopy(_buffer, 0, newbuf, 0, _count);
_buffer = newbuf;
}
// copy and advance
_buffer[_count] = (byte)b;
_count = newcount;
}
/**
* Writes <code>len</code> bytes from the specified byte array
* starting at offset <code>off</code> to this framing output stream.
*
* @param b the data.
* @param off the start offset in the data.
* @param len the number of bytes to write.
*/
public void write (byte[] b, int off, int len)
{
// sanity check the arguments
if ((off < 0) || (off > b.length) || (len < 0) ||
((off + len) > b.length) || ((off + len) < 0)) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return;
}
// expand the buffer if necessary
int newcount = _count + len;
if (newcount > _buffer.length) {
// increase the buffer size in large increments
byte[] newbuf = new byte[Math.max(_buffer.length << 1, newcount)];
System.arraycopy(_buffer, 0, newbuf, 0, _count);
_buffer = newbuf;
}
// copy and advance
System.arraycopy(b, off, _buffer, _count, len);
_count = newcount;
}
/**
* Writes the contents of this framing output stream to the target
* output stream, prefixed by an integer with value equal to the
* number of bytes written folling that integer. It then resets the
* framing output stream to prepare for another framed message.
*/
public void writeFrameAndReset (OutputStream target)
throws IOException
{
// prefix the frame with the byte count in network byte order (the
// format used by DataOutputStream)
int count = _count - 4;
_buffer[0] = (byte)((count >>> 24) & 0xFF);
_buffer[1] = (byte)((count >>> 16) & 0xFF);
_buffer[2] = (byte)((count >>> 8) & 0xFF);
_buffer[3] = (byte)((count >>> 0) & 0xFF);
// write the data
target.write(_buffer, 0, _count);
// System.err.println("Wrote frame " + (_count-4));
// reset our internal buffer
reset();
}
public void reset ()
{
// leave room for the frame size at the beginning
_count = 4;
}
protected byte[] _buffer;
protected int _count;
/** The default initial size of the internal buffer. */
protected static final int INITIAL_BUFFER_SIZE = 32;
}
src/java/com/threerings/io/ObjectInputStream.java
+169
View File
@@ -0,0 +1,169 @@
//
// $Id: ObjectInputStream.java,v 1.1 2002/07/23 05:42:34 mdb Exp $
package com.threerings.io;
import java.io.InputStream;
import java.io.DataInputStream;
import java.io.IOException;
import com.samskivert.util.HashIntMap;
import com.threerings.presents.Log;
/**
* Used to read {@link Streamable} objects from an {@link InputStream}.
* Other common object types are supported as well (@see {@link
* ObjectOutputStream}).
*
* @see Streamable
*/
public class ObjectInputStream extends DataInputStream
{
/**
* Constructs an object input stream which will read its data from the
* supplied source stream.
*/
public ObjectInputStream (InputStream source)
{
super(source);
}
/**
* Reads a {@link Streamable} instance or one of the supported object
* types from the input stream.
*/
public Object readObject ()
throws IOException, ClassNotFoundException
{
ClassMapping cmap;
// create our classmap if necessary
if (_classmap == null) {
_classmap = new HashIntMap();
}
try {
// read in the class code for this instance
short code = readShort();
// a zero code indicates a null value
if (code == 0) {
return null;
// if the code is negative, that means that we've never
// seen it before and class metadata follows
} else if (code < 0) {
// first swap the code into positive-land
code *= -1;
// read in the class metadata, create a class mapping record
// for the class, and cache it
String cname = readUTF();
Class sclass = Class.forName(cname);
Streamer streamer = Streamer.getStreamer(sclass);
// sanity check
if (streamer == null) {
String errmsg = "Aiya! Unable to create streamer for " +
"newly seen class [code=" + code +
", class=" + cname + "]";
throw new RuntimeException(errmsg);
}
cmap = new ClassMapping(code, sclass, streamer);
_classmap.put(code, cmap);
} else {
cmap = (ClassMapping)_classmap.get(code);
// sanity check
if (cmap == null) {
String errmsg = "Aiya! Read object code for which we " +
"have no registered class metadata [code=" + code + "]";
throw new RuntimeException(errmsg);
}
}
// create an instance of the appropriate object
_streamer = cmap.streamer;
Object target = _streamer.createObject(this);
_current = target;
// now read the instance data
_streamer.readObject(target, this, true);
// and return the newly read object
return target;
} finally {
// clear out our current object references
_current = null;
_streamer = null;
}
}
/**
* Reads an object from the input stream that was previously written
* with {@link ObjectOutputStream#writeBareObject}.
*
* @param object the object to be populated from data on the stream.
* It cannot be <code>null</code>.
*/
public void readBareObject (Object object)
throws IOException, ClassNotFoundException
{
try {
// obtain the streamer for objects of this class
_streamer = Streamer.getStreamer(object.getClass());
_current = object;
// now read the instance data
_streamer.readObject(object, this, true);
} finally {
// clear out our current object references
_current = null;
_streamer = null;
}
}
/**
* Reads the fields of the specified {@link Streamable} instance from
* the input stream using the default object streaming mechanisms (a
* call is not made to <code>readObject()</code>, even if such a
* method exists).
*/
public void defaultReadObject ()
throws IOException, ClassNotFoundException
{
// sanity check
if (_current == null) {
throw new RuntimeException(
"defaultReadObject() called illegally.");
}
// read the instance data
_streamer.readObject(_current, this, false);
}
/**
* Used by a {@link Streamer} that is reading an array of {@link
* Streamable} instances.
*/
protected void setCurrent (Streamer streamer, Object current)
{
_streamer = streamer;
_current = current;
}
/** Used to map classes to numeric codes and the {@link Streamer}
* instance used to write them. */
protected HashIntMap _classmap;
/** The object currently being read from the stream. */
protected Object _current;
/** The streamer being used currently. */
protected Streamer _streamer;
}
src/java/com/threerings/io/ObjectOutputStream.java
+183
View File
@@ -0,0 +1,183 @@
//
// $Id: ObjectOutputStream.java,v 1.1 2002/07/23 05:42:34 mdb Exp $
package com.threerings.io;
import java.io.OutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.HashMap;
import com.threerings.presents.Log;
/**
* Used to write {@link Streamable} objects to an {@link OutputStream}.
* Other common object types are supported as well:
*
* <pre>
* Boolean
* Byte
* Character
* Short
* Integer
* Long
* Float
* Double
* boolean[]
* byte[]
* char[]
* short[]
* int[]
* long[]
* float[]
* double[]
* Object[]
* </pre>
*
* @see Streamable
*/
public class ObjectOutputStream extends DataOutputStream
{
/**
* Constructs an object output stream which will write its data to the
* supplied target stream.
*/
public ObjectOutputStream (OutputStream target)
{
super(target);
}
/**
* Writes a {@link Streamable} instance or one of the support object
* types to the output stream.
*/
public void writeObject (Object object)
throws IOException
{
// if the object to be written is null, simply write a zero
if (object == null) {
writeShort(0);
return;
}
// create our classmap if necessary
if (_classmap == null) {
_classmap = new HashMap();
}
try {
// otherwise, look up the class mapping record
Class sclass = object.getClass();
ClassMapping cmap = (ClassMapping)_classmap.get(sclass);
_current = object;
// create a class mapping for this class if we've not got one
if (cmap == null) {
// create a streamer instance and assign a code to this class
Streamer streamer = Streamer.getStreamer(sclass);
// we specifically do not inline the getStreamer() call
// into the ClassMapping constructor because we want to be
// sure not to call _nextCode++ if getStreamer() throws an
// exception
cmap = new ClassMapping(_nextCode++, sclass, streamer);
_classmap.put(sclass, cmap);
// make sure we didn't blow past our maximum class count
if (_nextCode <= 0) {
throw new RuntimeException("Too many unique classes " +
"written to ObjectOutputStream");
}
// writing a negative class code indicates that the class
// name will follow
writeShort(-cmap.code);
writeUTF(sclass.getName());
} else {
writeShort(cmap.code);
}
// now write the instance data
_streamer = cmap.streamer;
_streamer.writeObject(object, this, true);
} finally {
// clear out our current object references
_current = null;
_streamer = null;
}
}
/**
* Writes a {@link Streamable} instance or one of the support object
* types <em>without associated class metadata</em> to the output
* stream. The caller is responsible for knowing the exact class of
* the written object, creating an instance of such and calling {@link
* ObjectInputStream#readBareObject} to read its data from the stream.
*
* @param object the object to be written. It cannot be
* <code>null</code>.
*/
public void writeBareObject (Object object)
throws IOException
{
try {
// get the streamer for objects of this type
_streamer = Streamer.getStreamer(object.getClass());
_current = object;
// now write the instance data
_streamer.writeObject(object, this, true);
} finally {
// clear out our current object references
_current = null;
_streamer = null;
}
}
/**
* Uses the default streamable mechanism to write the contents of the
* object currently being streamed. This can only be called from
* within a <code>writeObject</code> implementation in a {@link
* Streamable} object.
*/
public void defaultWriteObject ()
throws IOException
{
// sanity check
if (_current == null) {
throw new RuntimeException(
"defaultWriteObject() called illegally.");
}
// Log.info("Writing default [cmap=" + _streamer +
// ", current=" + _current + "].");
// write the instance data
_streamer.writeObject(_current, this, false);
}
/**
* Used by a {@link Streamer} that is writing an array of {@link
* Streamable} instances.
*/
protected void setCurrent (Streamer streamer, Object current)
{
_streamer = streamer;
_current = current;
}
/** Used to map classes to numeric codes and the {@link Streamer}
* instance used to write them. */
protected HashMap _classmap;
/** A counter used to assign codes to streamed classes. */
protected short _nextCode = 1;
/** The object currently being written to the stream. */
protected Object _current;
/** The streamer being used currently. */
protected Streamer _streamer;
}
src/java/com/threerings/io/SimpleStreamableObject.java
+33
View File
@@ -0,0 +1,33 @@
//
// $Id: SimpleStreamableObject.java,v 1.1 2002/07/23 05:42:34 mdb Exp $
package com.threerings.io;
import com.samskivert.util.StringUtil;
/**
* A simple serializable object implements the {@link Streamable}
* interface and provides a default {@link #toString} implementation which
* outputs all public members.
*/
public class SimpleStreamableObject implements Streamable
{
/**
* Generates a string representation of this instance.
*/
public String toString ()
{
StringBuffer buf = new StringBuffer("[");
toString(buf);
return buf.append("]").toString();
}
/**
* Handles the toString-ification of all public members. Derived
* classes can override and include non-public members if desired.
*/
protected void toString (StringBuffer buf)
{
StringUtil.fieldsToString(buf, this);
}
}
src/java/com/threerings/io/Streamable.java
+29
View File
@@ -0,0 +1,29 @@
//
// $Id: Streamable.java,v 1.1 2002/07/23 05:42:34 mdb Exp $
package com.threerings.io;
/**
* Marks an object as streamable, meaning that it can be written to {@link
* ObjectOutputStream} instances and read from {@link ObjectInputStream}
* instances.
*
* <p> All non-<code>transient</code> public fields will be automatically
* written and restored for a {@link Streamable} instance. Classes that
* wish to stream non-public fields or customize the streaming process
* should implement methods with the following signatures:
*
* <p><code>
* public void writeObject ({@link ObjectOutputStream} out);
* public void readObject ({@link ObjectInputStream} in);
* </code>
*
* <p> They can then handle the entirety of the streaming process, or call
* {@link ObjectOutputStream#defaultWriteObject} and {@link
* ObjectInputStream#defaultReadObject} from within their
* <code>writeObject</code> and <code>readObject</code> methods to perform
* the standard streaming in addition to their customized behavior.
*/
public interface Streamable
{
}
src/java/com/threerings/io/Streamer.java
+430
View File
@@ -0,0 +1,430 @@
//
// $Id: Streamer.java,v 1.1 2002/07/23 05:42:34 mdb Exp $
package com.threerings.io;
import java.lang.NoSuchMethodException;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import com.samskivert.io.NestableIOException;
import com.threerings.presents.Log;
/**
* Handles the streaming of {@link Streamable} instances as well as a set
* of basic object types (see {@link ObjectOutputStream}). An instance of
* {@link Streamer} is created for each distinct class that implements
* {@link Streamable}. The {@link Streamer} reflects on the streamed class
* and caches the information necessary to efficiently read and write
* objects of the class in question.
*/
public class Streamer
{
/**
* Returns true if the supplied target class can be streamed using a
* streamer.
*/
public synchronized static boolean isStreamable (Class target)
{
// if we have a streamer registered for this class, then it's
// definitely streamable
if (_streamers.containsKey(target)) {
return true;
}
// return true if it is a streamable or already registered type,
// or an array of same
Class uclass = target.isArray() ? target.getComponentType() : target;
return (_streamers.containsKey(uclass) ||
Streamable.class.isAssignableFrom(uclass));
}
/**
* Obtains a {@link Streamer} that can be used to read and write
* objects of the specified target class. {@link Streamer} instances
* are shared among all {@link ObjectInputStream}s and {@link
* ObjectOutputStream}s.
*
* @throws IOException when a streamer is requested for an object that
* does not implement {@link Streamable} and is not one of the basic
* object types (@see {@link ObjectOutputStream}).
*/
public synchronized static Streamer getStreamer (Class target)
throws IOException
{
// if we have not yet initialized ourselves, do so now
if (_streamers == null) {
createStreamers();
}
Streamer stream = (Streamer)_streamers.get(target);
if (stream == null) {
// make sure this is a streamable class
if (!isStreamable(target)) {
throw new IOException("Requested to stream invalid class '" +
target.getName() + "'");
}
// create a streamer for this class and cache it
// Log.info("Creating a streamer for '" + target.getName() + "'.");
stream = new Streamer(target);
_streamers.put(target, stream);
}
return stream;
}
/**
* Writes the supplied object to the specified stream.
*
* @param object the instance to be written to the stream.
* @param out the stream to which to write the instance.
* @param useWriter whether or not to use the custom
* <code>writeObject</code> if one exists.
*/
public void writeObject (
Object object, ObjectOutputStream out, boolean useWriter)
throws IOException
{
// if we're supposed to and one exists, use the writer method
if (useWriter && _writer != null) {
try {
// Log.info("Writing with writer " +
// "[class=" + _target.getName() + "].");
_writer.invoke(object, new Object[] { out });
} catch (Throwable t) {
if (t instanceof InvocationTargetException) {
t = ((InvocationTargetException)t).getTargetException();
}
if (t instanceof IOException) {
throw (IOException)t;
}
String errmsg = "Failure invoking streamable writer " +
"[class=" + _target.getName() + "]";
throw new NestableIOException(errmsg, t);
}
return;
}
// if we're writing an array, do some special business
if (_target.isArray()) {
int length = Array.getLength(object);
out.writeInt(length);
// if the component class is final, we can be sure that all
// instances in the array will be of the same class and thus
// can serialize things more efficiently
int cmods = _target.getComponentType().getModifiers();
if ((cmods & Modifier.FINAL) != 0) {
// compute a mask indicating which elements are null and
// which are populated
ArrayMask mask = new ArrayMask(length);
for (int ii = 0; ii < length; ii++) {
if (Array.get(object, ii) != null) {
mask.set(ii);
}
}
// write that mask out to the stream
mask.writeTo(out);
// now write out the populated elements
for (int ii = 0; ii < length; ii++) {
Object element = Array.get(object, ii);
if (element == null) {
continue;
}
out.setCurrent(_delegate, element);
_delegate.writeObject(element, out, useWriter);
}
} else {
// otherwise we've got to write each array element with
// its own class identifier because it could be any
// derived class of the array element type
for (int ii = 0; ii < length; ii++) {
out.writeObject(Array.get(object, ii));
}
}
return;
}
// otherwise simply write out the fields via our field marshallers
int fcount = _fields.length;
for (int ii = 0; ii < fcount; ii++) {
Field field = _fields[ii];
FieldMarshaller fm = _marshallers[ii];
if (fm == null) {
String errmsg = "Unable to marshall field " +
"[class=" + _target.getName() +
", field=" + field.getName() +
", type=" + field.getType().getName() + "]";
throw new IOException(errmsg);
}
try {
// Log.info("Writing field [class=" + _target.getName() +
// ", field=" + field.getName() + "].");
fm.writeField(field, object, out);
} catch (Exception e) {
String errmsg = "Failure writing streamable field " +
"[class=" + _target.getName() +
", field=" + field.getName() + "]";
throw new NestableIOException(errmsg, e);
}
}
}
/**
* Creates a blank object that can subsequently be read by this
* streamer. Data may be read from the input stream as a result of
* this method (in the case of arrays, the length of the array must be
* read before creating the array).
*/
public Object createObject (ObjectInputStream in)
throws IOException
{
try {
// if our target class is an array type, read in the element
// count and create an array instance of the appropriate type
// and size
if (_target.isArray()) {
return Array.newInstance(
_target.getComponentType(), in.readInt());
} else {
return _target.newInstance();
}
} catch (InstantiationException ie) {
String errmsg = "Error instantiating object " +
"[type=" + _target.getName() + "]";
throw new NestableIOException(errmsg, ie);
} catch (IllegalAccessException iae) {
String errmsg = "Error instantiating object " +
"[type=" + _target.getName() + "]";
throw new NestableIOException(errmsg, iae);
}
}
/**
* Reads and populates the fields of the supplied object from the
* specified stream.
*
* @param object the instance to be read from the stream.
* @param out the stream from which to read the instance.
* @param useWriter whether or not to use the custom
* <code>readObject</code> if one exists.
*/
public void readObject (
Object object, ObjectInputStream in, boolean useReader)
throws IOException, ClassNotFoundException
{
// if we're supposed to and one exists, use the reader method
if (useReader && _reader != null) {
try {
// Log.info("Reading with reader " +
// "[class=" + _target.getName() + "].");
_reader.invoke(object, new Object[] { in });
} catch (Throwable t) {
if (t instanceof InvocationTargetException) {
t = ((InvocationTargetException)t).getTargetException();
}
if (t instanceof IOException) {
throw (IOException)t;
}
String errmsg = "Failure invoking streamable reader " +
"[class=" + _target.getName() + "]";
throw new NestableIOException(errmsg, t);
}
return;
}
// if we're reading in an array, do some special business
if (_target.isArray()) {
int length = Array.getLength(object);
// if the component class is final, we can be sure that all
// instances in the array will be of the same class and thus
// have serialized things more efficiently
int cmods = _target.getComponentType().getModifiers();
if ((cmods & Modifier.FINAL) != 0) {
// read in the nullness mask
ArrayMask mask = new ArrayMask();
mask.readFrom(in);
// now read in the array elements given that we know which
// elements to read
for (int ii = 0; ii < length; ii++) {
if (mask.isSet(ii)) {
Object element = _delegate.createObject(in);
in.setCurrent(_delegate, element);
_delegate.readObject(element, in, useReader);
Array.set(object, ii, element);
}
}
} else {
// otherwise we had to write each object out individually
for (int ii = 0; ii < length; ii++) {
Array.set(object, ii, in.readObject());
}
}
return;
}
// otherwise simply read the fields via our field marshallers
int fcount = _fields.length;
for (int ii = 0; ii < fcount; ii++) {
Field field = _fields[ii];
FieldMarshaller fm = _marshallers[ii];
if (fm == null) {
String errmsg = "Unable to marshall field " +
"[class=" + _target.getName() +
", field=" + field.getName() +
", type=" + field.getType().getName() + "]";
throw new IOException(errmsg);
}
try {
fm.readField(field, object, in);
} catch (Exception e) {
String errmsg = "Failure reading streamable field " +
"[class=" + _target.getName() +
", field=" + field.getName() + "]";
throw new NestableIOException(errmsg, e);
}
}
}
/**
* The constructor used by the basic streamers.
*/
protected Streamer ()
{
}
/**
* Constructs a streamer for the specified target class.
*/
protected Streamer (Class target)
throws IOException
{
// keep a handle on the class
_target = target;
// if our target class is an array, we want to get a handle on a
// streamer delegate that we'll use to stream our elements
if (_target.isArray()) {
_delegate = Streamer.getStreamer(_target.getComponentType());
// sanity check
if (_delegate == null) {
String errmsg = "Aiya! Streamer created for array type " +
"but we have no registered streamer for the element " +
"type [type=" + _target.getName() + "]";
throw new RuntimeException(errmsg);
}
// and that's all we'll need
return;
}
// reflect on all the public fields
Field[] fields = target.getFields();
ArrayList flist = new ArrayList();
int fcount = fields.length;
for (int ii = 0; ii < fcount; ii++) {
Field field = fields[ii];
int mods = field.getModifiers();
// skip static, transient and non-public fields
if (((mods & Modifier.STATIC) != 0) ||
((mods & Modifier.PUBLIC) == 0) ||
((mods & Modifier.TRANSIENT) != 0)) {
continue;
}
// otherwise add the field to the list
flist.add(field);
}
// convert the list of fields into an array
fcount = flist.size();
_fields = new Field[fcount];
flist.toArray(_fields);
// obtain field marshallers for all of our fields
_marshallers = new FieldMarshaller[fcount];
for (int ii = 0; ii < fcount; ii++) {
_marshallers[ii] = FieldMarshaller.getFieldMarshaller(_fields[ii]);
// Log.info("Using " + _marshallers[ii] + " for " +
// _fields[ii].getName() + ".");
}
// look up the reader and writer methods
try {
_reader = target.getMethod(READER_METHOD_NAME, READER_ARGS);
} catch (NoSuchMethodException nsme) {
// nothing to worry about, we just don't have one
}
try {
_writer = target.getMethod(WRITER_METHOD_NAME, WRITER_ARGS);
} catch (NoSuchMethodException nsme) {
// nothing to worry about, we just don't have one
}
}
/**
* Creates our streamers table and registers streamers for all of the
* basic types.
*/
protected static void createStreamers ()
{
_streamers = new HashMap();
// register all of the basic streamers
int bscount = BasicStreamers.BSTREAMER_TYPES.length;
for (int ii = 0; ii < bscount; ii++) {
_streamers.put(BasicStreamers.BSTREAMER_TYPES[ii],
BasicStreamers.BSTREAMER_INSTANCES[ii]);
}
}
/** The class for which this streamer instance is configured. */
protected Class _target;
/** If our target class is an array, this is a reference to a streamer
* that can stream our array elements, otherwise it is null. */
protected Streamer _delegate;
/** The non-transient, non-static public fields that we will stream
* when requested. */
protected Field[] _fields;
/** Field marshallers for each field that will be read or written in
* our objects. */
protected FieldMarshaller[] _marshallers;
/** A reference to the <code>readObject</code> method if one is
* defined by our target class. */
protected Method _reader;
/** A reference to the <code>writeObject</code> method if one is
* defined by our target class. */
protected Method _writer;
/** Contains the mapping from class names to configured streamer
* instances. */
protected static HashMap _streamers;
/** The name of the custom reader method. */
protected static final String READER_METHOD_NAME = "readObject";
/** The argument list for the custom reader method. */
protected static final Class[] READER_ARGS = { ObjectInputStream.class };
/** The name of the custom writer method. */
protected static final String WRITER_METHOD_NAME = "writeObject";
/** The argument list for the custom writer method. */
protected static final Class[] WRITER_ARGS = { ObjectOutputStream.class };
}