Ejemplo n.º 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.List)
                            {
                                {
                                    TList _list24 = await iprot.ReadListBeginAsync(cancellationToken);

                                    Batches = new List <Batch>(_list24.Count);
                                    for (int _i25 = 0; _i25 < _list24.Count; ++_i25)
                                    {
                                        Batch _elem26;
                                        _elem26 = new Batch();
                                        await _elem26.ReadAsync(iprot, cancellationToken);

                                        Batches.Add(_elem26);
                                    }
                                    await iprot.ReadListEndAsync(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();
                }
            }
Ejemplo n.º 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 _list499 = await iprot.ReadListBeginAsync(cancellationToken);

                            Announcements = new List <SquareChatAnnouncement>(_list499.Count);
                            for (int _i500 = 0; _i500 < _list499.Count; ++_i500)
                            {
                                SquareChatAnnouncement _elem501;
                                _elem501 = new SquareChatAnnouncement();
                                await _elem501.ReadAsync(iprot, cancellationToken);

                                Announcements.Add(_elem501);
                            }
                            await iprot.ReadListEndAsync(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();
        }
    }
Ejemplo n.º 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 1:
                            if (field.Type == TType.List)
                            {
                                {
                                    Spans = new List <Jaeger.Thrift.Agent.Zipkin.Span>();
                                    TList _list0 = await iprot.ReadListBeginAsync(cancellationToken);

                                    for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
                                    {
                                        Jaeger.Thrift.Agent.Zipkin.Span _elem2;
                                        _elem2 = new Jaeger.Thrift.Agent.Zipkin.Span();
                                        await _elem2.ReadAsync(iprot, cancellationToken);

                                        Spans.Add(_elem2);
                                    }
                                    await iprot.ReadListEndAsync(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();
                }
            }
Ejemplo n.º 4
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)
                    {
                        {
                            SpotItems = new List <SpotItem>();
                            TList _list12 = await iprot.ReadListBeginAsync(cancellationToken);

                            for (int _i13 = 0; _i13 < _list12.Count; ++_i13)
                            {
                                SpotItem _elem14;
                                _elem14 = new SpotItem();
                                await _elem14.ReadAsync(iprot, cancellationToken);

                                SpotItems.Add(_elem14);
                            }
                            await iprot.ReadListEndAsync(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();
        }
    }
                public async global::System.Threading.Tasks.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 0:
                                if (field.Type == TType.List)
                                {
                                    {
                                        TList _list47 = await iprot.ReadListBeginAsync(cancellationToken);

                                        Success = new List <global::Jaeger.Thrift.BatchSubmitResponse>(_list47.Count);
                                        for (int _i48 = 0; _i48 < _list47.Count; ++_i48)
                                        {
                                            global::Jaeger.Thrift.BatchSubmitResponse _elem49;
                                            _elem49 = new global::Jaeger.Thrift.BatchSubmitResponse();
                                            await _elem49.ReadAsync(iprot, cancellationToken);

                                            Success.Add(_elem49);
                                        }
                                        await iprot.ReadListEndAsync(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();
                    }
                }
Ejemplo n.º 6
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 _list378 = await iprot.ReadListBeginAsync(cancellationToken);

                            CategoryList = new List <Category>(_list378.Count);
                            for (int _i379 = 0; _i379 < _list378.Count; ++_i379)
                            {
                                Category _elem380;
                                _elem380 = new Category();
                                await _elem380.ReadAsync(iprot, cancellationToken);

                                CategoryList.Add(_elem380);
                            }
                            await iprot.ReadListEndAsync(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();
        }
    }
Ejemplo n.º 7
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 0:
                            if (field.Type == TType.List)
                            {
                                {
                                    TList _list0 = await iprot.ReadListBeginAsync(cancellationToken);

                                    Success = new List <BaggageRestriction>(_list0.Count);
                                    for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
                                    {
                                        BaggageRestriction _elem2;
                                        _elem2 = new BaggageRestriction();
                                        await _elem2.ReadAsync(iprot, cancellationToken);

                                        Success.Add(_elem2);
                                    }
                                    await iprot.ReadListEndAsync(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();
                }
            }
Ejemplo n.º 8
0
        public async global::System.Threading.Tasks.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 _list174 = await iprot.ReadListBeginAsync(cancellationToken);

                                Bonk = new List <global::ThriftTest.Bonk>(_list174.Count);
                                for (int _i175 = 0; _i175 < _list174.Count; ++_i175)
                                {
                                    global::ThriftTest.Bonk _elem176;
                                    _elem176 = new global::ThriftTest.Bonk();
                                    await _elem176.ReadAsync(iprot, cancellationToken);

                                    Bonk.Add(_elem176);
                                }
                                await iprot.ReadListEndAsync(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();
            }
        }
Ejemplo n.º 9
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 0:
                            if (field.Type == TType.List)
                            {
                                {
                                    Success = new List <BatchSubmitResponse>();
                                    TList _list28 = await iprot.ReadListBeginAsync(cancellationToken);

                                    for (int _i29 = 0; _i29 < _list28.Count; ++_i29)
                                    {
                                        BatchSubmitResponse _elem30;
                                        _elem30 = new BatchSubmitResponse();
                                        await _elem30.ReadAsync(iprot, cancellationToken);

                                        Success.Add(_elem30);
                                    }
                                    await iprot.ReadListEndAsync(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();
                }
            }
                public async global::System.Threading.Tasks.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 0:
                                if (field.Type == TType.List)
                                {
                                    {
                                        TList _list13 = await iprot.ReadListBeginAsync(cancellationToken);

                                        Success = new List <global::PElementServer.Thrift.PElement>(_list13.Count);
                                        for (int _i14 = 0; _i14 < _list13.Count; ++_i14)
                                        {
                                            global::PElementServer.Thrift.PElement _elem15;
                                            _elem15 = new global::PElementServer.Thrift.PElement();
                                            await _elem15.ReadAsync(iprot, cancellationToken);

                                            Success.Add(_elem15);
                                        }
                                        await iprot.ReadListEndAsync(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();
                    }
                }
Ejemplo n.º 11
0
                public async global::System.Threading.Tasks.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 _list1 = await iprot.ReadListBeginAsync(cancellationToken);

                                        Spans = new List <global::Jaeger.Thrift.Agent.Zipkin.Span>(_list1.Count);
                                        for (int _i2 = 0; _i2 < _list1.Count; ++_i2)
                                        {
                                            global::Jaeger.Thrift.Agent.Zipkin.Span _elem3;
                                            _elem3 = new global::Jaeger.Thrift.Agent.Zipkin.Span();
                                            await _elem3.ReadAsync(iprot, cancellationToken);

                                            Spans.Add(_elem3);
                                        }
                                        await iprot.ReadListEndAsync(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();
                    }
                }
    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.List)
                    {
                        {
                            TList _list458 = await iprot.ReadListBeginAsync(cancellationToken);

                            Unsubscriptions = new List <long>(_list458.Count);
                            for (int _i459 = 0; _i459 < _list458.Count; ++_i459)
                            {
                                long _elem460;
                                _elem460 = await iprot.ReadI64Async(cancellationToken);

                                Unsubscriptions.Add(_elem460);
                            }
                            await iprot.ReadListEndAsync(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();
        }
    }
Ejemplo n.º 13
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)
                    {
                        {
                            Labels = new List <string>();
                            TList _list4 = await iprot.ReadListBeginAsync(cancellationToken);

                            for (int _i5 = 0; _i5 < _list4.Count; ++_i5)
                            {
                                string _elem6;
                                _elem6 = await iprot.ReadStringAsync(cancellationToken);

                                Labels.Add(_elem6);
                            }
                            await iprot.ReadListEndAsync(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();
        }
    }
Ejemplo n.º 14
0
        public async Task ReadAsync(TProtocol protocol, CancellationToken cancellationToken)
        {
            bool   isset_types = false;
            TField field;
            await protocol.ReadStructBeginAsync(cancellationToken);

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

                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.List)
                    {
                        {
                            Types = new List <TypeEntry>();
                            TList _list15 = await protocol.ReadListBeginAsync(cancellationToken);

                            for (int _i16 = 0; _i16 < _list15.Count; ++_i16)
                            {
                                TypeEntry _elem17 = new TypeEntry();
                                _elem17 = new TypeEntry();
                                await _elem17.ReadAsync(protocol, cancellationToken);

                                Types.Add(_elem17);
                            }
                            await protocol.ReadListEndAsync(cancellationToken);
                        }
                        isset_types = true;
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(protocol, field.Type, cancellationToken);
                    }
                    break;

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

                    break;
                }
                await protocol.ReadFieldEndAsync(cancellationToken);
            }
            await protocol.ReadStructEndAsync(cancellationToken);

            if (!isset_types)
            {
                throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
        }
