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]);

        }

    }

}

 

你可能感兴趣的:(序列化)