Exemple #1
0
    public CellSerial DeepCopy()
    {
        var tmp282 = new CellSerial();

        if ((C != null) && __isset.c)
        {
            tmp282.C = this.C;
        }
        tmp282.__isset.c = this.__isset.c;
        if ((K != null) && __isset.k)
        {
            tmp282.K = this.K.DeepCopy();
        }
        tmp282.__isset.k = this.__isset.k;
        if (__isset.ts)
        {
            tmp282.Ts = this.Ts;
        }
        tmp282.__isset.ts = this.__isset.ts;
        if ((V != null) && __isset.v)
        {
            tmp282.V = this.V.DeepCopy();
        }
        tmp282.__isset.v = this.__isset.v;
        return(tmp282);
    }
Exemple #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 _list296 = await iprot.ReadListBeginAsync(cancellationToken);

                            Cells_ = new List <Cell>(_list296.Count);
                            for (int _i297 = 0; _i297 < _list296.Count; ++_i297)
                            {
                                Cell _elem298;
                                _elem298 = new Cell();
                                await _elem298.ReadAsync(iprot, cancellationToken);

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

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

                            Serial_cells = new List <CellSerial>(_list299.Count);
                            for (int _i300 = 0; _i300 < _list299.Count; ++_i300)
                            {
                                CellSerial _elem301;
                                _elem301 = new CellSerial();
                                await _elem301.ReadAsync(iprot, cancellationToken);

                                Serial_cells.Add(_elem301);
                            }
                            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();
        }
    }