Ejemplo n.º 15
0
        public async Task ReadAsync(TProtocol protocol, CancellationToken cancellationToken)
        {
            bool   isset_colVals = false;
            TField field;
            await protocol.ReadStructBeginAsync(cancellationToken);

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

                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.List)
                    {
                        {
                            ColVals = new List <ColumnValue>();
                            TList _list23 = await protocol.ReadListBeginAsync(cancellationToken);

                            for (int _i24 = 0; _i24 < _list23.Count; ++_i24)
                            {
                                ColumnValue _elem25 = new ColumnValue();
                                _elem25 = new ColumnValue();
                                await _elem25.ReadAsync(protocol, cancellationToken);

                                ColVals.Add(_elem25);
                            }
                            await protocol.ReadListEndAsync(cancellationToken);
                        }
                        isset_colVals = true;
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(protocol, field.Type, cancellationToken);
                    }
                    break;

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

                    break;
                }
                await protocol.ReadFieldEndAsync(cancellationToken);
            }
            await protocol.ReadStructEndAsync(cancellationToken);

            if (!isset_colVals)
            {
                throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
        }
Ejemplo n.º 16
0
        public async Task ReadAsync(TProtocol protocol, CancellationToken cancellationToken)
        {
            bool   isset_columns = false;
            TField field;
            await protocol.ReadStructBeginAsync(cancellationToken);

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

                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.List)
                    {
                        {
                            Columns = new List <ColumnDesc>();
                            TList list = await protocol.ReadListBeginAsync(cancellationToken);

                            for (int i = 0; i < list.Count; ++i)
                            {
                                ColumnDesc desc = new ColumnDesc();
                                await desc.ReadAsync(protocol, cancellationToken);

                                Columns.Add(desc);
                            }
                            await protocol.ReadListEndAsync(cancellationToken);
                        }
                        isset_columns = true;
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(protocol, field.Type, cancellationToken);
                    }
                    break;

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

                    break;
                }
                await protocol.ReadFieldEndAsync(cancellationToken);
            }
            await protocol.ReadStructEndAsync(cancellationToken);

            if (!isset_columns)
            {
                throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
        }
