コード例 #1
0
    public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
    {
        iprot.IncrementRecursionDepth();
        try
        {
            TField field;
            await iprot.ReadStructBeginAsync(cancellationToken);

            while (true)
            {
                field = await iprot.ReadFieldBeginAsync(cancellationToken);

                if (field.Type == TType.Stop)
                {
                    break;
                }

                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.Struct)
                    {
                        UpdatedChatMember = new SquareChatMember();
                        await UpdatedChatMember.ReadAsync(iprot, cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                default:
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);

                    break;
                }

                await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
            iprot.DecrementRecursionDepth();
        }
    }
コード例 #2
0
    public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
    {
        iprot.IncrementRecursionDepth();
        try
        {
            TField field;
            await iprot.ReadStructBeginAsync(cancellationToken);

            while (true)
            {
                field = await iprot.ReadFieldBeginAsync(cancellationToken);

                if (field.Type == TType.Stop)
                {
                    break;
                }

                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.List)
                    {
                        {
                            TList _list503 = await iprot.ReadListBeginAsync(cancellationToken);

                            Chats = new List <SquareChat>(_list503.Count);
                            for (int _i504 = 0; _i504 < _list503.Count; ++_i504)
                            {
                                SquareChat _elem505;
                                _elem505 = new SquareChat();
                                await _elem505.ReadAsync(iprot, cancellationToken);

                                Chats.Add(_elem505);
                            }
                            await iprot.ReadListEndAsync(cancellationToken);
                        }
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 2:
                    if (field.Type == TType.Map)
                    {
                        {
                            TMap _map506 = await iprot.ReadMapBeginAsync(cancellationToken);

                            ChatMembers = new Dictionary <string, SquareChatMember>(_map506.Count);
                            for (int _i507 = 0; _i507 < _map506.Count; ++_i507)
                            {
                                string           _key508;
                                SquareChatMember _val509;
                                _key508 = await iprot.ReadStringAsync(cancellationToken);

                                _val509 = new SquareChatMember();
                                await _val509.ReadAsync(iprot, cancellationToken);

                                ChatMembers[_key508] = _val509;
                            }
                            await iprot.ReadMapEndAsync(cancellationToken);
                        }
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 3:
                    if (field.Type == TType.Map)
                    {
                        {
                            TMap _map510 = await iprot.ReadMapBeginAsync(cancellationToken);

                            Statuses = new Dictionary <string, SquareChatStatus>(_map510.Count);
                            for (int _i511 = 0; _i511 < _map510.Count; ++_i511)
                            {
                                string           _key512;
                                SquareChatStatus _val513;
                                _key512 = await iprot.ReadStringAsync(cancellationToken);

                                _val513 = new SquareChatStatus();
                                await _val513.ReadAsync(iprot, cancellationToken);

                                Statuses[_key512] = _val513;
                            }
                            await iprot.ReadMapEndAsync(cancellationToken);
                        }
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 4:
                    if (field.Type == TType.String)
                    {
                        ContinuationToken = await iprot.ReadStringAsync(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                default:
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);

                    break;
                }

                await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
            iprot.DecrementRecursionDepth();
        }
    }
コード例 #3
0
    public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
    {
        iprot.IncrementRecursionDepth();
        try
        {
            TField field;
            await iprot.ReadStructBeginAsync(cancellationToken);

            while (true)
            {
                field = await iprot.ReadFieldBeginAsync(cancellationToken);

                if (field.Type == TType.Stop)
                {
                    break;
                }

                switch (field.ID)
                {
                case 2:
                    if (field.Type == TType.Set)
                    {
                        {
                            TSet _set479 = await iprot.ReadSetBeginAsync(cancellationToken);

                            UpdatedAttrs = new THashSet <SquareChatMemberAttribute>(_set479.Count);
                            for (int _i480 = 0; _i480 < _set479.Count; ++_i480)
                            {
                                SquareChatMemberAttribute _elem481;
                                _elem481 = (SquareChatMemberAttribute)await iprot.ReadI32Async(cancellationToken);

                                UpdatedAttrs.Add(_elem481);
                            }
                            await iprot.ReadSetEndAsync(cancellationToken);
                        }
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 3:
                    if (field.Type == TType.Struct)
                    {
                        ChatMember = new SquareChatMember();
                        await ChatMember.ReadAsync(iprot, cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                default:
                    await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);

                    break;
                }

                await iprot.ReadFieldEndAsync(cancellationToken);
            }

            await iprot.ReadStructEndAsync(cancellationToken);
        }
        finally
        {
            iprot.DecrementRecursionDepth();
        }
    }