Ejemplo n.º 1
0
    public SpecIntervalSerial DeepCopy()
    {
        var tmp187 = new SpecIntervalSerial();

        if ((Range_begin != null) && __isset.range_begin)
        {
            tmp187.Range_begin = this.Range_begin.DeepCopy();
        }
        tmp187.__isset.range_begin = this.__isset.range_begin;
        if ((Range_end != null) && __isset.range_end)
        {
            tmp187.Range_end = this.Range_end.DeepCopy();
        }
        tmp187.__isset.range_end = this.__isset.range_end;
        if ((Offset_key != null) && __isset.offset_key)
        {
            tmp187.Offset_key = this.Offset_key.DeepCopy();
        }
        tmp187.__isset.offset_key = this.__isset.offset_key;
        if (__isset.offset_rev)
        {
            tmp187.Offset_rev = this.Offset_rev;
        }
        tmp187.__isset.offset_rev = this.__isset.offset_rev;
        if ((Key_intervals != null) && __isset.key_intervals)
        {
            tmp187.Key_intervals = this.Key_intervals.DeepCopy();
        }
        tmp187.__isset.key_intervals = this.__isset.key_intervals;
        if ((Values != null) && __isset.values)
        {
            tmp187.Values = this.Values.DeepCopy();
        }
        tmp187.__isset.values = this.__isset.values;
        if ((Ts_start != null) && __isset.ts_start)
        {
            tmp187.Ts_start = (SpecTimestamp)this.Ts_start.DeepCopy();
        }
        tmp187.__isset.ts_start = this.__isset.ts_start;
        if ((Ts_finish != null) && __isset.ts_finish)
        {
            tmp187.Ts_finish = (SpecTimestamp)this.Ts_finish.DeepCopy();
        }
        tmp187.__isset.ts_finish = this.__isset.ts_finish;
        if ((Flags != null) && __isset.flags)
        {
            tmp187.Flags = (SpecFlags)this.Flags.DeepCopy();
        }
        tmp187.__isset.flags = this.__isset.flags;
        if (__isset.options)
        {
            tmp187.Options = this.Options;
        }
        tmp187.__isset.options = this.__isset.options;
        if ((Updating != null) && __isset.updating)
        {
            tmp187.Updating = (SpecIntervalUpdateSerial)this.Updating.DeepCopy();
        }
        tmp187.__isset.updating = this.__isset.updating;
        return(tmp187);
    }
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.I64)
                    {
                        Cid = await iprot.ReadI64Async(cancellationToken);
                    }
                    else
                    {
                        await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
                    }
                    break;

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

                            Intervals = new List <SpecIntervalSerial>(_list213.Count);
                            for (int _i214 = 0; _i214 < _list213.Count; ++_i214)
                            {
                                SpecIntervalSerial _elem215;
                                _elem215 = new SpecIntervalSerial();
                                await _elem215.ReadAsync(iprot, cancellationToken);

                                Intervals.Add(_elem215);
                            }
                            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();
        }
    }