Example #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.Struct)
                        {
                            Ref = new TDDIAbstractTerminologyPackage();
                            Ref.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Example #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.String)
                        {
                            Gid = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

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

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

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

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                ImplementationConstraint = new List <TDDIImplementationConstraintRef>();
                                TList _list1152 = iprot.ReadListBegin();
                                for (int _i1153 = 0; _i1153 < _list1152.Count; ++_i1153)
                                {
                                    TDDIImplementationConstraintRef _elem1154;
                                    _elem1154 = new TDDIImplementationConstraintRef();
                                    _elem1154.Read(iprot);
                                    ImplementationConstraint.Add(_elem1154);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                Note = new List <TDDINoteRef>();
                                TList _list1155 = iprot.ReadListBegin();
                                for (int _i1156 = 0; _i1156 < _list1155.Count; ++_i1156)
                                {
                                    TDDINoteRef _elem1157;
                                    _elem1157 = new TDDINoteRef();
                                    _elem1157.Read(iprot);
                                    Note.Add(_elem1157);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                TaggedValue = new List <TDDITaggedValueRef>();
                                TList _list1158 = iprot.ReadListBegin();
                                for (int _i1159 = 0; _i1159 < _list1158.Count; ++_i1159)
                                {
                                    TDDITaggedValueRef _elem1160;
                                    _elem1160 = new TDDITaggedValueRef();
                                    _elem1160.Read(iprot);
                                    TaggedValue.Add(_elem1160);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                AssuranceCasePackage = new List <TDDIAbstractAssuranceCasePackage>();
                                TList _list1161 = iprot.ReadListBegin();
                                for (int _i1162 = 0; _i1162 < _list1161.Count; ++_i1162)
                                {
                                    TDDIAbstractAssuranceCasePackage _elem1163;
                                    _elem1163 = new TDDIAbstractAssuranceCasePackage();
                                    _elem1163.Read(iprot);
                                    AssuranceCasePackage.Add(_elem1163);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                Interface = new List <TDDIAssuranceCasePackageInterfaceRef>();
                                TList _list1164 = iprot.ReadListBegin();
                                for (int _i1165 = 0; _i1165 < _list1164.Count; ++_i1165)
                                {
                                    TDDIAssuranceCasePackageInterfaceRef _elem1166;
                                    _elem1166 = new TDDIAssuranceCasePackageInterfaceRef();
                                    _elem1166.Read(iprot);
                                    Interface.Add(_elem1166);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.List)
                        {
                            {
                                ArtifactPackage = new List <TDDIAbstractArtifactPackage>();
                                TList _list1167 = iprot.ReadListBegin();
                                for (int _i1168 = 0; _i1168 < _list1167.Count; ++_i1168)
                                {
                                    TDDIAbstractArtifactPackage _elem1169;
                                    _elem1169 = new TDDIAbstractArtifactPackage();
                                    _elem1169.Read(iprot);
                                    ArtifactPackage.Add(_elem1169);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.List)
                        {
                            {
                                ArgumentPackage = new List <TDDIAbstractArgumentPackage>();
                                TList _list1170 = iprot.ReadListBegin();
                                for (int _i1171 = 0; _i1171 < _list1170.Count; ++_i1171)
                                {
                                    TDDIAbstractArgumentPackage _elem1172;
                                    _elem1172 = new TDDIAbstractArgumentPackage();
                                    _elem1172.Read(iprot);
                                    ArgumentPackage.Add(_elem1172);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                TerminologyPackage = new List <TDDIAbstractTerminologyPackage>();
                                TList _list1173 = iprot.ReadListBegin();
                                for (int _i1174 = 0; _i1174 < _list1173.Count; ++_i1174)
                                {
                                    TDDIAbstractTerminologyPackage _elem1175;
                                    _elem1175 = new TDDIAbstractTerminologyPackage();
                                    _elem1175.Read(iprot);
                                    TerminologyPackage.Add(_elem1175);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        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.String)
                        {
                            Gid = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

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

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

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

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                ImplementationConstraint = new List <TDDIImplementationConstraintRef>();
                                TList _list1508 = iprot.ReadListBegin();
                                for (int _i1509 = 0; _i1509 < _list1508.Count; ++_i1509)
                                {
                                    TDDIImplementationConstraintRef _elem1510;
                                    _elem1510 = new TDDIImplementationConstraintRef();
                                    _elem1510.Read(iprot);
                                    ImplementationConstraint.Add(_elem1510);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                Note = new List <TDDINoteRef>();
                                TList _list1511 = iprot.ReadListBegin();
                                for (int _i1512 = 0; _i1512 < _list1511.Count; ++_i1512)
                                {
                                    TDDINoteRef _elem1513;
                                    _elem1513 = new TDDINoteRef();
                                    _elem1513.Read(iprot);
                                    Note.Add(_elem1513);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                TaggedValue = new List <TDDITaggedValueRef>();
                                TList _list1514 = iprot.ReadListBegin();
                                for (int _i1515 = 0; _i1515 < _list1514.Count; ++_i1515)
                                {
                                    TDDITaggedValueRef _elem1516;
                                    _elem1516 = new TDDITaggedValueRef();
                                    _elem1516.Read(iprot);
                                    TaggedValue.Add(_elem1516);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                TerminologyElement = new List <TDDIAbstractTerminologyElement>();
                                TList _list1517 = iprot.ReadListBegin();
                                for (int _i1518 = 0; _i1518 < _list1517.Count; ++_i1518)
                                {
                                    TDDIAbstractTerminologyElement _elem1519;
                                    _elem1519 = new TDDIAbstractTerminologyElement();
                                    _elem1519.Read(iprot);
                                    TerminologyElement.Add(_elem1519);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                ParticipantPackage = new List <TDDIAbstractTerminologyPackage>();
                                TList _list1520 = iprot.ReadListBegin();
                                for (int _i1521 = 0; _i1521 < _list1520.Count; ++_i1521)
                                {
                                    TDDIAbstractTerminologyPackage _elem1522;
                                    _elem1522 = new TDDIAbstractTerminologyPackage();
                                    _elem1522.Read(iprot);
                                    ParticipantPackage.Add(_elem1522);
                                }
                                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.String)
                        {
                            Gid = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

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

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

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

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                ImplementationConstraint = new List <TDDIImplementationConstraintRef>();
                                TList _list1216 = iprot.ReadListBegin();
                                for (int _i1217 = 0; _i1217 < _list1216.Count; ++_i1217)
                                {
                                    TDDIImplementationConstraintRef _elem1218;
                                    _elem1218 = new TDDIImplementationConstraintRef();
                                    _elem1218.Read(iprot);
                                    ImplementationConstraint.Add(_elem1218);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                Note = new List <TDDINoteRef>();
                                TList _list1219 = iprot.ReadListBegin();
                                for (int _i1220 = 0; _i1220 < _list1219.Count; ++_i1220)
                                {
                                    TDDINoteRef _elem1221;
                                    _elem1221 = new TDDINoteRef();
                                    _elem1221.Read(iprot);
                                    Note.Add(_elem1221);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                TaggedValue = new List <TDDITaggedValueRef>();
                                TList _list1222 = iprot.ReadListBegin();
                                for (int _i1223 = 0; _i1223 < _list1222.Count; ++_i1223)
                                {
                                    TDDITaggedValueRef _elem1224;
                                    _elem1224 = new TDDITaggedValueRef();
                                    _elem1224.Read(iprot);
                                    TaggedValue.Add(_elem1224);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                AssuranceCasePackage = new List <TDDIAbstractAssuranceCasePackage>();
                                TList _list1225 = iprot.ReadListBegin();
                                for (int _i1226 = 0; _i1226 < _list1225.Count; ++_i1226)
                                {
                                    TDDIAbstractAssuranceCasePackage _elem1227;
                                    _elem1227 = new TDDIAbstractAssuranceCasePackage();
                                    _elem1227.Read(iprot);
                                    AssuranceCasePackage.Add(_elem1227);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                Interface = new List <TDDIAssuranceCasePackageInterfaceRef>();
                                TList _list1228 = iprot.ReadListBegin();
                                for (int _i1229 = 0; _i1229 < _list1228.Count; ++_i1229)
                                {
                                    TDDIAssuranceCasePackageInterfaceRef _elem1230;
                                    _elem1230 = new TDDIAssuranceCasePackageInterfaceRef();
                                    _elem1230.Read(iprot);
                                    Interface.Add(_elem1230);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.List)
                        {
                            {
                                ArtifactPackage = new List <TDDIAbstractArtifactPackage>();
                                TList _list1231 = iprot.ReadListBegin();
                                for (int _i1232 = 0; _i1232 < _list1231.Count; ++_i1232)
                                {
                                    TDDIAbstractArtifactPackage _elem1233;
                                    _elem1233 = new TDDIAbstractArtifactPackage();
                                    _elem1233.Read(iprot);
                                    ArtifactPackage.Add(_elem1233);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.List)
                        {
                            {
                                ArgumentPackage = new List <TDDIAbstractArgumentPackage>();
                                TList _list1234 = iprot.ReadListBegin();
                                for (int _i1235 = 0; _i1235 < _list1234.Count; ++_i1235)
                                {
                                    TDDIAbstractArgumentPackage _elem1236;
                                    _elem1236 = new TDDIAbstractArgumentPackage();
                                    _elem1236.Read(iprot);
                                    ArgumentPackage.Add(_elem1236);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                TerminologyPackage = new List <TDDIAbstractTerminologyPackage>();
                                TList _list1237 = iprot.ReadListBegin();
                                for (int _i1238 = 0; _i1238 < _list1237.Count; ++_i1238)
                                {
                                    TDDIAbstractTerminologyPackage _elem1239;
                                    _elem1239 = new TDDIAbstractTerminologyPackage();
                                    _elem1239.Read(iprot);
                                    TerminologyPackage.Add(_elem1239);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.List)
                        {
                            {
                                ParticipantPackage = new List <TDDIAbstractAssuranceCasePackageRef>();
                                TList _list1240 = iprot.ReadListBegin();
                                for (int _i1241 = 0; _i1241 < _list1240.Count; ++_i1241)
                                {
                                    TDDIAbstractAssuranceCasePackageRef _elem1242;
                                    _elem1242 = new TDDIAbstractAssuranceCasePackageRef();
                                    _elem1242.Read(iprot);
                                    ParticipantPackage.Add(_elem1242);
                                }
                                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.String)
                        {
                            Gid = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

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

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

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

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                ImplementationConstraint = new List <TDDIImplementationConstraintRef>();
                                TList _list1184 = iprot.ReadListBegin();
                                for (int _i1185 = 0; _i1185 < _list1184.Count; ++_i1185)
                                {
                                    TDDIImplementationConstraintRef _elem1186;
                                    _elem1186 = new TDDIImplementationConstraintRef();
                                    _elem1186.Read(iprot);
                                    ImplementationConstraint.Add(_elem1186);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                Note = new List <TDDINoteRef>();
                                TList _list1187 = iprot.ReadListBegin();
                                for (int _i1188 = 0; _i1188 < _list1187.Count; ++_i1188)
                                {
                                    TDDINoteRef _elem1189;
                                    _elem1189 = new TDDINoteRef();
                                    _elem1189.Read(iprot);
                                    Note.Add(_elem1189);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                TaggedValue = new List <TDDITaggedValueRef>();
                                TList _list1190 = iprot.ReadListBegin();
                                for (int _i1191 = 0; _i1191 < _list1190.Count; ++_i1191)
                                {
                                    TDDITaggedValueRef _elem1192;
                                    _elem1192 = new TDDITaggedValueRef();
                                    _elem1192.Read(iprot);
                                    TaggedValue.Add(_elem1192);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                AssuranceCasePackage = new List <TDDIAbstractAssuranceCasePackage>();
                                TList _list1193 = iprot.ReadListBegin();
                                for (int _i1194 = 0; _i1194 < _list1193.Count; ++_i1194)
                                {
                                    TDDIAbstractAssuranceCasePackage _elem1195;
                                    _elem1195 = new TDDIAbstractAssuranceCasePackage();
                                    _elem1195.Read(iprot);
                                    AssuranceCasePackage.Add(_elem1195);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                Interface = new List <TDDIAssuranceCasePackageInterfaceRef>();
                                TList _list1196 = iprot.ReadListBegin();
                                for (int _i1197 = 0; _i1197 < _list1196.Count; ++_i1197)
                                {
                                    TDDIAssuranceCasePackageInterfaceRef _elem1198;
                                    _elem1198 = new TDDIAssuranceCasePackageInterfaceRef();
                                    _elem1198.Read(iprot);
                                    Interface.Add(_elem1198);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.List)
                        {
                            {
                                ArtifactPackage = new List <TDDIAbstractArtifactPackage>();
                                TList _list1199 = iprot.ReadListBegin();
                                for (int _i1200 = 0; _i1200 < _list1199.Count; ++_i1200)
                                {
                                    TDDIAbstractArtifactPackage _elem1201;
                                    _elem1201 = new TDDIAbstractArtifactPackage();
                                    _elem1201.Read(iprot);
                                    ArtifactPackage.Add(_elem1201);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.List)
                        {
                            {
                                ArgumentPackage = new List <TDDIAbstractArgumentPackage>();
                                TList _list1202 = iprot.ReadListBegin();
                                for (int _i1203 = 0; _i1203 < _list1202.Count; ++_i1203)
                                {
                                    TDDIAbstractArgumentPackage _elem1204;
                                    _elem1204 = new TDDIAbstractArgumentPackage();
                                    _elem1204.Read(iprot);
                                    ArgumentPackage.Add(_elem1204);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                TerminologyPackage = new List <TDDIAbstractTerminologyPackage>();
                                TList _list1205 = iprot.ReadListBegin();
                                for (int _i1206 = 0; _i1206 < _list1205.Count; ++_i1206)
                                {
                                    TDDIAbstractTerminologyPackage _elem1207;
                                    _elem1207 = new TDDIAbstractTerminologyPackage();
                                    _elem1207.Read(iprot);
                                    TerminologyPackage.Add(_elem1207);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.Struct)
                        {
                            Implements = new TDDIAbstractAssuranceCasePackage();
                            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.String)
                        {
                            Gid = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

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

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

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

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                ImplementationConstraint = new List <TDDIImplementationConstraintRef>();
                                TList _list1528 = iprot.ReadListBegin();
                                for (int _i1529 = 0; _i1529 < _list1528.Count; ++_i1529)
                                {
                                    TDDIImplementationConstraintRef _elem1530;
                                    _elem1530 = new TDDIImplementationConstraintRef();
                                    _elem1530.Read(iprot);
                                    ImplementationConstraint.Add(_elem1530);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                Note = new List <TDDINoteRef>();
                                TList _list1531 = iprot.ReadListBegin();
                                for (int _i1532 = 0; _i1532 < _list1531.Count; ++_i1532)
                                {
                                    TDDINoteRef _elem1533;
                                    _elem1533 = new TDDINoteRef();
                                    _elem1533.Read(iprot);
                                    Note.Add(_elem1533);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                TaggedValue = new List <TDDITaggedValueRef>();
                                TList _list1534 = iprot.ReadListBegin();
                                for (int _i1535 = 0; _i1535 < _list1534.Count; ++_i1535)
                                {
                                    TDDITaggedValueRef _elem1536;
                                    _elem1536 = new TDDITaggedValueRef();
                                    _elem1536.Read(iprot);
                                    TaggedValue.Add(_elem1536);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                TerminologyElement = new List <TDDIAbstractTerminologyElement>();
                                TList _list1537 = iprot.ReadListBegin();
                                for (int _i1538 = 0; _i1538 < _list1537.Count; ++_i1538)
                                {
                                    TDDIAbstractTerminologyElement _elem1539;
                                    _elem1539 = new TDDIAbstractTerminologyElement();
                                    _elem1539.Read(iprot);
                                    TerminologyElement.Add(_elem1539);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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