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 _list784 = iprot.ReadListBegin();
                                for (int _i785 = 0; _i785 < _list784.Count; ++_i785)
                                {
                                    TDDIKeyValueMapRef _elem786;
                                    _elem786 = new TDDIKeyValueMapRef();
                                    _elem786.Read(iprot);
                                    KeyValueMaps.Add(_elem786);
                                }
                                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)
                        {
                            {
                                ODEPackages = new List <TDDIAbstractODEPackageRef>();
                                TList _list787 = iprot.ReadListBegin();
                                for (int _i788 = 0; _i788 < _list787.Count; ++_i788)
                                {
                                    TDDIAbstractODEPackageRef _elem789;
                                    _elem789 = new TDDIAbstractODEPackageRef();
                                    _elem789.Read(iprot);
                                    ODEPackages.Add(_elem789);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                ArchitecturePackages = new List <TDDIAbstractArchitecturePackageRef>();
                                TList _list790 = iprot.ReadListBegin();
                                for (int _i791 = 0; _i791 < _list790.Count; ++_i791)
                                {
                                    TDDIAbstractArchitecturePackageRef _elem792;
                                    _elem792 = new TDDIAbstractArchitecturePackageRef();
                                    _elem792.Read(iprot);
                                    ArchitecturePackages.Add(_elem792);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityPackages = new List <TDDIAbstractDependabilityPackageRef>();
                                TList _list793 = iprot.ReadListBegin();
                                for (int _i794 = 0; _i794 < _list793.Count; ++_i794)
                                {
                                    TDDIAbstractDependabilityPackageRef _elem795;
                                    _elem795 = new TDDIAbstractDependabilityPackageRef();
                                    _elem795.Read(iprot);
                                    DependabilityPackages.Add(_elem795);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureLogicPackages = new List <TDDIAbstractFailureLogicPackageRef>();
                                TList _list796 = iprot.ReadListBegin();
                                for (int _i797 = 0; _i797 < _list796.Count; ++_i797)
                                {
                                    TDDIAbstractFailureLogicPackageRef _elem798;
                                    _elem798 = new TDDIAbstractFailureLogicPackageRef();
                                    _elem798.Read(iprot);
                                    FailureLogicPackages.Add(_elem798);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                AssuranceCasePackages = new List <TDDIAbstractAssuranceCasePackageRef>();
                                TList _list799 = iprot.ReadListBegin();
                                for (int _i800 = 0; _i800 < _list799.Count; ++_i800)
                                {
                                    TDDIAbstractAssuranceCasePackageRef _elem801;
                                    _elem801 = new TDDIAbstractAssuranceCasePackageRef();
                                    _elem801.Read(iprot);
                                    AssuranceCasePackages.Add(_elem801);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.List)
                        {
                            {
                                ParticipantPackages = new List <TDDIAbstractODEPackageRef>();
                                TList _list802 = iprot.ReadListBegin();
                                for (int _i803 = 0; _i803 < _list802.Count; ++_i803)
                                {
                                    TDDIAbstractODEPackageRef _elem804;
                                    _elem804 = new TDDIAbstractODEPackageRef();
                                    _elem804.Read(iprot);
                                    ParticipantPackages.Add(_elem804);
                                }
                                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 _list352 = iprot.ReadListBegin();
                                for (int _i353 = 0; _i353 < _list352.Count; ++_i353)
                                {
                                    TDDIKeyValueMapRef _elem354;
                                    _elem354 = new TDDIKeyValueMapRef();
                                    _elem354.Read(iprot);
                                    KeyValueMaps.Add(_elem354);
                                }
                                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)
                        {
                            {
                                DependabilityArtifacts = new List <TDDIAbstractDependabilityArtifactRef>();
                                TList _list355 = iprot.ReadListBegin();
                                for (int _i356 = 0; _i356 < _list355.Count; ++_i356)
                                {
                                    TDDIAbstractDependabilityArtifactRef _elem357;
                                    _elem357 = new TDDIAbstractDependabilityArtifactRef();
                                    _elem357.Read(iprot);
                                    DependabilityArtifacts.Add(_elem357);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                ParticipantPackages = new List <TDDIAbstractDependabilityPackageRef>();
                                TList _list358 = iprot.ReadListBegin();
                                for (int _i359 = 0; _i359 < _list358.Count; ++_i359)
                                {
                                    TDDIAbstractDependabilityPackageRef _elem360;
                                    _elem360 = new TDDIAbstractDependabilityPackageRef();
                                    _elem360.Read(iprot);
                                    ParticipantPackages.Add(_elem360);
                                }
                                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 _list736 = iprot.ReadListBegin();
                                for (int _i737 = 0; _i737 < _list736.Count; ++_i737)
                                {
                                    TDDIKeyValueMapRef _elem738;
                                    _elem738 = new TDDIKeyValueMapRef();
                                    _elem738.Read(iprot);
                                    KeyValueMaps.Add(_elem738);
                                }
                                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)
                        {
                            {
                                ODEPackages = new List <TDDIAbstractODEPackageRef>();
                                TList _list739 = iprot.ReadListBegin();
                                for (int _i740 = 0; _i740 < _list739.Count; ++_i740)
                                {
                                    TDDIAbstractODEPackageRef _elem741;
                                    _elem741 = new TDDIAbstractODEPackageRef();
                                    _elem741.Read(iprot);
                                    ODEPackages.Add(_elem741);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                ArchitecturePackages = new List <TDDIAbstractArchitecturePackageRef>();
                                TList _list742 = iprot.ReadListBegin();
                                for (int _i743 = 0; _i743 < _list742.Count; ++_i743)
                                {
                                    TDDIAbstractArchitecturePackageRef _elem744;
                                    _elem744 = new TDDIAbstractArchitecturePackageRef();
                                    _elem744.Read(iprot);
                                    ArchitecturePackages.Add(_elem744);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityPackages = new List <TDDIAbstractDependabilityPackageRef>();
                                TList _list745 = iprot.ReadListBegin();
                                for (int _i746 = 0; _i746 < _list745.Count; ++_i746)
                                {
                                    TDDIAbstractDependabilityPackageRef _elem747;
                                    _elem747 = new TDDIAbstractDependabilityPackageRef();
                                    _elem747.Read(iprot);
                                    DependabilityPackages.Add(_elem747);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureLogicPackages = new List <TDDIAbstractFailureLogicPackageRef>();
                                TList _list748 = iprot.ReadListBegin();
                                for (int _i749 = 0; _i749 < _list748.Count; ++_i749)
                                {
                                    TDDIAbstractFailureLogicPackageRef _elem750;
                                    _elem750 = new TDDIAbstractFailureLogicPackageRef();
                                    _elem750.Read(iprot);
                                    FailureLogicPackages.Add(_elem750);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                AssuranceCasePackages = new List <TDDIAbstractAssuranceCasePackageRef>();
                                TList _list751 = iprot.ReadListBegin();
                                for (int _i752 = 0; _i752 < _list751.Count; ++_i752)
                                {
                                    TDDIAbstractAssuranceCasePackageRef _elem753;
                                    _elem753 = new TDDIAbstractAssuranceCasePackageRef();
                                    _elem753.Read(iprot);
                                    AssuranceCasePackages.Add(_elem753);
                                }
                                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 _list760 = iprot.ReadListBegin();
                                for (int _i761 = 0; _i761 < _list760.Count; ++_i761)
                                {
                                    TDDIKeyValueMapRef _elem762;
                                    _elem762 = new TDDIKeyValueMapRef();
                                    _elem762.Read(iprot);
                                    KeyValueMaps.Add(_elem762);
                                }
                                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)
                        {
                            {
                                ODEPackages = new List <TDDIAbstractODEPackageRef>();
                                TList _list763 = iprot.ReadListBegin();
                                for (int _i764 = 0; _i764 < _list763.Count; ++_i764)
                                {
                                    TDDIAbstractODEPackageRef _elem765;
                                    _elem765 = new TDDIAbstractODEPackageRef();
                                    _elem765.Read(iprot);
                                    ODEPackages.Add(_elem765);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                ArchitecturePackages = new List <TDDIAbstractArchitecturePackageRef>();
                                TList _list766 = iprot.ReadListBegin();
                                for (int _i767 = 0; _i767 < _list766.Count; ++_i767)
                                {
                                    TDDIAbstractArchitecturePackageRef _elem768;
                                    _elem768 = new TDDIAbstractArchitecturePackageRef();
                                    _elem768.Read(iprot);
                                    ArchitecturePackages.Add(_elem768);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityPackages = new List <TDDIAbstractDependabilityPackageRef>();
                                TList _list769 = iprot.ReadListBegin();
                                for (int _i770 = 0; _i770 < _list769.Count; ++_i770)
                                {
                                    TDDIAbstractDependabilityPackageRef _elem771;
                                    _elem771 = new TDDIAbstractDependabilityPackageRef();
                                    _elem771.Read(iprot);
                                    DependabilityPackages.Add(_elem771);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureLogicPackages = new List <TDDIAbstractFailureLogicPackageRef>();
                                TList _list772 = iprot.ReadListBegin();
                                for (int _i773 = 0; _i773 < _list772.Count; ++_i773)
                                {
                                    TDDIAbstractFailureLogicPackageRef _elem774;
                                    _elem774 = new TDDIAbstractFailureLogicPackageRef();
                                    _elem774.Read(iprot);
                                    FailureLogicPackages.Add(_elem774);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                AssuranceCasePackages = new List <TDDIAbstractAssuranceCasePackageRef>();
                                TList _list775 = iprot.ReadListBegin();
                                for (int _i776 = 0; _i776 < _list775.Count; ++_i776)
                                {
                                    TDDIAbstractAssuranceCasePackageRef _elem777;
                                    _elem777 = new TDDIAbstractAssuranceCasePackageRef();
                                    _elem777.Read(iprot);
                                    AssuranceCasePackages.Add(_elem777);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.Struct)
                        {
                            Implements = new TDDIAbstractODEPackage();
                            Implements.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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