hessian2input.as

RESIN 3.2 最新源码

        case 'X'.charCodeAt():
        case 'x'.charCodeAt():
          _isLastChunk = tag == 'S'.charCodeAt() || tag == 'X'.charCodeAt();
          _chunkLength = (read() << 8) + read();

          _sbuf = "";

          var ch:int;

          while ((ch = parseChar()) >= 0)
            _sbuf += String.fromCharCode(ch);

          return _sbuf;

        // 0-byte string
        case 0x00: case 0x01: case 0x02: case 0x03:
        case 0x04: case 0x05: case 0x06: case 0x07:
        case 0x08: case 0x09: case 0x0a: case 0x0b:
        case 0x0c: case 0x0d: case 0x0e: case 0x0f:

        case 0x10: case 0x11: case 0x12: case 0x13:
        case 0x14: case 0x15: case 0x16: case 0x17:
        case 0x18: case 0x19: case 0x1a: case 0x1b:
        case 0x1c: case 0x1d: case 0x1e: case 0x1f:
          _isLastChunk = true;
          _chunkLength = tag - 0x00;

          _sbuf = "";

          while ((ch = parseChar()) >= 0)
            _sbuf += String.fromCharCode(ch);

          return _sbuf;

        default:
          throw expect("string", tag);
      }
    }

    /**
     * Reads a byte array.
     *
     * <p>
     *   <pre>
     *   b b16 b8 non-final binary chunk
     *   B b16 b8 final binary chunk
     *   </pre>
     * </p>
     *
     * @return A ByteArray with the bytes that were read.
     */
    public override function readBytes():ByteArray
    {
      var b:int;
      var tag:int = read();
      var buffer:ByteArray = null;

      switch (tag) {
        case 'N'.charCodeAt():
          return null;

        case 'B'.charCodeAt():
        case 'b'.charCodeAt():
          _isLastChunk = tag == 'B'.charCodeAt();
          _chunkLength = (read() << 8) + read();

          buffer = new ByteArray();

          while ((b = parseByte()) >= 0)
            buffer.writeByte(b);

          buffer.position = 0;

          return buffer;

        case 0x20: case 0x21: case 0x22: case 0x23:
        case 0x24: case 0x25: case 0x26: case 0x27:
        case 0x28: case 0x29: case 0x2a: case 0x2b:
        case 0x2c: case 0x2d: case 0x2e: case 0x2f:
          _isLastChunk = true;
          _chunkLength = tag - 0x20;

          buffer = new ByteArray();

          while ((b = parseByte()) >= 0)
            buffer.writeByte(b);

          buffer.position = 0;

          return buffer;

        default:
          throw expect("bytes", tag);
      }
    }

    /**
     * Reads a fault.
     *
     * @return The fault value read.
     */
    private function readFault():Object
    {
      var map:Object = new Object();

      var code:int = read();
      for (; code > 0 && code != 'z'.charCodeAt(); code = read()) {
        _offset--;

        var key:Object = readObject();
        var value:Object = readObject();

        if (key != null && value != null)
          map[key] = value;
      }

      if (code != 'z'.charCodeAt())
        throw expect("fault", code);

      return map;
    }

    /**
     * Reads an arbitrary object from the input stream.
     *
     * @param cl the expected class if the protocol doesn't supply it.
     *
     * @return The object value read.
     */
    public override function readObject(cl:Class = null):Object
    {
      if (cl == null || cl == Object)
        return readArbitraryObject();
      
      var tag:int = _offset < _length ? (_buffer[_offset++] & 0xff) : read();

      var ref:int;
      var type:String;
      var length:int;

      switch (tag) {
        case 'N'.charCodeAt():
          return null;

        case 'M'.charCodeAt():
          return readMap(cl);

        case 'O'.charCodeAt():
          {
            readObjectDefinition();

            return readObject(cl);
          }

        case 'o'.charCodeAt():
          {
            ref = readInt();

            var def:ObjectDefinition = _classDefs[ref] as ObjectDefinition;

            return readObjectInstance(def, cl);
          }

        case 'V'.charCodeAt():
          {
            type = readType();
            length = readLength();

            return readList(length, type, cl);
          }

        case 'v'.charCodeAt():
          {
            ref = readInt();
            type = _types[ref] as String;
            length = readInt();

            return readLengthList(length, type, cl);
          }

        case 'R'.charCodeAt():
          {
            return _refs[parseInteger()];
          }

        case Hessian2Constants.REF_BYTE: 
          {
            return _refs[read()];
          }

        case Hessian2Constants.REF_SHORT: 
          {
            ref = 256 * read() + read();

            return _refs[ref];
          }
      }

      if (tag >= 0)
        _offset--;

      // XXX?
      // hessian/3b2i vs hessian/3406
      // return readObject();

      return readArbitraryObject();
    }

    /**
     * Reads an arbitrary object from the input stream.
     *
     * @return The object value read.
     */
    private function readArbitraryObject():Object
    {
      var tag:int = _offset < _length ? (_buffer[_offset++] & 0xff) : read();

      var ch:int;
      var buffer:ByteArray;
      var type:String;
      var length:int;
      var ref:int;

      switch (tag) {
        case 'N'.charCodeAt():
          return null;

        case 'T'.charCodeAt():
          return true;

        case 'F'.charCodeAt():
          return false;

        // direct integer
        case 0x80: case 0x81: case 0x82: case 0x83:
        case 0x84: case 0x85: case 0x86: case 0x87:
        case 0x88: case 0x89: case 0x8a: case 0x8b:
        case 0x8c: case 0x8d: case 0x8e: case 0x8f:

        case 0x90: case 0x91: case 0x92: case 0x93:
        case 0x94: case 0x95: case 0x96: case 0x97:
        case 0x98: case 0x99: case 0x9a: case 0x9b:
        case 0x9c: case 0x9d: case 0x9e: case 0x9f:

        case 0xa0: case 0xa1: case 0xa2: case 0xa3:
        case 0xa4: case 0xa5: case 0xa6: case 0xa7:
        case 0xa8: case 0xa9: case 0xaa: case 0xab:
        case 0xac: case 0xad: case 0xae: case 0xaf:

        case 0xb0: case 0xb1: case 0xb2: case 0xb3:
        case 0xb4: case 0xb5: case 0xb6: case 0xb7:
        case 0xb8: case 0xb9: case 0xba: case 0xbb:
        case 0xbc: case 0xbd: case 0xbe: case 0xbf:
          return tag - Hessian2Constants.INT_ZERO;

        /* byte int */
        case 0xc0: case 0xc1: case 0xc2: case 0xc3:
        case 0xc4: case 0xc5: case 0xc6: case 0xc7:
        case 0xc8: case 0xc9: case 0xca: case 0xcb:
        case 0xcc: case 0xcd: case 0xce: case 0xcf:
          return ((tag - Hessian2Constants.INT_BYTE_ZERO) << 8) + read();

        /* short int */
        case 0xd0: case 0xd1: case 0xd2: case 0xd3:
        case 0xd4: case 0xd5: case 0xd6: case 0xd7:
          return ((tag - Hessian2Constants.INT_SHORT_ZERO) << 16) + 
                 256 * read() + read();

        case 'I'.charCodeAt():
          return parseInteger();

        // direct long
        case 0xd8: case 0xd9: case 0xda: case 0xdb:
        case 0xdc: case 0xdd: case 0xde: case 0xdf:

        case 0xe0: case 0xe1: case 0xe2: case 0xe3:
        case 0xe4: case 0xe5: case 0xe6: case 0xe7:
        case 0xe8: case 0xe9: case 0xea: case 0xeb:
        case 0xec: case 0xed: case 0xee: case 0xef:
          return tag - Hessian2Constants.LONG_ZERO;

        /* byte long */
        case 0xf0: case 0xf1: case 0xf2: case 0xf3:
        case 0xf4: case 0xf5: case 0xf6: case 0xf7:
        case 0xf8: case 0xf9: case 0xfa: case 0xfb:
        case 0xfc: case 0xfd: case 0xfe: case 0xff:
          return ((tag - Hessian2Constants.LONG_BYTE_ZERO) << 8) + read();

        /* short long */
        case 0x38: case 0x39: case 0x3a: case 0x3b:
        case 0x3c: case 0x3d: case 0x3e: case 0x3f:
          return ((tag - Hessian2Constants.LONG_SHORT_ZERO) << 16) + 
                 256 * read() + read();

        case Hessian2Constants.LONG_INT:
          return parseInteger();

        case 'L'.charCodeAt():
          return parseLong();

        case Hessian2Constants.DOUBLE_ZERO:
          return new Number(0);

        case Hessian2Constants.DOUBLE_ONE:
          return new Number(1);

        case Hessian2Constants.DOUBLE_BYTE:
          return new Number(read());

        case Hessian2Constants.DOUBLE_SHORT:
          return new Number(256 * read() + read());

        case Hessian2Constants.DOUBLE_FLOAT:
          {
            var f:int = parseInteger();

            return Float.intBitsToFloat(f);
          }

        case 'D'.charCodeAt():
          return parseDouble();

        case 'd'.charCodeAt():
          return new Date(parseLong());

        case 's'.charCodeAt():
        case 'S'.charCodeAt(): 
          {
            _isLastChunk = (tag == 'S'.charCodeAt());
            _chunkLength = (read() << 8) + read();

            _sbuf = "";

            while ((ch = parseChar()) >= 0)
              _sbuf += String.fromCharCode(ch);

            return _sbuf;
          }

        case 0x00: case 0x01: case 0x02: case 0x03:
        case 0x04: case 0x05: case 0x06: case 0x07:
        case 0x08: case 0x09: case 0x0a: case 0x0b:
        case 0x0c: case 0x0d: case 0x0e: case 0x0f:

        case 0x10: case 0x11: case 0x12: case 0x13:
        case 0x14: case 0x15: case 0x16: case 0x17:
        case 0x18: case 0x19: case 0x1a: case 0x1b:
        case 0x1c: case 0x1d: case 0x1e: case 0x1f:
          {
            _isLastChunk = true;
            _chunkLength = tag - 0x00;

            _sbuf = "";

            while ((ch = parseChar()) >= 0)
              _sbuf += String.fromCharCode(ch);

            return _sbuf;
          }

        case 'b'.charCodeAt():
        case 'B'.charCodeAt(): 
          {
            _isLastChunk = (tag == 'B'.charCodeAt());
            _chunkLength = (read() << 8) + read();

            buffer = new ByteArray();

            var b:int;

            while ((b = parseByte()) >= 0)
              buffer.writeByte(b);

            buffer.position = 0;

            return buffer;
          }

        case 0x20: case 0x21: case 0x22: case 0x23:
        case 0x24: case 0x25: case 0x26: case 0x27:
        case 0x28: case 0x29: case 0x2a: case 0x2b:
        case 0x2c: case 0x2d: case 0x2e: case 0x2f:
          {
            _isLastChunk = true;
            var len:int = tag - 0x20;
            _chunkLength = 0;

            buffer = new ByteArray();

            for (var i:int = 0; i < len; i++)
              buffer.writeByte(read());

            buffer.position = 0;

            return buffer;
          }

        case 'V'.charCodeAt(): 
          {
            type = readType();
            length = readLength();

            return readList(length, type);
          }

        // direct lists
        case 'v'.charCodeAt(): 
          {
            ref = readInt();
            type = _types[ref] as String;
            length = readInt();

            return readLengthList(length, type);
          }

        case 'M'.charCodeAt(): 
          return readMap();

        case 'O'.charCodeAt(): 
          {
            readObjectDefinition();

            return readObject();
          }

        case 'o'.charCodeAt(): 
          {
            ref = readInt();

            var def:ObjectDefinition = _classDefs[ref] as ObjectDefinition;

            return readObjectInstance(def);
          }

        case 'R'.charCodeAt(): 
          {
            return _refs[parseInteger()];
          }

        case Hessian2Constants.REF_BYTE: 
          {
            return _refs[read()];
          }

        case Hessian2Constants.REF_SHORT: 
          {
            ref = 256 * read() + read();

            return _refs[ref];
          }

        default:
          throw error("unknown code: 0x" + tag.toString(16) + " " + String.fromCharCode(tag));
      }
    }

    /**
     * Reads an object definition.
     *
     * <p>
     *   <pre>
     *   O type <int> (string)* <value>*
     *   </pre>
     * </p>
     */
    private function readObjectDefinition():void
    {
      var type:String = readString();
      var len:int = readInt();

      var fieldNames:Array = new Array();
      for (var i:int = 0; i < len; i++)
        fieldNames.push(readString());

      var def:ObjectDefinition = new ObjectDefinition(type, fieldNames);

      if (_classDefs == null)
        _classDefs = new Array();

      _classDefs.push(def);
    }

    /**
     * Reads an object instance.
     *
     * @param def The ObjectDefinition on which to base the read.
     * @param expectedClass A class to instantiate.
     *
     * @return The object instance as read.
     *
     */
    private function readObjectInstance(def:ObjectDefinition,
                                        expectedClass:Class = null):Object
    {
      var type:String = def.getType();
      var fieldNames:Array = def.getFieldNames();
      var value:Object = null;

      var cl:Class = getDefinitionByName(type) as Class;

      if (cl != null)
        value = new cl();

      else if (expectedClass != null)
        value = new expectedClass();

      else {
        value = new Object();

        if (type != null)
          value.hessianTypeName = type;
      }

      addRef(value);

      for each (var key:String in fieldNames)
        value[key] = readObject();

      return value;
    }

    private function readLenString(len:int = -1):String
    {
      if (len < 0)
        len = readInt();

      _isLastChunk = true;
      _chunkLength = len;

      _sbuf = "";

      var ch:int;

      while ((ch = parseChar()) >= 0)
        _sbuf += String.fromCharCode(ch);

      return _sbuf;
    }

    /**
     * Reads a reference.
     *
     * <p>
     *   <pre>
     *   R b32 b24 b16 b8
     *   </pre>
     * </p>
     * 
     * @return The object to which the read reference refers.
     */
    public override function readRef():Object
    {
      return _refs[parseInteger()];
    }

    /**
     * Reads the start of a list.
     */
    public override function readListStart():int
    {
      return read();
    }

    /**
     * Reads the start of a map.
     */
    public override function readMapStart():int
    {