Kryo的变长序列化底层在AS3的实现

当前是个人把java的Output和Input的翻译成了AS3版本，虽然没什么技术含量，但是还是很有帮助，经过长时间使用，基本确保和java之间的通信没有任何问题。

package yxcq.kryo
{
    import flash.utils.ByteArray;
    
    import yxcq.utils.math.Long;
    
    public class Input
    {
        protected var buffer:ByteArray;
        
        public function Input(bytes:ByteArray)
        {
            if(bytes != null){
                this.buffer = bytes;
                this.buffer.position = 0;
            }
        }
        
        public function get bytesAvailable():int
        {
            return buffer.bytesAvailable;
        }
        
        public function setBytes(bytes:ByteArray):void
        {
            this.buffer = bytes;
            this.buffer.position = 0;
        }
        
        protected function require(required:int):int
        {
            if(buffer.bytesAvailable>=required)
                return buffer.bytesAvailable;
            else
                throw new Error();
        }
        
        public function read():int
        {
            if(buffer.bytesAvailable<1)
                return -1;
            return buffer.readUnsignedByte()&0xFF;
        }
        
        public function skip(count:int):void
        {
            this.buffer.position = this.buffer.position+count;
        }
        
        public function readByte():int
        {
            require(1);
            return buffer.readByte();
        }
        
        public function readByteUnsigned():int
        {
            require(1);
            return buffer.readUnsignedByte();
        }
        
        public function readBytes(length:int):ByteArray
        {
            var bytes:ByteArray = new ByteArray;
            _readBytes(bytes,0,length);
            return bytes;
        }
        
        protected function _readBytes(bytes:ByteArray,offset:int,length:int):void
        {
            buffer.readBytes(bytes,offset,length);
        }
        
        public function readInt():int{
            require(4);
            return (buffer.readUnsignedByte() & 0xFF) << 24 //
                | (buffer.readUnsignedByte() & 0xFF) << 16 //
                | (buffer.readUnsignedByte() & 0xFF) << 8 //
                | buffer.readUnsignedByte() & 0xFF;
        }
        
        /** Reads a 1-5 byte int. It is guaranteed that a varible length encoding will be used. */
        public function readVarInt (optimizePositive:Boolean):int {
            if (require(1) < 5) return readInt_slow(optimizePositive);
            var b:int = buffer.readUnsignedByte();
            var result:int = b & 0x7F;
            if ((b & 0x80) != 0) {
                b = buffer.readUnsignedByte();
                result |= (b & 0x7F) << 7;
                if ((b & 0x80) != 0) {
                    b = buffer.readUnsignedByte();
                    result |= (b & 0x7F) << 14;
                    if ((b & 0x80) != 0) {
                        b = buffer.readUnsignedByte();
                        result |= (b & 0x7F) << 21;
                        if ((b & 0x80) != 0) {
                            b = buffer.readUnsignedByte();
                            result |= (b & 0x7F) << 28;
                        }
                    }
                }
            }
            return optimizePositive ? result : ((result >>> 1) ^ -(result & 1));
        }
        
        private function readInt_slow (optimizePositive:Boolean):int {
            // The buffer is guaranteed to have at least 1 byte.
            var b:int = buffer.readUnsignedByte();
            var result:int = b & 0x7F;
            if ((b & 0x80) != 0) {
                require(1);
                b = buffer.readUnsignedByte();
                result |= (b & 0x7F) << 7;
                if ((b & 0x80) != 0) {
                    require(1);
                    b = buffer.readUnsignedByte();
                    result |= (b & 0x7F) << 14;
                    if ((b & 0x80) != 0) {
                        require(1);
                        b = buffer.readUnsignedByte();
                        result |= (b & 0x7F) << 21;
                        if ((b & 0x80) != 0) {
                            require(1);
                            b = buffer.readUnsignedByte();
                            result |= (b & 0x7F) << 28;
                        }
                    }
                }
            }
            return optimizePositive ? result : ((result >>> 1) ^ -(result & 1));
        }
        
        
        protected var chars:ByteArray = new ByteArray;
        
        public function readString():String
        {
            var available:int = require(1);
            var b:int = buffer.readUnsignedByte();
            if((b&0x80) == 0)return readAscii();
            var charCount:int = available>=5?readUtf8Length(b) : readUtf8Length_slow(b);
            switch (charCount) {
                case 0:
                    return null;
                case 1:
                    return "";
            }
            charCount--;
            chars.clear();
            readUtf8(charCount);
            var len:int = chars.position;
            chars.position = 0;
            return chars.readUTFBytes(len);
        }
        
        private function readUtf8Length (b:int):int {
            var result:int = b & 0x3F; // Mask all but first 6 bits.
            if ((b & 0x40) != 0) { // Bit 7 means another byte, bit 8 means UTF8.
                b = buffer.readUnsignedByte();
                result |= (b & 0x7F) << 6;
                if ((b & 0x80) != 0) {
                    b = buffer.readUnsignedByte();
                    result |= (b & 0x7F) << 13;
                    if ((b & 0x80) != 0) {
                        b = buffer.readUnsignedByte();
                        result |= (b & 0x7F) << 20;
                        if ((b & 0x80) != 0) {
                            b = buffer.readUnsignedByte();
                            result |= (b & 0x7F) << 27;
                        }
                    }
                }
            }
            return result;
        }
        
        private function readUtf8Length_slow (b:int):int {
            var result:int = b & 0x3F; // Mask all but first 6 bits.
            if ((b & 0x40) != 0) { // Bit 7 means another byte, bit 8 means UTF8.
                require(1);
                b = buffer.readUnsignedByte();
                result |= (b & 0x7F) << 6;
                if ((b & 0x80) != 0) {
                    require(1);
                    b = buffer.readUnsignedByte();
                    result |= (b & 0x7F) << 13;
                    if ((b & 0x80) != 0) {
                        require(1);
                        b = buffer.readUnsignedByte();
                        result |= (b & 0x7F) << 20;
                        if ((b & 0x80) != 0) {
                            require(1);
                            b = buffer.readUnsignedByte();
                            result |= (b & 0x7F) << 27;
                        }
                    }
                }
            }
            return result;
        }
        
        private function readUtf8 (charCount:int):void {
            // Try to read 7 bit ASCII chars.
            var charIndex:int = 0;
            var count:int = Math.min(require(1), charCount);
            var b:int;
            while (charIndex < count) {
                b = buffer.readByte();
                if (b < 0) {
                    this.buffer.position--;
                    break;
                }
                charIndex++;
                chars.writeByte(b);
            }
            // If buffer didn't hold all chars or any were not ASCII, use slow path for remainder.
            if (charIndex < charCount){ 
                readUtf8_slow(charCount, charIndex);
            }
        }
        
        private function readUtf8_slow (charCount:int, charIndex:int):void {
            var utfstrlen:int = 0;
            var position:int = buffer.position;
            while (charIndex < charCount) {
                var b:int = buffer.readByte() & 0x000000FF;
                switch (b >> 4) {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                    case 5:
                    case 6:
                    case 7:
                        chars.writeByte(b);
                        break;
                    case 12:
                    case 13:
                        chars.writeByte(b);
                        chars.writeByte(buffer.readByte());
                        break;
                    case 14:
                        chars.writeByte(b);
                        chars.writeByte(buffer.readByte());
                        chars.writeByte(buffer.readByte());
                        break;
                }
                charIndex++;
            }
        }
        
        private function readAscii ():String {
            var position:int = buffer.position;
            var end:int = buffer.position;
            var start:int = end -1;
            var limit:int = buffer.length;
            var b:int;
            do {
                if(end == limit){
                    buffer.position = position-1;
                    return readAscii_slow();
                }
                b = buffer.readUnsignedByte();
                end++;
            } while ((b & 0x00000080) == 0);
            buffer[end - 1] &=0x0000007F; // Mask end of ascii bit.
            buffer.position = position-1;
            var value:String = (buffer as ByteArray).readMultiByte(end-start,'iso-8859-1');
            buffer[end - 1] |= 0x00000080;
            return value;
        }
        
        private function readAscii_slow ():String {
            throw new Error("数据流中有不支持的字符串解析");
        }
        
        public function readFloat():Number
        {
            return buffer.readFloat();
        }
        
        public function readFloat2(precision:Number,optimizePositive:Boolean):Number
        {
            return Number(readInt_slow(optimizePositive))/precision;
        }
        
        public function readShort():int
        {
            return buffer.readShort();
        }
        
        public function readShortUnsigned():int
        {
            return buffer.readUnsignedShort();
        }
        
        public function readLong():Long
        {
            var h:int = buffer.readUnsignedByte()<<22;
            h |= buffer.readUnsignedByte()<<16;
            h |= buffer.readUnsignedByte()<<8;
            h |= buffer.readUnsignedByte();
            var l:int = buffer.readUnsignedByte()<<22;
            l |= buffer.readUnsignedByte()<<16;
            l |= buffer.readUnsignedByte()<<8;
            l |= buffer.readUnsignedByte();
            return new Long(h,l);
        }
        
        public function readVarLong (optimizePositive:Boolean):Long{
            var b:int = buffer.readByte();
            var low:int = b & 0x7F;
            var high:int = 0;
            if ((b & 0x80) != 0) {
                b = buffer.readByte();
                low |= (b & 0x7F) << 7;
                if ((b & 0x80) != 0) {
                    b = buffer.readByte();
                    low |= (b & 0x7F) << 14;
                    if ((b & 0x80) != 0) {
                        b = buffer.readByte();
                        low |= (b & 0x7F) << 21;
                        if ((b & 0x80) != 0) {
                            b = buffer.readByte();
                            var temp:int = b&0x7F;
                            high = ((0 << temp) | (temp >>> 4) )|high;
                            low |= (temp << 28);
                            if ((b & 0x80) != 0) {
                                b = buffer.readByte();
                                high |= (b & 0x7F)<<3;
                                if ((b & 0x80) != 0) {
                                    b = buffer.readByte();
                                    high |= (b & 0x7F) << 10;
                                    if ((b & 0x80) != 0) {
                                        b = buffer.readByte();
                                        high |= (b & 0x7F) << 17;
                                        if ((b & 0x80) != 0) {
                                            b = buffer.readByte();
                                            high |= (b & 0x7F) << 24;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            var result:Long = new Long(high,low);
            if (!optimizePositive) result = result.rightShift(1,true).xor(result.and(1));
            return result;
        }
        
        public function readBoolean():Boolean
        {
            return buffer.readUnsignedByte()==1;
        }
        
        public function readChar():int
        {
            return buffer.readUnsignedShort();
        }
        
        public function readDouble():Number
        {
            return buffer.readDouble();
        }
        
        /** Bulk input of an int array. */
        public function readVarInts (length:int, optimizePositive:Boolean):Vector.<int>{
            var array:Vector.<int> = new Vector.<int>;
            for (var i:int = 0; i < length; i++)
                array[i] = readVarInt(optimizePositive);
            return array;
        }
        
        public function readVarLongs (length:int, optimizePositive:Boolean):Vector.<Long>{
            var array:Vector.<Long> = new Vector.<Long>;
            for (var i:int = 0; i < length; i++)
                array[i] = readVarLong(optimizePositive);
            return array;
        }
        
        /** Bulk input of an int array. */
        public function readInts (length:int) :Vector.<int> {
            var array:Vector.<int> = new Vector.<int>;
            for (var i:int = 0; i < length; i++)
                array[i] = readInt();
            return array;
        }
        
        /** Bulk input of a long array. */
        public function readLongs (length:int):Vector.<Long> {
            var array:Vector.<Long> = new Vector.<Long>;
            for (var i:int = 0; i < length; i++)
                array[i] = readLong();
            return array;
        }
        
        /** Bulk input of a float array. */
        public function readFloats (length:int) :Vector.<Number> {
            var array:Vector.<Number> = new Vector.<Number>;
            for (var i:int = 0; i < length; i++)
                array[i] = readFloat();
            return array;
        }
        
        /** Bulk input of a short array. */
        public function readShorts (length:int):Vector.<int>  {
            var array:Vector.<int> = new Vector.<int>;
            for (var i:int = 0; i < length; i++)
                array[i] = readShort();
            return array;
        }
        
        /** Bulk input of a char array. */
        public function readChars (length:int):Vector.<int>  {
            var array:Vector.<int> = new Vector.<int>;
            for (var i:int = 0; i < length; i++)
                array[i] = readChar();
            return array;
        }
        
        /** Bulk input of a double array. */
        public function readDoubles (length:int):Vector.<Number>  {
            var array:Vector.<Number> = new Vector.<Number>;
            for (var i:int = 0; i < length; i++)
                array[i] = readDouble();
            return array;
        }
    }
}

package yxcq.kryo
{
    import yxcq.utils.math.Long;
    import flash.utils.ByteArray;
    
    public class Output
    {
        protected var buffer:ByteArray = new ByteArray;
        
        public function Output()
        {
        }
        
        public function getBuffer():ByteArray
        {
            return buffer;
        }
        
        public function write(value:int):void
        {
            buffer.writeByte(value);
        }
        
        public function writeBytes(bytes:ByteArray,offset:int,length:int):void
        {
            buffer.writeBytes(bytes,offset,length);
        }
        
        
        public function writeByte(b:int):void
        {
            buffer.writeByte(b);
        }
        
        public function writeInt(value:int):void
        {
            buffer.writeInt(value);
        }
        
        public function writeVarInt(value:int,optimizePositive:Boolean):int
        {
            if(!optimizePositive) value = (value<<1)^(value>>31);
            if(value>>>7 == 0){
                buffer.writeByte(value&0xFF);
                return 1;
            }
            if(value>>>14 == 0){
                buffer.writeByte((value&0x7F | 0x80)&0xFF);
                buffer.writeByte((value>>>7)&0xFF);
                return 2;
            }
            if (value >>> 21 == 0) {
                buffer.writeByte((value&0x7F | 0x80)&0xFF);
                buffer.writeByte((value>>>7|0x80)&0xFF);
                buffer.writeByte((value>>>14)&0xFF);
                return 3;
            }
            if (value >>> 28 == 0) {
                buffer.writeByte((value&0x7F | 0x80)&0xFF);
                buffer.writeByte((value>>>7|0x80)&0xFF);
                buffer.writeByte((value>>>14|0x80)&0xFF);
                buffer.writeByte((value>>>21)&0xFF);
                return 4;
            }
            buffer.writeByte((value&0x7F | 0x80)&0xFF);
            buffer.writeByte((value>>>7|0x80)&0xFF);
            buffer.writeByte((value>>>14|0x80)&0xFF);
            buffer.writeByte((value>>>21|0x80)&0xFF);
            buffer.writeByte((value>>>28)&0xFF);
            return 5;
        }
        public function writeVarLong (value:Long, optimizePositive:Boolean):int{
            if (!optimizePositive) value = value.leftShift(1).xor(value.rightShift(63));
            if (value.rightShift(7,true).isZero()) {
                buffer.writeByte(value.getLow());
                return 1;
            }
            if (value.rightShift(14,true).isZero()) {
                buffer.writeByte(value.and(0x7F).or(0x80).getLow());
                buffer.writeByte(value.rightShift(7,true).getLow());
                return 2;
            }
            if (value.rightShift(21,true).isZero()) {
                buffer.writeByte(value.and(0x7F).or(0x80).getLow());
                buffer.writeByte(value.rightShift(7,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(14,true).getLow());
                return 3;
            }
            if (value.rightShift(28,true).isZero()) {
                buffer.writeByte(value.and(0x7F).or(0x80).getLow());
                buffer.writeByte(value.rightShift(7,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(14,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(21,true).getLow());
                return 4;
            }
            if (value.rightShift(35,true).isZero()) {
                buffer.writeByte(value.and(0x7F).or(0x80).getLow());
                buffer.writeByte(value.rightShift(7,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(14,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(21,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(28,true).getLow());
                return 5;
            }
            if (value.rightShift(42,true).isZero()) {
                buffer.writeByte(value.and(0x7F).or(0x80).getLow());
                buffer.writeByte(value.rightShift(7,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(14,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(21,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(28,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(35,true).getLow());
                return 6;
            }
            if (value.rightShift(49,true).isZero()) {
                buffer.writeByte(value.and(0x7F).or(0x80).getLow());
                buffer.writeByte(value.rightShift(7,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(14,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(21,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(28,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(35,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(42,true).getLow());
                return 7;
            }
            if (value.rightShift(56,true).isZero()) {
                buffer.writeByte(value.and(0x7F).or(0x80).getLow());
                buffer.writeByte(value.rightShift(7,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(14,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(21,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(28,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(35,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(42,true).or(0x80).getLow());
                buffer.writeByte(value.rightShift(49,true).getLow());
                return 8;
            }
            buffer.writeByte(value.and(0x7F).or(0x80).getLow());
            buffer.writeByte(value.rightShift(7,true).or(0x80).getLow());
            buffer.writeByte(value.rightShift(14,true).or(0x80).getLow());
            buffer.writeByte(value.rightShift(21,true).or(0x80).getLow());
            buffer.writeByte(value.rightShift(28,true).or(0x80).getLow());
            buffer.writeByte(value.rightShift(35,true).or(0x80).getLow());
            buffer.writeByte(value.rightShift(42,true).or(0x80).getLow());
            buffer.writeByte(value.rightShift(49,true).or(0x80).getLow());
            buffer.writeByte(value.rightShift(56,true).getLow());
            return 9;
        }
        
        public function writeString (value:String):void {
            if (value == null) {
                writeByte(0x80); // 0 means null, bit 8 means UTF8.
                return;
            }
            var charCount:int = value.length;
            if (charCount == 0) {
                writeByte(1 | 0x80); // 1 means empty string, bit 8 means UTF8.
                return;
            }
            // Detect ASCII. 检查是否ASCII
            var ascii:Boolean = false;
            if (charCount > 1 && charCount < 64) {
                ascii = true;
                for (var i:int = 0; i < charCount; i++) {
                    var c:int = value.charCodeAt(i);
                    if (c > 127) {
                        ascii = false;
                        break;
                    }
                }
            }
            if (ascii) {
                buffer.writeUTFBytes(value);
                buffer[buffer.position - 1] |= 0x80;
            } else {
                writeUtf8Length(charCount + 1);
                var charIndex:int = 0;
                var position:int = buffer.position;
                // Try to write 8 bit chars.
                for (; charIndex < charCount; charIndex++) {
                    var c:int = value.charCodeAt(charIndex);
                    if (c > 127) break;
                    buffer.writeByte(c&0xFF);
                    position++;
                }
                buffer.position = position;
                if (charIndex < charCount) 
                    writeString_slow(value, charCount, charIndex);
            }
        }
        
        /** Writes a string that is known to contain only ASCII characters. Non-ASCII strings passed to this method will be corrupted.
         * Each byte is a 7 bit character with the remaining byte denoting if another character is available. This is slightly more
         * efficient than {@link #writeString(String)}. The string can be read using {@link Input#readString()} or
         * {@link Input#readStringBuilder()}.
         * @param value May be null. */
        public function writeAscii (value:String):void{
            if (value == null) {
                writeByte(0x80); // 0 means null, bit 8 means UTF8.
                return;
            }
            var charCount:int = value.length;
            switch (charCount) {
                case 0:
                    writeByte(1 | 0x80); // 1 is string length + 1, bit 8 means UTF8.
                    return;
                case 1:
                    writeByte(2 | 0x80); // 2 is string length + 1, bit 8 means UTF8.
                    writeByte(value.charCodeAt(0));
                    return;
            }
            buffer.writeUTF(value);
            buffer[buffer.position - 1] |= 0x80; // Bit 8 means end of ASCII.
        }
        
        /** Writes the length of a string, which is a variable length encoded int except the first byte uses bit 8 to denote UTF8 and
         * bit 7 to denote if another byte is present. */
        private function writeUtf8Length (value:int):void {
            if (value >>> 6 == 0) {
                buffer.writeByte((value | 0x80)&0xFF); // Set bit 8.
            } else if (value >>> 13 == 0) {
                buffer.writeByte((value | 0x40 | 0x80)&0xFF); // Set bit 7 and 8.
                buffer.writeByte((value >>> 6)&0xFF);
            } else if (value >>> 20 == 0) {
                buffer.writeByte((value | 0x40 | 0x80)&0xFF); // Set bit 7 and 8.
                buffer.writeByte(((value >>> 6) | 0x80)&0xFF); // Set bit 8.
                buffer.writeByte((value >>> 13)&0xFF);
            } else if (value >>> 27 == 0) {
                buffer.writeByte((value | 0x40 | 0x80)&0xFF); // Set bit 7 and 8.
                buffer.writeByte(((value >>> 6) | 0x80)&0xFF); // Set bit 8.
                buffer.writeByte(((value >>> 13) | 0x80)&0xFF); // Set bit 8.
                buffer.writeByte((value >>> 20)&0xFF);
            } else {
                buffer.writeByte((value | 0x40 | 0x80)&0xFF); // Set bit 7 and 8.
                buffer.writeByte(((value >>> 6) | 0x80)&0xFF); // Set bit 8.
                buffer.writeByte(((value >>> 13) | 0x80)&0xFF); // Set bit 8.
                buffer.writeByte(((value >>> 20) | 0x80)&0xFF); // Set bit 8.
                buffer.writeByte((value >>> 27)&0xFF);
            }
        }
        
        private function writeString_slow (value:String, charCount:int, charIndex:int):void {
            for (; charIndex < charCount; charIndex++) {
                var c:int = value.charCodeAt(charIndex);
                if (c <= 0x007F) {
                    buffer.writeByte(c&0xFF);
                } else if (c > 0x07FF) {
                    buffer.writeByte((0xE0 | c >> 12 & 0x0F)&0xFF);
                    buffer.writeByte((0x80 | c >> 6 & 0x3F)&0xFF);
                    buffer.writeByte((0x80 | c & 0x3F)&0xFF);
                } else {
                    buffer.writeByte((0xC0 | c >> 6 & 0x1F)&0xFF);
                    buffer.writeByte((0x80 | c & 0x3F)&0xFF);
                }
            }
        }
        
        public function writeFloat(value:Number):void
        {
            this.buffer.writeFloat(value);
        }
        
        public function writeFloat2(value:Number,precision:Number,optimizePositive:Boolean):void
        {
            this.writeVarInt(value*precision,optimizePositive);
        }
        
        public function writeShort(value:int):void
        {
            this.buffer.writeShort(value);
        }
        
        public function writeLong(value:Long):void
        {
            this.buffer.writeByte(value.getHigh()>>>24);
            this.buffer.writeByte(value.getHigh()>>>16);
            this.buffer.writeByte(value.getHigh()>>>8);
            this.buffer.writeByte(value.getHigh());
            this.buffer.writeByte(value.getLow()>>>24);
            this.buffer.writeByte(value.getLow()>>>16);
            this.buffer.writeByte(value.getLow()>>>8);
            this.buffer.writeByte(value.getLow());
        }
        
        public function writeBoolean(value:Boolean):void
        {
            this.buffer.writeBoolean(value);
        }
        
        public function writeChar(value:int):void
        {
            this.buffer.writeShort(value);
        }
        
        public function writeDouble(value:Number):void
        {
            this.buffer.writeDouble(value);
        }
        
        /** Bulk output of an int array. */
        public function writeVarInts (object:Vector.<int>, optimizePositive:Boolean) :void {
            for (var i:int = 0, n:int = object.length; i < n; i++)
                writeVarInt(object[i], optimizePositive);
        }
        
        /** Bulk output of an int array. */
        public function writeInts (object:Vector.<int>) :void {
            for (var i:int = 0, n:int = object.length; i < n; i++)
                this.buffer.writeInt(object[i]);
        }
        
        public function writeVarLongs (object:Vector.<Long>, optimizePositive:Boolean):void{
            for (var i:int = 0, n:int = object.length; i < n; i++)
                writeVarLong(object[i], optimizePositive);
        }
        
        /** Bulk output of an long array. */
        public function writeLongs (object:Vector.<Long>) :void {
            for (var i:int = 0, n:int = object.length; i < n; i++)
                writeLong(object[i]);
        }
        
        /** Bulk output of a float array. */
        public function writeFloats (object:Vector.<Number>) :void {
            for (var i:int = 0, n:int = object.length; i < n; i++)
                writeFloat(object[i]);
        }
        
        /** Bulk output of a short array. */
        public function writeShorts (object:Vector.<int>) :void {
            for (var i:int = 0, n:int = object.length; i < n; i++)
                writeShort(object[i]);
        }
        
        /** Bulk output of a char array. */
        public function writeChars (object:Vector.<int>) :void {
            for (var i:int = 0, n:int = object.length; i < n; i++)
                writeChar(object[i]);
        }
        
        /** Bulk output of a double array. */
        public function writeDoubles (object:Vector.<int>) :void {
            for (var i:int = 0, n:int = object.length; i < n; i++)
                writeDouble(object[i]);
        }
    }
}