Ejemplo n.º 1
0
    public SpecTimestamp DeepCopy()
    {
        var tmp60 = new SpecTimestamp();

        if (__isset.comp)
        {
            tmp60.Comp = this.Comp;
        }
        tmp60.__isset.comp = this.__isset.comp;
        if (__isset.ts)
        {
            tmp60.Ts = this.Ts;
        }
        tmp60.__isset.ts = this.__isset.ts;
        return(tmp60);
    }
Ejemplo n.º 2
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 _list188 = await iprot.ReadListBeginAsync(cancellationToken);

                            Range_begin = new List <byte[]>(_list188.Count);
                            for (int _i189 = 0; _i189 < _list188.Count; ++_i189)
                            {
                                byte[] _elem190;
                                _elem190 = await iprot.ReadBinaryAsync(cancellationToken);

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

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

                            Range_end = new List <byte[]>(_list191.Count);
                            for (int _i192 = 0; _i192 < _list191.Count; ++_i192)
                            {
                                byte[] _elem193;
                                _elem193 = await iprot.ReadBinaryAsync(cancellationToken);

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

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

                            Offset_key = new List <byte[]>(_list194.Count);
                            for (int _i195 = 0; _i195 < _list194.Count; ++_i195)
                            {
                                byte[] _elem196;
                                _elem196 = await iprot.ReadBinaryAsync(cancellationToken);

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

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

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

                            Key_intervals = new List <SpecKeyInterval>(_list197.Count);
                            for (int _i198 = 0; _i198 < _list197.Count; ++_i198)
                            {
                                SpecKeyInterval _elem199;
                                _elem199 = new SpecKeyInterval();
                                await _elem199.ReadAsync(iprot, cancellationToken);

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

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

                            Values = new List <SpecValueSerial>(_list200.Count);
                            for (int _i201 = 0; _i201 < _list200.Count; ++_i201)
                            {
                                SpecValueSerial _elem202;
                                _elem202 = new SpecValueSerial();
                                await _elem202.ReadAsync(iprot, cancellationToken);

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

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

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

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

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

                case 11:
                    if (field.Type == TType.Struct)
                    {
                        Updating = new SpecIntervalUpdateSerial();
                        await Updating.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();
        }
    }