Ejemplo n.º 17
0
    public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
    {
        iprot.IncrementRecursionDepth();
        try
        {
            bool   isset_row       = false;
            bool   isset_mutations = false;
            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.String)
                    {
                        Row = await iprot.ReadBinaryAsync(cancellationToken);

                        isset_row = true;
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 2:
                    if (field.Type == TType.List)
                    {
                        {
                            Mutations = new List <TMutation>();
                            TList _list62 = await iprot.ReadListBeginAsync(cancellationToken);

                            for (int _i63 = 0; _i63 < _list62.Count; ++_i63)
                            {
                                TMutation _elem64;
                                _elem64 = new TMutation();
                                await _elem64.ReadAsync(iprot, cancellationToken);

                                Mutations.Add(_elem64);
                            }
                            await iprot.ReadListEndAsync(cancellationToken);
                        }
                        isset_mutations = true;
                    }
                    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);

            if (!isset_row)
            {
                throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_mutations)
            {
                throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
        }
        finally
        {
            iprot.DecrementRecursionDepth();
        }
    }
Ejemplo n.º 18
0
    public async global::System.Threading.Tasks.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 _list29 = await iprot.ReadListBeginAsync(cancellationToken);

                            Names = new List <SchemaPattern>(_list29.Count);
                            for (int _i30 = 0; _i30 < _list29.Count; ++_i30)
                            {
                                SchemaPattern _elem31;
                                _elem31 = new SchemaPattern();
                                await _elem31.ReadAsync(iprot, cancellationToken);

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

                case 2:
                    if (field.Type == TType.Struct)
                    {
                        Tags = new SchemaTagsPatterns();
                        await Tags.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();
        }
    }
        public async global::System.Threading.Tasks.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.I32)
                        {
                            Value = await iprot.ReadI32Async(cancellationToken);
                        }
                        else
                        {
                            await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.Bool)
                        {
                            Success = await iprot.ReadBoolAsync(cancellationToken);
                        }
                        else
                        {
                            await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.List)
                        {
                            {
                                TList _list3 = await iprot.ReadListBeginAsync(cancellationToken);

                                Results = new List <global::APIGateway.Thrift.Generated.BaseTypes.Result>(_list3.Count);
                                for (int _i4 = 0; _i4 < _list3.Count; ++_i4)
                                {
                                    global::APIGateway.Thrift.Generated.BaseTypes.Result _elem5;
                                    _elem5 = new global::APIGateway.Thrift.Generated.BaseTypes.Result();
                                    await _elem5.ReadAsync(iprot, cancellationToken);

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

                    case 4:
                        if (field.Type == TType.Struct)
                        {
                            ResponseBase = new global::APIGateway.Thrift.Generated.BaseTypes.ResponseBase();
                            await ResponseBase.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();
            }
        }
Ejemplo n.º 20
0
        public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                bool   isset_sessionId        = false;
                bool   isset_deviceIds        = false;
                bool   isset_measurementsList = false;
                bool   isset_valuesList       = false;
                bool   isset_timestamps       = false;
                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.I64)
                        {
                            SessionId = await iprot.ReadI64Async(cancellationToken);

                            isset_sessionId = true;
                        }
                        else
                        {
                            await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.List)
                        {
                            {
                                TList _list87 = await iprot.ReadListBeginAsync(cancellationToken);

                                DeviceIds = new List <string>(_list87.Count);
                                for (int _i88 = 0; _i88 < _list87.Count; ++_i88)
                                {
                                    string _elem89;
                                    _elem89 = await iprot.ReadStringAsync(cancellationToken);

                                    DeviceIds.Add(_elem89);
                                }
                                await iprot.ReadListEndAsync(cancellationToken);
                            }
                            isset_deviceIds = true;
                        }
                        else
                        {
                            await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.List)
                        {
                            {
                                TList _list90 = await iprot.ReadListBeginAsync(cancellationToken);

                                MeasurementsList = new List <List <string> >(_list90.Count);
                                for (int _i91 = 0; _i91 < _list90.Count; ++_i91)
                                {
                                    List <string> _elem92;
                                    {
                                        TList _list93 = await iprot.ReadListBeginAsync(cancellationToken);

                                        _elem92 = new List <string>(_list93.Count);
                                        for (int _i94 = 0; _i94 < _list93.Count; ++_i94)
                                        {
                                            string _elem95;
                                            _elem95 = await iprot.ReadStringAsync(cancellationToken);

                                            _elem92.Add(_elem95);
                                        }
                                        await iprot.ReadListEndAsync(cancellationToken);
                                    }
                                    MeasurementsList.Add(_elem92);
                                }
                                await iprot.ReadListEndAsync(cancellationToken);
                            }
                            isset_measurementsList = true;
                        }
                        else
                        {
                            await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.List)
                        {
                            {
                                TList _list96 = await iprot.ReadListBeginAsync(cancellationToken);

                                ValuesList = new List <byte[]>(_list96.Count);
                                for (int _i97 = 0; _i97 < _list96.Count; ++_i97)
                                {
                                    byte[] _elem98;
                                    _elem98 = await iprot.ReadBinaryAsync(cancellationToken);

                                    ValuesList.Add(_elem98);
                                }
                                await iprot.ReadListEndAsync(cancellationToken);
                            }
                            isset_valuesList = true;
                        }
                        else
                        {
                            await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.List)
                        {
                            {
                                TList _list99 = await iprot.ReadListBeginAsync(cancellationToken);

                                Timestamps = new List <long>(_list99.Count);
                                for (int _i100 = 0; _i100 < _list99.Count; ++_i100)
                                {
                                    long _elem101;
                                    _elem101 = await iprot.ReadI64Async(cancellationToken);

                                    Timestamps.Add(_elem101);
                                }
                                await iprot.ReadListEndAsync(cancellationToken);
                            }
                            isset_timestamps = true;
                        }
                        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);

                if (!isset_sessionId)
                {
                    throw new TProtocolException(TProtocolException.INVALID_DATA);
                }
                if (!isset_deviceIds)
                {
                    throw new TProtocolException(TProtocolException.INVALID_DATA);
                }
                if (!isset_measurementsList)
                {
                    throw new TProtocolException(TProtocolException.INVALID_DATA);
                }
                if (!isset_valuesList)
                {
                    throw new TProtocolException(TProtocolException.INVALID_DATA);
                }
                if (!isset_timestamps)
                {
                    throw new TProtocolException(TProtocolException.INVALID_DATA);
                }
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
    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 _list209 = await iprot.ReadListBeginAsync(cancellationToken);

                            Users = new List <Contact>(_list209.Count);
                            for (int _i210 = 0; _i210 < _list209.Count; ++_i210)
                            {
                                Contact _elem211;
                                _elem211 = new Contact();
                                await _elem211.ReadAsync(iprot, cancellationToken);

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

                case 2:
                    if (field.Type == TType.List)
                    {
                        {
                            TList _list212 = await iprot.ReadListBeginAsync(cancellationToken);

                            Buddies = new List <Contact>(_list212.Count);
                            for (int _i213 = 0; _i213 < _list212.Count; ++_i213)
                            {
                                Contact _elem214;
                                _elem214 = new Contact();
                                await _elem214.ReadAsync(iprot, cancellationToken);

                                Buddies.Add(_elem214);
                            }
                            await iprot.ReadListEndAsync(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();
        }
    }
Ejemplo n.º 22
0
    public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
    {
        iprot.IncrementRecursionDepth();
        try
        {
            bool   isset_success = false;
            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.Bool)
                    {
                        Success = await iprot.ReadBoolAsync(cancellationToken);

                        isset_success = true;
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

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

                case 3:
                    if (field.Type == TType.List)
                    {
                        {
                            Readaccess = new List <string>();
                            TList _list13 = await iprot.ReadListBeginAsync(cancellationToken);

                            for (int _i14 = 0; _i14 < _list13.Count; ++_i14)
                            {
                                string _elem15;
                                _elem15 = await iprot.ReadStringAsync(cancellationToken);

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

                case 4:
                    if (field.Type == TType.List)
                    {
                        {
                            Writeaccess = new List <string>();
                            TList _list16 = await iprot.ReadListBeginAsync(cancellationToken);

                            for (int _i17 = 0; _i17 < _list16.Count; ++_i17)
                            {
                                string _elem18;
                                _elem18 = await iprot.ReadStringAsync(cancellationToken);

                                Writeaccess.Add(_elem18);
                            }
                            await iprot.ReadListEndAsync(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);

            if (!isset_success)
            {
                throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
        }
        finally
        {
            iprot.DecrementRecursionDepth();
        }
    }
Ejemplo n.º 23
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.String)
                    {
                        _from = await iprot.ReadStringAsync(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

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

                case 3:
                    if (field.Type == TType.I32)
                    {
                        ToType = (MIDType)await iprot.ReadI32Async(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

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

                case 5:
                    if (field.Type == TType.I64)
                    {
                        CreatedTime = await iprot.ReadI64Async(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 6:
                    if (field.Type == TType.I64)
                    {
                        DeliveredTime = await iprot.ReadI64Async(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

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

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

                case 14:
                    if (field.Type == TType.Bool)
                    {
                        HasContent = await iprot.ReadBoolAsync(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 15:
                    if (field.Type == TType.I32)
                    {
                        ContentType = (ContentType)await iprot.ReadI32Async(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 17:
                    if (field.Type == TType.String)
                    {
                        ContentPreview = await iprot.ReadBinaryAsync(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

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

                            ContentMetadata = new Dictionary <string, string>(_map157.Count);
                            for (int _i158 = 0; _i158 < _map157.Count; ++_i158)
                            {
                                string _key159;
                                string _val160;
                                _key159 = await iprot.ReadStringAsync(cancellationToken);

                                _val160 = await iprot.ReadStringAsync(cancellationToken);

                                ContentMetadata[_key159] = _val160;
                            }
                            await iprot.ReadMapEndAsync(cancellationToken);
                        }
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 19:
                    if (field.Type == TType.Byte)
                    {
                        SessionId = await iprot.ReadByteAsync(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 20:
                    if (field.Type == TType.List)
                    {
                        {
                            TList _list161 = await iprot.ReadListBeginAsync(cancellationToken);

                            Chunks = new List <byte[]>(_list161.Count);
                            for (int _i162 = 0; _i162 < _list161.Count; ++_i162)
                            {
                                byte[] _elem163;
                                _elem163 = await iprot.ReadBinaryAsync(cancellationToken);

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

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

                case 22:
                    if (field.Type == TType.I32)
                    {
                        MessageRelationType = (MessageRelationType)await iprot.ReadI32Async(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 23:
                    if (field.Type == TType.I64)
                    {
                        ReadCount = await iprot.ReadI64Async(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 24:
                    if (field.Type == TType.I32)
                    {
                        RelatedMessageServiceCode = (ServiceCode)await iprot.ReadI32Async(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();
        }
    }
Ejemplo n.º 24
0
        public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                bool   isset_links = false;
                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 _list3 = await iprot.ReadListBeginAsync(cancellationToken);

                                Links = new List <global::Jaeger.Thrift.Agent.DependencyLink>(_list3.Count);
                                for (int _i4 = 0; _i4 < _list3.Count; ++_i4)
                                {
                                    global::Jaeger.Thrift.Agent.DependencyLink _elem5;
                                    _elem5 = new global::Jaeger.Thrift.Agent.DependencyLink();
                                    await _elem5.ReadAsync(iprot, cancellationToken);

                                    Links.Add(_elem5);
                                }
                                await iprot.ReadListEndAsync(cancellationToken);
                            }
                            isset_links = true;
                        }
                        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);

                if (!isset_links)
                {
                    throw new TProtocolException(TProtocolException.INVALID_DATA);
                }
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 25
0
        public async global::System.Threading.Tasks.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 _list39 = await iprot.ReadListBeginAsync(cancellationToken);

                                Column_names = new List <byte[]>(_list39.Count);
                                for (int _i40 = 0; _i40 < _list39.Count; ++_i40)
                                {
                                    byte[] _elem41;
                                    _elem41 = await iprot.ReadBinaryAsync(cancellationToken);

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

                    case 2:
                        if (field.Type == TType.Struct)
                        {
                            Slice_range = new global::Apache.Cassandra.Test.SliceRange();
                            await Slice_range.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();
            }
        }
Ejemplo n.º 26
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 _list20 = await iprot.ReadListBeginAsync(cancellationToken);

                            CurrencyExchangeRates = new List <PaidCallCurrencyExchangeRate>(_list20.Count);
                            for (int _i21 = 0; _i21 < _list20.Count; ++_i21)
                            {
                                PaidCallCurrencyExchangeRate _elem22;
                                _elem22 = new PaidCallCurrencyExchangeRate();
                                await _elem22.ReadAsync(iprot, cancellationToken);

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

                case 2:
                    if (field.Type == TType.List)
                    {
                        {
                            TList _list23 = await iprot.ReadListBeginAsync(cancellationToken);

                            RecommendedCountryCodes = new List <string>(_list23.Count);
                            for (int _i24 = 0; _i24 < _list23.Count; ++_i24)
                            {
                                string _elem25;
                                _elem25 = await iprot.ReadStringAsync(cancellationToken);

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

                case 3:
                    if (field.Type == TType.List)
                    {
                        {
                            TList _list26 = await iprot.ReadListBeginAsync(cancellationToken);

                            AdCountries = new List <PaidCallAdCountry>(_list26.Count);
                            for (int _i27 = 0; _i27 < _list26.Count; ++_i27)
                            {
                                PaidCallAdCountry _elem28;
                                _elem28 = new PaidCallAdCountry();
                                await _elem28.ReadAsync(iprot, cancellationToken);

                                AdCountries.Add(_elem28);
                            }
                            await iprot.ReadListEndAsync(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();
        }
    }
Ejemplo n.º 27
0
        public static async Task SkipAsync(TProtocol protocol, TType type, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            protocol.IncrementRecursionDepth();
            try
            {
                switch (type)
                {
                case TType.Bool:
                    await protocol.ReadBoolAsync(cancellationToken);

                    break;

                case TType.Byte:
                    await protocol.ReadByteAsync(cancellationToken);

                    break;

                case TType.I16:
                    await protocol.ReadI16Async(cancellationToken);

                    break;

                case TType.I32:
                    await protocol.ReadI32Async(cancellationToken);

                    break;

                case TType.I64:
                    await protocol.ReadI64Async(cancellationToken);

                    break;

                case TType.Double:
                    await protocol.ReadDoubleAsync(cancellationToken);

                    break;

                case TType.String:
                    // Don't try to decode the string, just skip it.
                    await protocol.ReadBinaryAsync(cancellationToken);

                    break;

                case TType.Struct:
                    await protocol.ReadStructBeginAsync(cancellationToken);

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

                        if (field.Type == TType.Stop)
                        {
                            break;
                        }
                        await SkipAsync(protocol, field.Type, cancellationToken);

                        await protocol.ReadFieldEndAsync(cancellationToken);
                    }
                    await protocol.ReadStructEndAsync(cancellationToken);

                    break;

                case TType.Map:
                    var map = await protocol.ReadMapBeginAsync(cancellationToken);

                    for (var i = 0; i < map.Count; i++)
                    {
                        await SkipAsync(protocol, map.KeyType, cancellationToken);
                        await SkipAsync(protocol, map.ValueType, cancellationToken);
                    }
                    await protocol.ReadMapEndAsync(cancellationToken);

                    break;

                case TType.Set:
                    var set = await protocol.ReadSetBeginAsync(cancellationToken);

                    for (var i = 0; i < set.Count; i++)
                    {
                        await SkipAsync(protocol, set.ElementType, cancellationToken);
                    }
                    await protocol.ReadSetEndAsync(cancellationToken);

                    break;

                case TType.List:
                    var list = await protocol.ReadListBeginAsync(cancellationToken);

                    for (var i = 0; i < list.Count; i++)
                    {
                        await SkipAsync(protocol, list.ElementType, cancellationToken);
                    }
                    await protocol.ReadListEndAsync(cancellationToken);

                    break;

                default:
                    throw new TProtocolException(TProtocolException.INVALID_DATA, "Unknown data type " + type.ToString("d"));
                }
            }
            finally
            {
                protocol.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 28
0
        public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                bool   isset_page_locations = false;
                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)
                        {
                            {
                                Page_locations = new List <PageLocation>();
                                TList _list24 = await iprot.ReadListBeginAsync(cancellationToken);

                                for (int _i25 = 0; _i25 < _list24.Count; ++_i25)
                                {
                                    PageLocation _elem26;
                                    _elem26 = new PageLocation();
                                    await _elem26.ReadAsync(iprot, cancellationToken);

                                    Page_locations.Add(_elem26);
                                }
                                await iprot.ReadListEndAsync(cancellationToken);
                            }
                            isset_page_locations = true;
                        }
                        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);

                if (!isset_page_locations)
                {
                    throw new TProtocolException(TProtocolException.INVALID_DATA);
                }
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 29
0
    public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
    {
        iprot.IncrementRecursionDepth();
        try
        {
            bool   isset_row = false;
            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.String)
                    {
                        Row = await iprot.ReadBinaryAsync(cancellationToken);

                        isset_row = true;
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 2:
                    if (field.Type == TType.List)
                    {
                        {
                            Columns = new List <TColumn>();
                            TList _list8 = await iprot.ReadListBeginAsync(cancellationToken);

                            for (int _i9 = 0; _i9 < _list8.Count; ++_i9)
                            {
                                TColumn _elem10;
                                _elem10 = new TColumn();
                                await _elem10.ReadAsync(iprot, cancellationToken);

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

                case 3:
                    if (field.Type == TType.I64)
                    {
                        Timestamp = await iprot.ReadI64Async(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

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

                case 5:
                    if (field.Type == TType.I32)
                    {
                        MaxVersions = await iprot.ReadI32Async(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 6:
                    if (field.Type == TType.String)
                    {
                        FilterString = await iprot.ReadBinaryAsync(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 7:
                    if (field.Type == TType.Map)
                    {
                        {
                            Attributes = new Dictionary <byte[], byte[]>();
                            TMap _map11 = await iprot.ReadMapBeginAsync(cancellationToken);

                            for (int _i12 = 0; _i12 < _map11.Count; ++_i12)
                            {
                                byte[] _key13;
                                byte[] _val14;
                                _key13 = await iprot.ReadBinaryAsync(cancellationToken);

                                _val14 = await iprot.ReadBinaryAsync(cancellationToken);

                                Attributes[_key13] = _val14;
                            }
                            await iprot.ReadMapEndAsync(cancellationToken);
                        }
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 8:
                    if (field.Type == TType.Struct)
                    {
                        Authorizations = new TAuthorization();
                        await Authorizations.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);

            if (!isset_row)
            {
                throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
        }
        finally
        {
            iprot.DecrementRecursionDepth();
        }
    }
    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)
                    {
                        {
                            SquareChats = new List <SquareChat>();
                            TList _list320 = await iprot.ReadListBeginAsync(cancellationToken);

                            for (int _i321 = 0; _i321 < _list320.Count; ++_i321)
                            {
                                SquareChat _elem322;
                                _elem322 = new SquareChat();
                                await _elem322.ReadAsync(iprot, cancellationToken);

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

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

                case 3:
                    if (field.Type == TType.I32)
                    {
                        TotalSquareChatCount = await iprot.ReadI32Async(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

                case 4:
                    if (field.Type == TType.Map)
                    {
                        {
                            SquareChatStatuses = new Dictionary <string, SquareChatStatus>();
                            TMap _map323 = await iprot.ReadMapBeginAsync(cancellationToken);

                            for (int _i324 = 0; _i324 < _map323.Count; ++_i324)
                            {
                                string           _key325;
                                SquareChatStatus _val326;
                                _key325 = await iprot.ReadStringAsync(cancellationToken);

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

                                SquareChatStatuses[_key325] = _val326;
                            }
                            await iprot.ReadMapEndAsync(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();
        }
    }
Ejemplo n.º 31
0
        public static async Task SkipAsync(TProtocol prot, TType type, CancellationToken cancellationToken)
        {
            if (cancellationToken.IsCancellationRequested)
            {
                await Task.FromCanceled(cancellationToken);
            }

            prot.IncrementRecursionDepth();
            try
            {
                switch (type)
                {
                    case TType.Bool:
                        await prot.ReadBoolAsync(cancellationToken);
                        break;
                    case TType.Byte:
                        await prot.ReadByteAsync(cancellationToken);
                        break;
                    case TType.I16:
                        await prot.ReadI16Async(cancellationToken);
                        break;
                    case TType.I32:
                        await prot.ReadI32Async(cancellationToken);
                        break;
                    case TType.I64:
                        await prot.ReadI64Async(cancellationToken);
                        break;
                    case TType.Double:
                        await prot.ReadDoubleAsync(cancellationToken);
                        break;
                    case TType.String:
                        // Don't try to decode the string, just skip it.
                        await prot.ReadBinaryAsync(cancellationToken);
                        break;
                    case TType.Struct:
                        await prot.ReadStructBeginAsync(cancellationToken);
                        while (true)
                        {
                            var field = await prot.ReadFieldBeginAsync(cancellationToken);
                            if (field.Type == TType.Stop)
                            {
                                break;
                            }
                            await SkipAsync(prot, field.Type, cancellationToken);
                            await prot.ReadFieldEndAsync(cancellationToken);
                        }
                        await prot.ReadStructEndAsync(cancellationToken);
                        break;
                    case TType.Map:
                        var map = await prot.ReadMapBeginAsync(cancellationToken);
                        for (var i = 0; i < map.Count; i++)
                        {
                            await SkipAsync(prot, map.KeyType, cancellationToken);
                            await SkipAsync(prot, map.ValueType, cancellationToken);
                        }
                        await prot.ReadMapEndAsync(cancellationToken);
                        break;
                    case TType.Set:
                        var set = await prot.ReadSetBeginAsync(cancellationToken);
                        for (var i = 0; i < set.Count; i++)
                        {
                            await SkipAsync(prot, set.ElementType, cancellationToken);
                        }
                        await prot.ReadSetEndAsync(cancellationToken);
                        break;
                    case TType.List:
                        var list = await prot.ReadListBeginAsync(cancellationToken);
                        for (var i = 0; i < list.Count; i++)
                        {
                            await SkipAsync(prot, list.ElementType, cancellationToken);
                        }
                        await prot.ReadListEndAsync(cancellationToken);
                        break;
                    default:
                        throw new TProtocolException(TProtocolException.INVALID_DATA, "Unknown data type " + type.ToString("d"));
                }
            }
            finally
            {
                prot.DecrementRecursionDepth();
            }
        }