public void Read(TProtocol iprot)
        {
            TField field;

            iprot.ReadStructBegin();
            while (true)
            {
                field = iprot.ReadFieldBegin();
                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.Struct)
                    {
                        Exec_summary = new ExecutorSummary();
                        Exec_summary.Read(iprot);
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 2:
                    if (field.Type == TType.Struct)
                    {
                        Stats = new ComponentAggregateStats();
                        Stats.Read(iprot);
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                default:
                    TProtocolUtil.Skip(iprot, field.Type);
                    break;
                }
                iprot.ReadFieldEnd();
            }
            iprot.ReadStructEnd();
        }
        public void Read(TProtocol iprot)
        {
            bool   isset_id = false;
            TField field;

            iprot.ReadStructBegin();
            while (true)
            {
                field = iprot.ReadFieldBegin();
                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.String)
                    {
                        Id       = iprot.ReadString();
                        isset_id = true;
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 2:
                    if (field.Type == TType.String)
                    {
                        Name = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 3:
                    if (field.Type == TType.I32)
                    {
                        Uptime_secs = iprot.ReadI32();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 4:
                    if (field.Type == TType.String)
                    {
                        Status = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 5:
                    if (field.Type == TType.I32)
                    {
                        Num_tasks = iprot.ReadI32();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 6:
                    if (field.Type == TType.I32)
                    {
                        Num_workers = iprot.ReadI32();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 7:
                    if (field.Type == TType.I32)
                    {
                        Num_executors = iprot.ReadI32();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 8:
                    if (field.Type == TType.String)
                    {
                        Topology_conf = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 9:
                    if (field.Type == TType.Map)
                    {
                        {
                            Id_to_spout_agg_stats = new Dictionary <string, ComponentAggregateStats>();
                            TMap _map201 = iprot.ReadMapBegin();
                            for (int _i202 = 0; _i202 < _map201.Count; ++_i202)
                            {
                                string _key203;
                                ComponentAggregateStats _val204;
                                _key203 = iprot.ReadString();
                                _val204 = new ComponentAggregateStats();
                                _val204.Read(iprot);
                                Id_to_spout_agg_stats[_key203] = _val204;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 10:
                    if (field.Type == TType.Map)
                    {
                        {
                            Id_to_bolt_agg_stats = new Dictionary <string, ComponentAggregateStats>();
                            TMap _map205 = iprot.ReadMapBegin();
                            for (int _i206 = 0; _i206 < _map205.Count; ++_i206)
                            {
                                string _key207;
                                ComponentAggregateStats _val208;
                                _key207 = iprot.ReadString();
                                _val208 = new ComponentAggregateStats();
                                _val208.Read(iprot);
                                Id_to_bolt_agg_stats[_key207] = _val208;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 11:
                    if (field.Type == TType.String)
                    {
                        Sched_status = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 12:
                    if (field.Type == TType.Struct)
                    {
                        Topology_stats = new TopologyStats();
                        Topology_stats.Read(iprot);
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 13:
                    if (field.Type == TType.String)
                    {
                        Owner = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 14:
                    if (field.Type == TType.Struct)
                    {
                        Debug_options = new DebugOptions();
                        Debug_options.Read(iprot);
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 15:
                    if (field.Type == TType.I32)
                    {
                        Replication_count = iprot.ReadI32();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 521:
                    if (field.Type == TType.Double)
                    {
                        Requested_memonheap = iprot.ReadDouble();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 522:
                    if (field.Type == TType.Double)
                    {
                        Requested_memoffheap = iprot.ReadDouble();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 523:
                    if (field.Type == TType.Double)
                    {
                        Requested_cpu = iprot.ReadDouble();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 524:
                    if (field.Type == TType.Double)
                    {
                        Assigned_memonheap = iprot.ReadDouble();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 525:
                    if (field.Type == TType.Double)
                    {
                        Assigned_memoffheap = iprot.ReadDouble();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 526:
                    if (field.Type == TType.Double)
                    {
                        Assigned_cpu = iprot.ReadDouble();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                default:
                    TProtocolUtil.Skip(iprot, field.Type);
                    break;
                }
                iprot.ReadFieldEnd();
            }
            iprot.ReadStructEnd();
            if (!isset_id)
            {
                throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
        }
Пример #3
0
        public void Read(TProtocol iprot)
        {
            bool   isset_component_id   = false;
            bool   isset_component_type = false;
            TField field;

            iprot.ReadStructBegin();
            while (true)
            {
                field = iprot.ReadFieldBegin();
                if (field.Type == TType.Stop)
                {
                    break;
                }
                switch (field.ID)
                {
                case 1:
                    if (field.Type == TType.String)
                    {
                        Component_id       = iprot.ReadString();
                        isset_component_id = true;
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 2:
                    if (field.Type == TType.I32)
                    {
                        Component_type       = (ComponentType)iprot.ReadI32();
                        isset_component_type = true;
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 3:
                    if (field.Type == TType.String)
                    {
                        Topology_id = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 4:
                    if (field.Type == TType.String)
                    {
                        Topology_name = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 5:
                    if (field.Type == TType.I32)
                    {
                        Num_executors = iprot.ReadI32();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 6:
                    if (field.Type == TType.I32)
                    {
                        Num_tasks = iprot.ReadI32();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 7:
                    if (field.Type == TType.Map)
                    {
                        {
                            Window_to_stats = new Dictionary <string, ComponentAggregateStats>();
                            TMap _map211 = iprot.ReadMapBegin();
                            for (int _i212 = 0; _i212 < _map211.Count; ++_i212)
                            {
                                string _key213;
                                ComponentAggregateStats _val214;
                                _key213 = iprot.ReadString();
                                _val214 = new ComponentAggregateStats();
                                _val214.Read(iprot);
                                Window_to_stats[_key213] = _val214;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 8:
                    if (field.Type == TType.Map)
                    {
                        {
                            Gsid_to_input_stats = new Dictionary <GlobalStreamId, ComponentAggregateStats>();
                            TMap _map215 = iprot.ReadMapBegin();
                            for (int _i216 = 0; _i216 < _map215.Count; ++_i216)
                            {
                                GlobalStreamId          _key217;
                                ComponentAggregateStats _val218;
                                _key217 = new GlobalStreamId();
                                _key217.Read(iprot);
                                _val218 = new ComponentAggregateStats();
                                _val218.Read(iprot);
                                Gsid_to_input_stats[_key217] = _val218;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 9:
                    if (field.Type == TType.Map)
                    {
                        {
                            Sid_to_output_stats = new Dictionary <string, ComponentAggregateStats>();
                            TMap _map219 = iprot.ReadMapBegin();
                            for (int _i220 = 0; _i220 < _map219.Count; ++_i220)
                            {
                                string _key221;
                                ComponentAggregateStats _val222;
                                _key221 = iprot.ReadString();
                                _val222 = new ComponentAggregateStats();
                                _val222.Read(iprot);
                                Sid_to_output_stats[_key221] = _val222;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 10:
                    if (field.Type == TType.List)
                    {
                        {
                            Exec_stats = new List <ExecutorAggregateStats>();
                            TList _list223 = iprot.ReadListBegin();
                            for (int _i224 = 0; _i224 < _list223.Count; ++_i224)
                            {
                                ExecutorAggregateStats _elem225 = new ExecutorAggregateStats();
                                _elem225 = new ExecutorAggregateStats();
                                _elem225.Read(iprot);
                                Exec_stats.Add(_elem225);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 11:
                    if (field.Type == TType.List)
                    {
                        {
                            Errors = new List <ErrorInfo>();
                            TList _list226 = iprot.ReadListBegin();
                            for (int _i227 = 0; _i227 < _list226.Count; ++_i227)
                            {
                                ErrorInfo _elem228 = new ErrorInfo();
                                _elem228 = new ErrorInfo();
                                _elem228.Read(iprot);
                                Errors.Add(_elem228);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 12:
                    if (field.Type == TType.String)
                    {
                        Eventlog_host = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 13:
                    if (field.Type == TType.I32)
                    {
                        Eventlog_port = iprot.ReadI32();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 14:
                    if (field.Type == TType.Struct)
                    {
                        Debug_options = new DebugOptions();
                        Debug_options.Read(iprot);
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 15:
                    if (field.Type == TType.String)
                    {
                        Topology_status = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                default:
                    TProtocolUtil.Skip(iprot, field.Type);
                    break;
                }
                iprot.ReadFieldEnd();
            }
            iprot.ReadStructEnd();
            if (!isset_component_id)
            {
                throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_component_type)
            {
                throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
        }