public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        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.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMap>();
                                TList _list20 = iprot.ReadListBegin();
                                for (int _i21 = 0; _i21 < _list20.Count; ++_i21)
                                {
                                    TDDIKeyValueMap _elem22;
                                    _elem22 = new TDDIKeyValueMap();
                                    _elem22.Read(iprot);
                                    KeyValueMaps.Add(_elem22);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.List)
                        {
                            {
                                Measures = new List <TDDIAbstractMeasure>();
                                TList _list23 = iprot.ReadListBegin();
                                for (int _i24 = 0; _i24 < _list23.Count; ++_i24)
                                {
                                    TDDIAbstractMeasure _elem25;
                                    _elem25 = new TDDIAbstractMeasure();
                                    _elem25.Read(iprot);
                                    Measures.Add(_elem25);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                MeasureTypes = new List <TDDIMeasureType>();
                                TList _list26 = iprot.ReadListBegin();
                                for (int _i27 = 0; _i27 < _list26.Count; ++_i27)
                                {
                                    TDDIMeasureType _elem28;
                                    _elem28 = new TDDIMeasureType();
                                    _elem28.Read(iprot);
                                    MeasureTypes.Add(_elem28);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.List)
                        {
                            {
                                MaintenanceProcedures = new List <TDDIMaintenanceProcedure>();
                                TList _list29 = iprot.ReadListBegin();
                                for (int _i30 = 0; _i30 < _list29.Count; ++_i30)
                                {
                                    TDDIMaintenanceProcedure _elem31;
                                    _elem31 = new TDDIMaintenanceProcedure();
                                    _elem31.Read(iprot);
                                    MaintenanceProcedures.Add(_elem31);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                DomainPackages = new List <TDDIDomainPackage>();
                                TList _list32 = iprot.ReadListBegin();
                                for (int _i33 = 0; _i33 < _list32.Count; ++_i33)
                                {
                                    TDDIDomainPackage _elem34;
                                    _elem34 = new TDDIDomainPackage();
                                    _elem34.Read(iprot);
                                    DomainPackages.Add(_elem34);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                TARAPackages = new List <TDDITARAPackage>();
                                TList _list35 = iprot.ReadListBegin();
                                for (int _i36 = 0; _i36 < _list35.Count; ++_i36)
                                {
                                    TDDITARAPackage _elem37;
                                    _elem37 = new TDDITARAPackage();
                                    _elem37.Read(iprot);
                                    TARAPackages.Add(_elem37);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                HARAPackages = new List <TDDIHARAPackage>();
                                TList _list38 = iprot.ReadListBegin();
                                for (int _i39 = 0; _i39 < _list38.Count; ++_i39)
                                {
                                    TDDIHARAPackage _elem40;
                                    _elem40 = new TDDIHARAPackage();
                                    _elem40.Read(iprot);
                                    HARAPackages.Add(_elem40);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                RequirementPackages = new List <TDDIRequirementPackage>();
                                TList _list41 = iprot.ReadListBegin();
                                for (int _i42 = 0; _i42 < _list41.Count; ++_i42)
                                {
                                    TDDIRequirementPackage _elem43;
                                    _elem43 = new TDDIRequirementPackage();
                                    _elem43.Read(iprot);
                                    RequirementPackages.Add(_elem43);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                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)
                        {
                            RequirementPackage = new TDDIRequirementPackage();
                            RequirementPackage.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 3:
                        if (field.Type == TType.Struct)
                        {
                            RequirementPackageBinding = new TDDIRequirementPackageBinding();
                            RequirementPackageBinding.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Example #3
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                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)
                        {
                            DesignPackage = new TDDIDesignPackage();
                            DesignPackage.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 3:
                        if (field.Type == TType.Struct)
                        {
                            RequirementPackage = new TDDIRequirementPackage();
                            RequirementPackage.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Struct)
                        {
                            HARAPackage = new TDDIHARAPackage();
                            HARAPackage.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Struct)
                        {
                            DependabilityPackage = new TDDIDependabilityPackage();
                            DependabilityPackage.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.Struct)
                        {
                            TARAPackage = new TDDITARAPackage();
                            TARAPackage.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            DomainPackage = new TDDIDomainPackage();
                            DomainPackage.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }