t-code-generator/examples/Demo.js

A Taf protocol proxy/servant generator

const TModel = require('t-model')
const TRpc = require('t-rpc')
const TafProtocolClient = TRpc.protocols.taf.Client
const { RpcError, ClientDecodeError, ServerFuncNotFoundError } = TRpc.errors
const { ResponseMessage } = TRpc.messages

let { DemoStruct } = require('./DemoStruct.js').Demo

class DemoFProxy {
  static get Protocol () {
    return TafProtocolClient
  }
  constructor () {
    this._name = undefined
    this._objectProxy = undefined
  }
  setTimeout (value) {
    this._objectProxy.timeout = value
  }
  getTimeout () {
    return this._objectProxy.timeout
  }
  returnBoolMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TBool.read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnBoolMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnCharMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TInt8.read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnCharMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnShortMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TInt16.read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnShortMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnIntMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TInt32.read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnIntMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnLonglongMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TInt64.read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnLonglongMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnUCharMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TUInt8.read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnUCharMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnUShortMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TUInt16.read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnUShortMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnUIntMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TUInt32.read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnUIntMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnFloatMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TFloat.read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnFloatMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnDoubleMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TDouble.read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnDoubleMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnStringMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TString.read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnStringMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnStructMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = DemoStruct.read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnStructMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnBytesMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TBytes.read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnBytesMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnListMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TList(TModel.TUInt8).read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28, true)
        response.arguments.outUintArg = TModel.TUInt32.read(is, 29, true)
        response.arguments.outBytesArg = TModel.TBytes.read(is, 30, true)
        return { request: rpcResult.requestMessage, response }
      } catch (error) {
        let message = error.responseMessage ? error.responseMessage.message : error.message
        throw new ClientDecodeError(message, rpcResult.requestMessage, rpcResult.responseMessage, rpcResult.costTime, rpcResult.endpointInfo)
      }
    }
    let _error = rpcError => {
      let code = rpcError.responseMessage ? rpcError.responseMessage.code : -999
      let message = rpcError.responseMessage ? rpcError.responseMessage.message : rpcError.message
      throw new RpcError(code, message, rpcError.requestMessage, rpcError.responseMessage, rpcError.costTime, rpcError.endpointInfo)
    }
    return this._objectProxy.invoke('returnListMethod', _encode(), args.length > 0 ? args[0] : undefined).then(_decode, _error)
  }
  returnMapMethod (boolArg, intArg, stringArg, floatValue, doubleValue, vectorArg, mapArg, structArg, charArg, shortArg, longlongArg, ucharArg, ushortArg, uintArg, bytesArg, ...args) {
    let _encode = () => {
      let os = new TModel.TOutputStream()
      new (TModel.TBool)(boolArg).write(os, 1)
      new (TModel.TInt32)(intArg).write(os, 2)
      new (TModel.TString)(stringArg).write(os, 3)
      new (TModel.TFloat)(floatValue).write(os, 4)
      new (TModel.TDouble)(doubleValue).write(os, 5)
      new (TModel.TList(TModel.TInt32))(vectorArg).write(os, 6)
      new (TModel.TMap(TModel.TInt32, TModel.TString))(mapArg).write(os, 7)
      new (DemoStruct)(structArg).write(os, 8)
      new (TModel.TInt8)(charArg).write(os, 9)
      new (TModel.TInt16)(shortArg).write(os, 10)
      new (TModel.TInt64)(longlongArg).write(os, 11)
      new (TModel.TUInt8)(ucharArg).write(os, 12)
      new (TModel.TUInt16)(ushortArg).write(os, 13)
      new (TModel.TUInt32)(uintArg).write(os, 14)
      new (TModel.TBytes)(bytesArg).write(os, 15)
      return os.tBuffer.buffer
    }
    let _decode = rpcResult => {
      try {
        let response = { arguments: {} }
        let is = new TModel.TInputStream(new TModel.TBuffer(rpcResult.responseMessage.responsePacket.sBuffer))
        response.costtime = rpcResult.costTime
        response.return = TModel.TMap(TModel.TString, TModel.TInt16).read(is, 0, true)
        response.arguments.outBoolArg = TModel.TBool.read(is, 16, true)
        response.arguments.outIntArg = TModel.TInt32.read(is, 17, true)
        response.arguments.outStringArg = TModel.TString.read(is, 18, true)
        response.arguments.outFloatValue = TModel.TFloat.read(is, 19, true)
        response.arguments.outDoubleValue = TModel.TDouble.read(is, 20, true)
        response.arguments.outVectorArg = TModel.TList(TModel.TInt32).read(is, 21, true)
        response.arguments.outMapArg = TModel.TMap(TModel.TInt32, TModel.TString).read(is, 22, true)
        response.arguments.outStructArg = DemoStruct.read(is, 23, true)
        response.arguments.outCharArg = TModel.TInt8.read(is, 24, true)
        response.arguments.outShortArg = TModel.TInt16.read(is, 25, true)
        response.arguments.outLonglongArg = TModel.TInt64.read(is, 26, true)
        response.arguments.outUcharArg = TModel.TUInt8.read(is, 27, true)
        response.arguments.outUshortArg = TModel.TUInt16.read(is, 28