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

Beginnings of the ActionScript 3.0 client: checkpoint checkin.

Browse Source 
There's a long way to go and I think I need to rethink the way streaming
will work, but this is a start. These classes all compile under
the flex environment.


git-svn-id: svn+ssh://src.earth.threerings.net/narya/trunk@3842 542714f4-19e9-0310-aa3c-eee0fc999fb1
This commit is contained in:
Ray Greenwell
2006-02-09 03:33:58 +00:00
parent fe47f6a478
commit 3f9c6c6081
12 changed files with 681 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/as/com/threerings/io/ArrayMask.as
+6
View File
@@ -0,0 +1,6 @@
package com.threerings.io {
public class ArrayMask
{
}
}
src/as/com/threerings/io/ClassMapping.as
+17
View File
@@ -0,0 +1,17 @@
package com.threerings.io {
public class ClassMapping
{
public var code :int;
public var classname :String;
public var streamer :Streamer;
public function ClassMapping (code :int, classname :String,
streamer :Streamer)
{
this.code = code;
this.classname = classname;
this.streamer = streamer;
}
}
}
src/as/com/threerings/io/ObjectInputStream.as
+174
View File
@@ -0,0 +1,174 @@
package com.threerings.io {
import flash.errors.IOError;
import flash.util.ByteArray;
import flash.util.IDataInput;
import com.threerings.util.ClassUtil;
import com.threerings.util.SimpleMap;
public class ObjectInputStream
{
public function ObjectInputStream (targ:IDataInput)
{
_targ = targ;
}
public function readObject () :*
//throws IOError
{
var cmap :ClassMapping;
try {
// read in the class code for this instance
var code :int = readShort();
// a zero code indicates a null value
if (code == 0) {
return null;
// if the code is negative, that means 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
var cname :String = readUTF();
var streamer :Streamer = Streamer.getStreamer(cname);
cmap = new ClassMapping(code, cname, streamer);
_classMap[code] = cmap;
} else {
cmap = _classMap[code];
if (null == cmap) {
throw new IOError("Read object for which we have no " +
"registered class metadata.");
}
}
// create an instance of the appropriate object
_streamer = cmap.streamer;
var 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;
}
}
public function readBareObject (obj :*) :void
//throws IOError
{
try {
// obtain the streamer for the objects of this class
_streamer = Streamer.getStreamer(ClassUtil.getClassName(obj));
_current = obj;
// now read the instance data
_streamer.readObject(obj, this, true);
} finally {
// clear out our current object references
_current = null;
_streamer = null;
}
}
public function readField (clazz :Class) :*
//throws IOError
{
if (readBoolean()) {
var obj :* = new clazz();
return readBareObject(obj);
}
return null;
}
public function defaultReadObject () :void
//throws IOError
{
_streamer.readObject(_current, this, false);
}
public function readBoolean () :Boolean
//throws IOError
{
return _targ.readBoolean();
}
public function readByte () :int
//throws IOError
{
return _targ.readByte();
}
public function readBytes (bytes :ByteArray, offset :uint = 0,
length :uint = 0) :void
//throws IOError
{
_targ.readBytes(bytes, offset, length);
}
public function readDouble () :Number
//throws IOError
{
return _targ.readDouble();
}
public function readFloat () :Number
//throws IOError
{
return _targ.readFloat();
}
public function readInt () :int
//throws IOError
{
return _targ.readInt();
}
public function readShort () :int
//throws IOError
{
return _targ.readShort();
}
public function readUTF () :String
//throws IOError
{
return _targ.readUTF();
}
/**
* Used by a Streamer that is reading an array of Streamable instances.
*/
protected function setCurrent (streamer :Streamer, current :*)
{
_streamer = streamer;
_current = current;
}
/** The target DataInput that we route input from. */
protected var _targ :IDataInput;
/** The object currently being read from the stream. */
protected var _current :*;
/** The stramer being used currently. */
protected var _streamer :Streamer;
/** A map of short class code to ClassMapping info. */
protected var _classMap :SimpleMap = new SimpleMap();
}
}
src/as/com/threerings/io/ObjectOutputStream.as
+182
View File
@@ -0,0 +1,182 @@
package com.threerings.io {
import flash.util.ByteArray;
import flash.util.IDataOutput;
import com.threerings.util.ClassUtil;
import com.threerings.util.SimpleMap;
public class ObjectOutputStream
// implements IDataOutput
{
public function ObjectOutputStream (targ :IDataOutput)
{
_targ = targ;
}
public function writeObject (obj :*) :void
//throws IOError
{
// if the object to be written is null (or undefined) write a zero
if (obj == null) {
writeShort(0);
return;
}
try {
var cname :String = ClassUtil.getClassName(obj);
// look up the class mapping record
var cmap :ClassMapping = _classMap[cname];
_current = obj;
// create a class mapping if we've not got one
if (cmap === undefined) {
var streamer :Streamer = Streamer.getStreamer(cname);
cmap = new ClassMapping(_nextCode++, cname, streamer);
_classMap[cname] = cmap;
// TODO: if _nextCode blows short, log an error
writeShort(-cmap.code);
writeUTF(cname);
} else {
writeShort(cmap.code);
}
// now write the instance data
_streamer = cmap.streamer;
_streamer.writeObject(obj, this, true);
} finally {
_current = null;
_streamer = null;
}
}
public function writeBareObject (obj :*) :void
//throws IOError
{
try {
// get the streamer for objects of this type
_streamer = Streamer.getStreamer(ClassUtil.getClassName(obj));
_current = obj;
// now write the instance data
_streamer.writeObject(obj, this, true);
} finally {
// clear out our current object references
_current = null;
_streamer = null;
}
}
public function writeField (val :*) :void
//throws IOError
{
var b :Boolean = (val != null);
writeBoolean(b);
if (b) {
writeBareObject(val);
}
}
/**
* 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 function defaultWriteObject () :void
//throws IOError
{
// sanity check
if (_current == null) {
throw new Error("defaultWriteObject() called illegally.");
}
// write the instance data
_streamer.writeObject(_current, this, false)
}
public function writeBoolean (value :Boolean) :void
//throws IOError
{
_targ.writeBoolean(value);
}
public function writeByte (value :int) :void
//throws IOError
{
_targ.writeByte(value);
}
public function writeBytes (bytes :ByteArray, offset :uint=0,
length :uint = 0) :void
//throws IOError
{
_targ.writeBytes(bytes, offset, length);
}
public function writeDouble (value :Number) :void
//throws IOError
{
_targ.writeDouble(value);
}
public function writeFloat (value :Number) :void
//throws IOError
{
_targ.writeFloat(value);
}
public function writeInt (value :int) :void
//throws IOError
{
_targ.writeInt(value);
}
public function writeShort (value :int) :void
//throws IOError
{
_targ.writeInt(value);
}
public function writeUTF (value :String) :void
//throws IOError
{
_targ.writeUTF(value);
}
// these two are defined in IDataOutput, but have no java equivalent so
// we skip them.
//public function writeUnsignedInt (value :int) :void
//public function writeUTFBytes (value :int) :void
/**
* Used by a Streamer that is writing an array of Streamable instances.
*/
protected function setCurrent (streamer :Streamer, current :*)
{
_streamer = streamer;
_current = current;
}
/** The target DataOutput that we route things to. */
protected var _targ :IDataOutput;
/** A counter used to assign codes to streamed classes. */
protected var _nextCode :int = 1;
/** The object currently being written out. */
protected var _current :*;
/** The streamer being used currently. */
protected var _streamer :Streamer;
/** A map of classname to ClassMapping inffaro. */
protected var _classMap :SimpleMap = new SimpleMap();
}
}
src/as/com/threerings/io/Streamable.as
+11
View File
@@ -0,0 +1,11 @@
package com.threerings.io {
public interface Streamable
{
function writeObject (out :ObjectOutputStream) :void;
//throws IOError;
function readObject (ins :ObjectInputStream) :void;
//throws IOError; /** ClassCastException equivalent. */
}
}
src/as/com/threerings/io/Streamer.as
+97
View File
@@ -0,0 +1,97 @@
package com.threerings.io {
import com.threerings.util.SimpleMap;
public class Streamer
{
public static function getStreamer (className :String) :Streamer
//throws IOError
{
if (_streamerMap == null) {
createStreamers();
}
var streamer :Streamer = _streamerMap[className];
if (streamer == null) {
streamer = new Streamer(className);
_streamerMap[className] = streamer;
}
return streamer;
}
/** This should be a protected constructor. */
public function Streamer (targ :Class)
//throws IOError
{
_targ = targ;
}
/**
* Return the String to use to identify the class that we're streaming.
*/
// TODO
public function getClassName () :String
{
return "TODO: javaname";
}
public function writeObject (obj :*, out :ObjectOutputStream,
useWriter :Boolean) :void
//throws IOError
{
// TODO: check use of isProtoTypeOf, it's unclear if it's
// going to do what we want
if (useWriter && obj.isPrototypeOf(Streamable)) {
obj.writeObject(out);
return;
}
// TODO: cope with arrays
// write out the fields... this is bogus because
// we just want to call the streamer method
obj.writeObject(out);
}
public function createObject (ins :ObjectInputStream) :*
//throws IOError
{
// actionscript is so fucked up
return new _targ();
}
public function readObject (obj :*, ins :ObjectInputStream,
useReader :Boolean) :void
//throws IOError
{
// TODO: check use of isProtoTypeOf, it's unclear if it's
// going to do what we want
if (useReader && obj.isPrototypeOf(Streamable)) {
obj.readObject(ins);
return;
}
// TODO: cope with arrays
// read in the fields... this is bogus because we just
// want to call the streamer method
obj.readObject(ins);
}
/**
* Creates our streamers table map and registers streamers for
* basic types.
*/
protected static function createStreamers () :void
{
_streamerMap = new SimpleMap();
// TODO: fill in with the basic streamers
}
protected var _targ :Class;
protected static var _streamerMap :SimpleMap;
}
}