Ejemplo n.º 1
0
        public override bool Equals(object that)
        {
            THardwareInfo other = that as THardwareInfo;

            if (other == null)
            {
                return(false);
            }

            if (ReferenceEquals(this,
                                other))
            {
                return(true);
            }

            return(isset.num_gpu_hw == other.isset.num_gpu_hw &&
                   (!isset.num_gpu_hw ||
                    Equals(Num_gpu_hw,
                           other.Num_gpu_hw)) &&
                   isset.num_cpu_hw == other.isset.num_cpu_hw &&
                   (!isset.num_cpu_hw ||
                    Equals(Num_cpu_hw,
                           other.Num_cpu_hw)) &&
                   isset.num_gpu_allocated == other.isset.num_gpu_allocated &&
                   (!isset.num_gpu_allocated ||
                    Equals(Num_gpu_allocated,
                           other.Num_gpu_allocated)) &&
                   isset.start_gpu == other.isset.start_gpu &&
                   (!isset.start_gpu ||
                    Equals(Start_gpu,
                           other.Start_gpu)) &&
                   isset.host_name == other.isset.host_name &&
                   (!isset.host_name ||
                    Equals(Host_name,
                           other.Host_name)) &&
                   isset.gpu_info == other.isset.gpu_info &&
                   (!isset.gpu_info ||
                    TCollections.Equals(Gpu_info,
                                        other.Gpu_info)));
        }
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 _list60 = await iprot.ReadListBeginAsync(cancellationToken);

                                Hardware_info = new List <THardwareInfo>(_list60.Count);

                                for (int _i61 = 0; _i61 < _list60.Count; ++_i61)
                                {
                                    THardwareInfo _elem62;
                                    _elem62 = new THardwareInfo();

                                    await _elem62.ReadAsync(iprot,
                                                            cancellationToken);

                                    Hardware_info.Add(_elem62);
                                }

                                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();
            }
        }