private void DeserializeV2OrV3(IByteBuffer buffer, TarsConvertOptions options, Response resp)
        {
            while (buffer.IsReadable())
            {
                headHandler.ReadHead(buffer, options);
                switch (options.Tag)
                {
                case 2:
                    resp.PacketType = byteConvert.Deserialize(buffer, options);
                    break;

                case 3:
                    resp.MessageType = intConvert.Deserialize(buffer, options);
                    break;

                case 4:
                    resp.RequestId = intConvert.Deserialize(buffer, options);
                    break;

                case 5:
                    resp.ServantName = stringConvert.Deserialize(buffer, options);
                    break;

                case 6:
                    resp.FuncName = stringConvert.Deserialize(buffer, options);
                    var(method, isOneway, outParameters, codec, version, serviceType) = rpcMetadata.FindRpcMethod(resp.ServantName, resp.FuncName);
                    resp.ReturnValueType      = method.ReturnParameter;
                    resp.ReturnParameterTypes = outParameters;
                    resp.ReturnParameters     = new object[outParameters.Length];
                    break;

                case 7 when options.Version == TarsCodecsVersion.V2:
                {
                    var uni = new UniAttributeV2(convertRoot, headHandler);
                    uni.Deserialize(buffer, options);
                    if (uni.Temp.ContainsKey(string.Empty))
                    {
                        var buf = uni.Temp[string.Empty].Values.First();
                        headHandler.ReadHead(buf, options);
                        resp.ReturnValue = convertRoot.Deserialize(buf, resp.ReturnValueType.ParameterType, options);
                    }
                    else if (resp.ReturnValueType.ParameterType == typeof(Task))
                    {
                        resp.ReturnValue = Task.CompletedTask;
                    }
                    for (int i = 0; i < resp.ReturnParameterTypes.Length; i++)
                    {
                        var pt  = resp.ReturnParameterTypes[i];
                        var buf = uni.Temp[pt.Name].Values.First();
                        headHandler.ReadHead(buf, options);
                        resp.ReturnParameters[i] = convertRoot.Deserialize(buf, pt.ParameterType, options);
                    }
                }
                break;

                case 7 when options.Version == TarsCodecsVersion.V3:
                {
                    var uni = new UniAttributeV3(convertRoot, headHandler);
                    uni.Deserialize(buffer, options);
                    if (uni.Temp.ContainsKey(string.Empty))
                    {
                        var buf = uni.Temp[string.Empty];
                        headHandler.ReadHead(buf, options);
                        resp.ReturnValue = convertRoot.Deserialize(buf, resp.ReturnValueType.ParameterType, options);
                    }
                    else if (resp.ReturnValueType.ParameterType == typeof(Task))
                    {
                        resp.ReturnValue = Task.CompletedTask;
                    }
                    for (int i = 0; i < resp.ReturnParameterTypes.Length; i++)
                    {
                        var pt  = resp.ReturnParameterTypes[i];
                        var buf = uni.Temp[pt.Name];
                        headHandler.ReadHead(buf, options);
                        resp.ReturnParameters[i] = convertRoot.Deserialize(buf, pt.ParameterType, options);
                    }
                }
                break;

                case 8:
                    resp.Timeout = intConvert.Deserialize(buffer, options);
                    break;

                case 9:
                    resp.Context = dictConvert.Deserialize(buffer, options);
                    break;

                case 10:
                    resp.Status = dictConvert.Deserialize(buffer, options);
                    break;
                }
            }
        }
Example #2
0
        public override Request Deserialize(IByteBuffer buffer, TarsConvertOptions options)
        {
            var req = new Request();
            var tag = options.Tag = 1;

            while (tag != 0 && buffer.IsReadable())
            {
                headHandler.ReadHead(buffer, options);
                tag = options.Tag;
                switch (tag)
                {
                case 1:
                    req.Version     = shortConvert.Deserialize(buffer, options);
                    options.Version = req.Version;
                    break;

                case 2:
                    req.PacketType = byteConvert.Deserialize(buffer, options);
                    break;

                case 3:
                    req.MessageType = intConvert.Deserialize(buffer, options);
                    break;

                case 4:
                    req.RequestId = intConvert.Deserialize(buffer, options);
                    break;

                case 5:
                    req.ServantName = stringConvert.Deserialize(buffer, options);
                    break;

                case 6:
                    req.FuncName = stringConvert.Deserialize(buffer, options);
                    var(method, isOneway, outParameters, codec, version, serviceType) = rpcMetadata.FindRpcMethod(req.ServantName, req.FuncName);
                    req.IsOneway             = isOneway;
                    req.Mehtod               = method;
                    req.ReturnParameterTypes = outParameters;
                    req.ServiceType          = serviceType;
                    req.ParameterTypes       = method.GetParameters();
                    break;

                case 7 when options.Version == TarsCodecsVersion.V1:
                {
                    var contentBuffer = bufferConvert.Deserialize(buffer, options);
                    req.Parameters = new object[req.ParameterTypes.Length];
                    while (contentBuffer.IsReadable())
                    {
                        headHandler.ReadHead(contentBuffer, options);
                        var index = options.Tag - 1;
                        var type  = req.ParameterTypes[index];
                        req.Parameters[index] = convertRoot.Deserialize(contentBuffer, type.ParameterType, options);
                    }
                }
                break;

                case 7 when options.Version == TarsCodecsVersion.V2:
                {
                    var uni = new UniAttributeV2(convertRoot, headHandler);
                    uni.Deserialize(buffer, options);
                    req.Parameters = new object[req.ParameterTypes.Length];
                    foreach (var pt in req.ParameterTypes)
                    {
                        var pBuffer = uni.Temp[pt.Name].Values.First();
                        headHandler.ReadHead(pBuffer, options);
                        req.Parameters[pt.Position] = convertRoot.Deserialize(pBuffer, pt.ParameterType, options);
                    }
                }
                break;

                case 7 when options.Version == TarsCodecsVersion.V3:
                {
                    var uni = new UniAttributeV3(convertRoot, headHandler);
                    uni.Deserialize(buffer, options);
                    req.Parameters = new object[req.ParameterTypes.Length];
                    foreach (var pt in req.ParameterTypes)
                    {
                        var pBuffer = uni.Temp[pt.Name];
                        headHandler.ReadHead(pBuffer, options);
                        req.Parameters[pt.Position] = convertRoot.Deserialize(pBuffer, pt.ParameterType, options);
                    }
                }
                break;

                case 8:
                    req.Timeout = intConvert.Deserialize(buffer, options);
                    break;

                case 9:
                    req.Context = dictConvert.Deserialize(buffer, options);
                    break;

                case 10:
                    req.Status = dictConvert.Deserialize(buffer, options);
                    tag        = 0;
                    break;

                default:
                    break;
                }
            }
            return(req);
        }