Beispiel #1
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.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.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list636 = iprot.ReadListBegin();
                                for (int _i637 = 0; _i637 < _list636.Count; ++_i637)
                                {
                                    TDDIKeyValueMapRef _elem638;
                                    _elem638 = new TDDIKeyValueMapRef();
                                    _elem638.Read(iprot);
                                    KeyValueMaps.Add(_elem638);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureAnalysisArtifacts = new List <TDDIAbstractFailureAnalysisArtifactRef>();
                                TList _list639 = iprot.ReadListBegin();
                                for (int _i640 = 0; _i640 < _list639.Count; ++_i640)
                                {
                                    TDDIAbstractFailureAnalysisArtifactRef _elem641;
                                    _elem641 = new TDDIAbstractFailureAnalysisArtifactRef();
                                    _elem641.Read(iprot);
                                    FailureAnalysisArtifacts.Add(_elem641);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                FTAArtifacts = new List <TDDIAbstractFTAArtifact>();
                                TList _list642 = iprot.ReadListBegin();
                                for (int _i643 = 0; _i643 < _list642.Count; ++_i643)
                                {
                                    TDDIAbstractFTAArtifact _elem644;
                                    _elem644 = new TDDIAbstractFTAArtifact();
                                    _elem644.Read(iprot);
                                    FTAArtifacts.Add(_elem644);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                BasicEvents = new List <TDDIBasicEvent>();
                                TList _list645 = iprot.ReadListBegin();
                                for (int _i646 = 0; _i646 < _list645.Count; ++_i646)
                                {
                                    TDDIBasicEvent _elem647;
                                    _elem647 = new TDDIBasicEvent();
                                    _elem647.Read(iprot);
                                    BasicEvents.Add(_elem647);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                ParticipantPackages = new List <TDDIAbstractFTAPackageRef>();
                                TList _list648 = iprot.ReadListBegin();
                                for (int _i649 = 0; _i649 < _list648.Count; ++_i649)
                                {
                                    TDDIAbstractFTAPackageRef _elem650;
                                    _elem650 = new TDDIAbstractFTAPackageRef();
                                    _elem650.Read(iprot);
                                    ParticipantPackages.Add(_elem650);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Beispiel #2
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.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.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list620 = iprot.ReadListBegin();
                                for (int _i621 = 0; _i621 < _list620.Count; ++_i621)
                                {
                                    TDDIKeyValueMapRef _elem622;
                                    _elem622 = new TDDIKeyValueMapRef();
                                    _elem622.Read(iprot);
                                    KeyValueMaps.Add(_elem622);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureAnalysisArtifacts = new List <TDDIAbstractFailureAnalysisArtifactRef>();
                                TList _list623 = iprot.ReadListBegin();
                                for (int _i624 = 0; _i624 < _list623.Count; ++_i624)
                                {
                                    TDDIAbstractFailureAnalysisArtifactRef _elem625;
                                    _elem625 = new TDDIAbstractFailureAnalysisArtifactRef();
                                    _elem625.Read(iprot);
                                    FailureAnalysisArtifacts.Add(_elem625);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                FTAArtifacts = new List <TDDIAbstractFTAArtifact>();
                                TList _list626 = iprot.ReadListBegin();
                                for (int _i627 = 0; _i627 < _list626.Count; ++_i627)
                                {
                                    TDDIAbstractFTAArtifact _elem628;
                                    _elem628 = new TDDIAbstractFTAArtifact();
                                    _elem628.Read(iprot);
                                    FTAArtifacts.Add(_elem628);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                BasicEvents = new List <TDDIBasicEvent>();
                                TList _list629 = iprot.ReadListBegin();
                                for (int _i630 = 0; _i630 < _list629.Count; ++_i630)
                                {
                                    TDDIBasicEvent _elem631;
                                    _elem631 = new TDDIBasicEvent();
                                    _elem631.Read(iprot);
                                    BasicEvents.Add(_elem631);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.Struct)
                        {
                            Implements = new TDDIAbstractFTAPackage();
                            Implements.Read(iprot);
                        }
                        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.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.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list844 = iprot.ReadListBegin();
                                for (int _i845 = 0; _i845 < _list844.Count; ++_i845)
                                {
                                    TDDIKeyValueMapRef _elem846;
                                    _elem846 = new TDDIKeyValueMapRef();
                                    _elem846.Read(iprot);
                                    KeyValueMaps.Add(_elem846);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureAnalysisArtifacts = new List <TDDIAbstractFailureAnalysisArtifactRef>();
                                TList _list847 = iprot.ReadListBegin();
                                for (int _i848 = 0; _i848 < _list847.Count; ++_i848)
                                {
                                    TDDIAbstractFailureAnalysisArtifactRef _elem849;
                                    _elem849 = new TDDIAbstractFailureAnalysisArtifactRef();
                                    _elem849.Read(iprot);
                                    FailureAnalysisArtifacts.Add(_elem849);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                MarkovArtifacts = new List <TDDIAbstractMarkovArtifact>();
                                TList _list850 = iprot.ReadListBegin();
                                for (int _i851 = 0; _i851 < _list850.Count; ++_i851)
                                {
                                    TDDIAbstractMarkovArtifact _elem852;
                                    _elem852 = new TDDIAbstractMarkovArtifact();
                                    _elem852.Read(iprot);
                                    MarkovArtifacts.Add(_elem852);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                FailStates = new List <TDDIFailState>();
                                TList _list853 = iprot.ReadListBegin();
                                for (int _i854 = 0; _i854 < _list853.Count; ++_i854)
                                {
                                    TDDIFailState _elem855;
                                    _elem855 = new TDDIFailState();
                                    _elem855.Read(iprot);
                                    FailStates.Add(_elem855);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.Struct)
                        {
                            Implements = new TDDIAbstractMarkovChainPackage();
                            Implements.Read(iprot);
                        }
                        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.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.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list556 = iprot.ReadListBegin();
                                for (int _i557 = 0; _i557 < _list556.Count; ++_i557)
                                {
                                    TDDIKeyValueMapRef _elem558;
                                    _elem558 = new TDDIKeyValueMapRef();
                                    _elem558.Read(iprot);
                                    KeyValueMaps.Add(_elem558);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureAnalysisArtifacts = new List <TDDIAbstractFailureAnalysisArtifactRef>();
                                TList _list559 = iprot.ReadListBegin();
                                for (int _i560 = 0; _i560 < _list559.Count; ++_i560)
                                {
                                    TDDIAbstractFailureAnalysisArtifactRef _elem561;
                                    _elem561 = new TDDIAbstractFailureAnalysisArtifactRef();
                                    _elem561.Read(iprot);
                                    FailureAnalysisArtifacts.Add(_elem561);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                FMEAArtifacts = new List <TDDIAbstractFMEAArtifactRef>();
                                TList _list562 = iprot.ReadListBegin();
                                for (int _i563 = 0; _i563 < _list562.Count; ++_i563)
                                {
                                    TDDIAbstractFMEAArtifactRef _elem564;
                                    _elem564 = new TDDIAbstractFMEAArtifactRef();
                                    _elem564.Read(iprot);
                                    FMEAArtifacts.Add(_elem564);
                                }
                                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.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.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list504 = iprot.ReadListBegin();
                                for (int _i505 = 0; _i505 < _list504.Count; ++_i505)
                                {
                                    TDDIKeyValueMapRef _elem506;
                                    _elem506 = new TDDIKeyValueMapRef();
                                    _elem506.Read(iprot);
                                    KeyValueMaps.Add(_elem506);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureAnalysisArtifacts = new List <TDDIAbstractFailureAnalysisArtifactRef>();
                                TList _list507 = iprot.ReadListBegin();
                                for (int _i508 = 0; _i508 < _list507.Count; ++_i508)
                                {
                                    TDDIAbstractFailureAnalysisArtifactRef _elem509;
                                    _elem509 = new TDDIAbstractFailureAnalysisArtifactRef();
                                    _elem509.Read(iprot);
                                    FailureAnalysisArtifacts.Add(_elem509);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                FMEAArtifacts = new List <TDDIAbstractFMEAArtifactRef>();
                                TList _list510 = iprot.ReadListBegin();
                                for (int _i511 = 0; _i511 < _list510.Count; ++_i511)
                                {
                                    TDDIAbstractFMEAArtifactRef _elem512;
                                    _elem512 = new TDDIAbstractFMEAArtifactRef();
                                    _elem512.Read(iprot);
                                    FMEAArtifacts.Add(_elem512);
                                }
                                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.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.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list828 = iprot.ReadListBegin();
                                for (int _i829 = 0; _i829 < _list828.Count; ++_i829)
                                {
                                    TDDIKeyValueMapRef _elem830;
                                    _elem830 = new TDDIKeyValueMapRef();
                                    _elem830.Read(iprot);
                                    KeyValueMaps.Add(_elem830);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureAnalysisArtifacts = new List <TDDIAbstractFailureAnalysisArtifactRef>();
                                TList _list831 = iprot.ReadListBegin();
                                for (int _i832 = 0; _i832 < _list831.Count; ++_i832)
                                {
                                    TDDIAbstractFailureAnalysisArtifactRef _elem833;
                                    _elem833 = new TDDIAbstractFailureAnalysisArtifactRef();
                                    _elem833.Read(iprot);
                                    FailureAnalysisArtifacts.Add(_elem833);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                MarkovArtifacts = new List <TDDIAbstractMarkovArtifact>();
                                TList _list834 = iprot.ReadListBegin();
                                for (int _i835 = 0; _i835 < _list834.Count; ++_i835)
                                {
                                    TDDIAbstractMarkovArtifact _elem836;
                                    _elem836 = new TDDIAbstractMarkovArtifact();
                                    _elem836.Read(iprot);
                                    MarkovArtifacts.Add(_elem836);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                FailStates = new List <TDDIFailState>();
                                TList _list837 = iprot.ReadListBegin();
                                for (int _i838 = 0; _i838 < _list837.Count; ++_i838)
                                {
                                    TDDIFailState _elem839;
                                    _elem839 = new TDDIFailState();
                                    _elem839.Read(iprot);
                                    FailStates.Add(_elem839);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Beispiel #7
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.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.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list860 = iprot.ReadListBegin();
                                for (int _i861 = 0; _i861 < _list860.Count; ++_i861)
                                {
                                    TDDIKeyValueMapRef _elem862;
                                    _elem862 = new TDDIKeyValueMapRef();
                                    _elem862.Read(iprot);
                                    KeyValueMaps.Add(_elem862);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureAnalysisArtifacts = new List <TDDIAbstractFailureAnalysisArtifactRef>();
                                TList _list863 = iprot.ReadListBegin();
                                for (int _i864 = 0; _i864 < _list863.Count; ++_i864)
                                {
                                    TDDIAbstractFailureAnalysisArtifactRef _elem865;
                                    _elem865 = new TDDIAbstractFailureAnalysisArtifactRef();
                                    _elem865.Read(iprot);
                                    FailureAnalysisArtifacts.Add(_elem865);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                MarkovArtifacts = new List <TDDIAbstractMarkovArtifact>();
                                TList _list866 = iprot.ReadListBegin();
                                for (int _i867 = 0; _i867 < _list866.Count; ++_i867)
                                {
                                    TDDIAbstractMarkovArtifact _elem868;
                                    _elem868 = new TDDIAbstractMarkovArtifact();
                                    _elem868.Read(iprot);
                                    MarkovArtifacts.Add(_elem868);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                FailStates = new List <TDDIFailState>();
                                TList _list869 = iprot.ReadListBegin();
                                for (int _i870 = 0; _i870 < _list869.Count; ++_i870)
                                {
                                    TDDIFailState _elem871;
                                    _elem871 = new TDDIFailState();
                                    _elem871.Read(iprot);
                                    FailStates.Add(_elem871);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                ParticipantPackages = new List <TDDIAbstractMarkovChainPackageRef>();
                                TList _list872 = iprot.ReadListBegin();
                                for (int _i873 = 0; _i873 < _list872.Count; ++_i873)
                                {
                                    TDDIAbstractMarkovChainPackageRef _elem874;
                                    _elem874 = new TDDIAbstractMarkovChainPackageRef();
                                    _elem874.Read(iprot);
                                    ParticipantPackages.Add(_elem874);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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