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();
            }
        }
        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 _list876 = iprot.ReadListBegin();
                                for (int _i877 = 0; _i877 < _list876.Count; ++_i877)
                                {
                                    TDDIImplementationConstraintRef _elem878;
                                    _elem878 = new TDDIImplementationConstraintRef();
                                    _elem878.Read(iprot);
                                    ImplementationConstraint.Add(_elem878);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                MetaClaim = new List <TDDIClaimRef>();
                                TList _list885 = iprot.ReadListBegin();
                                for (int _i886 = 0; _i886 < _list885.Count; ++_i886)
                                {
                                    TDDIClaimRef _elem887;
                                    _elem887 = new TDDIClaimRef();
                                    _elem887.Read(iprot);
                                    MetaClaim.Add(_elem887);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 14:
                        if (field.Type == TType.List)
                        {
                            {
                                Source = new List <TDDIAbstractArgumentAssetRef>();
                                TList _list888 = iprot.ReadListBegin();
                                for (int _i889 = 0; _i889 < _list888.Count; ++_i889)
                                {
                                    TDDIAbstractArgumentAssetRef _elem890;
                                    _elem890 = new TDDIAbstractArgumentAssetRef();
                                    _elem890.Read(iprot);
                                    Source.Add(_elem890);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                Target = new List <TDDIAbstractArgumentAssetRef>();
                                TList _list891 = iprot.ReadListBegin();
                                for (int _i892 = 0; _i892 < _list891.Count; ++_i892)
                                {
                                    TDDIAbstractArgumentAssetRef _elem893;
                                    _elem893 = new TDDIAbstractArgumentAssetRef();
                                    _elem893.Read(iprot);
                                    Target.Add(_elem893);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.Struct)
                        {
                            Reasoning = new TDDIArgumentReasoning();
                            Reasoning.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Example #3
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.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 #4
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 _list1128 = iprot.ReadListBegin();
                                for (int _i1129 = 0; _i1129 < _list1128.Count; ++_i1129)
                                {
                                    TDDIImplementationConstraintRef _elem1130;
                                    _elem1130 = new TDDIImplementationConstraintRef();
                                    _elem1130.Read(iprot);
                                    ImplementationConstraint.Add(_elem1130);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                Property = new List <TDDIPropertyRef>();
                                TList _list1137 = iprot.ReadListBegin();
                                for (int _i1138 = 0; _i1138 < _list1137.Count; ++_i1138)
                                {
                                    TDDIPropertyRef _elem1139;
                                    _elem1139 = new TDDIPropertyRef();
                                    _elem1139.Read(iprot);
                                    Property.Add(_elem1139);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                Source = new List <TDDIAbstractArtifactAssetRef>();
                                TList _list1140 = iprot.ReadListBegin();
                                for (int _i1141 = 0; _i1141 < _list1140.Count; ++_i1141)
                                {
                                    TDDIAbstractArtifactAssetRef _elem1142;
                                    _elem1142 = new TDDIAbstractArtifactAssetRef();
                                    _elem1142.Read(iprot);
                                    Source.Add(_elem1142);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.List)
                        {
                            {
                                Target = new List <TDDIAbstractArtifactAssetRef>();
                                TList _list1143 = iprot.ReadListBegin();
                                for (int _i1144 = 0; _i1144 < _list1143.Count; ++_i1144)
                                {
                                    TDDIAbstractArtifactAssetRef _elem1145;
                                    _elem1145 = new TDDIAbstractArtifactAssetRef();
                                    _elem1145.Read(iprot);
                                    Target.Add(_elem1145);
                                }
                                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 _list1404 = iprot.ReadListBegin();
                                for (int _i1405 = 0; _i1405 < _list1404.Count; ++_i1405)
                                {
                                    TDDIImplementationConstraintRef _elem1406;
                                    _elem1406 = new TDDIImplementationConstraintRef();
                                    _elem1406.Read(iprot);
                                    ImplementationConstraint.Add(_elem1406);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

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

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

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

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                TerminologyPackage = new List <TDDIAbstractTerminologyPackageRef>();
                                TList _list1425 = iprot.ReadListBegin();
                                for (int _i1426 = 0; _i1426 < _list1425.Count; ++_i1426)
                                {
                                    TDDIAbstractTerminologyPackageRef _elem1427;
                                    _elem1427 = new TDDIAbstractTerminologyPackageRef();
                                    _elem1427.Read(iprot);
                                    TerminologyPackage.Add(_elem1427);
                                }
                                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 _list1168 = iprot.ReadListBegin();
                                for (int _i1169 = 0; _i1169 < _list1168.Count; ++_i1169)
                                {
                                    TDDIImplementationConstraintRef _elem1170;
                                    _elem1170 = new TDDIImplementationConstraintRef();
                                    _elem1170.Read(iprot);
                                    ImplementationConstraint.Add(_elem1170);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                ArtifactElement = new List <TDDIAbstractArtifactElementRef>();
                                TList _list1177 = iprot.ReadListBegin();
                                for (int _i1178 = 0; _i1178 < _list1177.Count; ++_i1178)
                                {
                                    TDDIAbstractArtifactElementRef _elem1179;
                                    _elem1179 = new TDDIAbstractArtifactElementRef();
                                    _elem1179.Read(iprot);
                                    ArtifactElement.Add(_elem1179);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Example #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.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 _list1048 = iprot.ReadListBegin();
                                for (int _i1049 = 0; _i1049 < _list1048.Count; ++_i1049)
                                {
                                    TDDIImplementationConstraintRef _elem1050;
                                    _elem1050 = new TDDIImplementationConstraintRef();
                                    _elem1050.Read(iprot);
                                    ImplementationConstraint.Add(_elem1050);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                Property = new List <TDDIPropertyRef>();
                                TList _list1057 = iprot.ReadListBegin();
                                for (int _i1058 = 0; _i1058 < _list1057.Count; ++_i1058)
                                {
                                    TDDIPropertyRef _elem1059;
                                    _elem1059 = new TDDIPropertyRef();
                                    _elem1059.Read(iprot);
                                    Property.Add(_elem1059);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Example #8
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 _list1272 = iprot.ReadListBegin();
                                for (int _i1273 = 0; _i1273 < _list1272.Count; ++_i1273)
                                {
                                    TDDIImplementationConstraintRef _elem1274;
                                    _elem1274 = new TDDIImplementationConstraintRef();
                                    _elem1274.Read(iprot);
                                    ImplementationConstraint.Add(_elem1274);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                TerminologyElement = new List <TDDIAbstractTerminologyElement>();
                                TList _list1281 = iprot.ReadListBegin();
                                for (int _i1282 = 0; _i1282 < _list1281.Count; ++_i1282)
                                {
                                    TDDIAbstractTerminologyElement _elem1283;
                                    _elem1283 = new TDDIAbstractTerminologyElement();
                                    _elem1283.Read(iprot);
                                    TerminologyElement.Add(_elem1283);
                                }
                                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 _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();
            }
        }
Example #11
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 _list1032 = iprot.ReadListBegin();
                                for (int _i1033 = 0; _i1033 < _list1032.Count; ++_i1033)
                                {
                                    TDDIImplementationConstraintRef _elem1034;
                                    _elem1034 = new TDDIImplementationConstraintRef();
                                    _elem1034.Read(iprot);
                                    ImplementationConstraint.Add(_elem1034);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                MetaClaim = new List <TDDIClaimRef>();
                                TList _list1041 = iprot.ReadListBegin();
                                for (int _i1042 = 0; _i1042 < _list1041.Count; ++_i1042)
                                {
                                    TDDIClaimRef _elem1043;
                                    _elem1043 = new TDDIClaimRef();
                                    _elem1043.Read(iprot);
                                    MetaClaim.Add(_elem1043);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Example #12
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 _list1372 = iprot.ReadListBegin();
                                for (int _i1373 = 0; _i1373 < _list1372.Count; ++_i1373)
                                {
                                    TDDIImplementationConstraintRef _elem1374;
                                    _elem1374 = new TDDIImplementationConstraintRef();
                                    _elem1374.Read(iprot);
                                    ImplementationConstraint.Add(_elem1374);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

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

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

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

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

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Example #13
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 _list1096 = iprot.ReadListBegin();
                                for (int _i1097 = 0; _i1097 < _list1096.Count; ++_i1097)
                                {
                                    TDDIImplementationConstraintRef _elem1098;
                                    _elem1098 = new TDDIImplementationConstraintRef();
                                    _elem1098.Read(iprot);
                                    ImplementationConstraint.Add(_elem1098);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                Property = new List <TDDIPropertyRef>();
                                TList _list1105 = iprot.ReadListBegin();
                                for (int _i1106 = 0; _i1106 < _list1105.Count; ++_i1106)
                                {
                                    TDDIPropertyRef _elem1107;
                                    _elem1107 = new TDDIPropertyRef();
                                    _elem1107.Read(iprot);
                                    Property.Add(_elem1107);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Example #14
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();
            }
        }
Example #15
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 _list1120 = iprot.ReadListBegin();
                                for (int _i1121 = 0; _i1121 < _list1120.Count; ++_i1121)
                                {
                                    TDDIImplementationConstraintRef _elem1122;
                                    _elem1122 = new TDDIImplementationConstraintRef();
                                    _elem1122.Read(iprot);
                                    ImplementationConstraint.Add(_elem1122);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                MetaClaim = new List <TDDIClaimRef>();
                                TList _list1129 = iprot.ReadListBegin();
                                for (int _i1130 = 0; _i1130 < _list1129.Count; ++_i1130)
                                {
                                    TDDIClaimRef _elem1131;
                                    _elem1131 = new TDDIClaimRef();
                                    _elem1131.Read(iprot);
                                    MetaClaim.Add(_elem1131);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 14:
                        if (field.Type == TType.List)
                        {
                            {
                                Source = new List <TDDIAbstractArgumentAssetRef>();
                                TList _list1132 = iprot.ReadListBegin();
                                for (int _i1133 = 0; _i1133 < _list1132.Count; ++_i1133)
                                {
                                    TDDIAbstractArgumentAssetRef _elem1134;
                                    _elem1134 = new TDDIAbstractArgumentAssetRef();
                                    _elem1134.Read(iprot);
                                    Source.Add(_elem1134);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                Target = new List <TDDIAbstractArgumentAssetRef>();
                                TList _list1135 = iprot.ReadListBegin();
                                for (int _i1136 = 0; _i1136 < _list1135.Count; ++_i1136)
                                {
                                    TDDIAbstractArgumentAssetRef _elem1137;
                                    _elem1137 = new TDDIAbstractArgumentAssetRef();
                                    _elem1137.Read(iprot);
                                    Target.Add(_elem1137);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.Struct)
                        {
                            Reasoning = new TDDIArgumentReasoning();
                            Reasoning.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 _list1000 = iprot.ReadListBegin();
                                for (int _i1001 = 0; _i1001 < _list1000.Count; ++_i1001)
                                {
                                    TDDIImplementationConstraintRef _elem1002;
                                    _elem1002 = new TDDIImplementationConstraintRef();
                                    _elem1002.Read(iprot);
                                    ImplementationConstraint.Add(_elem1002);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                ArtifactElement = new List <TDDIAbstractArtifactElementRef>();
                                TList _list1009 = iprot.ReadListBegin();
                                for (int _i1010 = 0; _i1010 < _list1009.Count; ++_i1010)
                                {
                                    TDDIAbstractArtifactElementRef _elem1011;
                                    _elem1011 = new TDDIAbstractArtifactElementRef();
                                    _elem1011.Read(iprot);
                                    ArtifactElement.Add(_elem1011);
                                }
                                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 _list1284 = iprot.ReadListBegin();
                                for (int _i1285 = 0; _i1285 < _list1284.Count; ++_i1285)
                                {
                                    TDDIImplementationConstraintRef _elem1286;
                                    _elem1286 = new TDDIImplementationConstraintRef();
                                    _elem1286.Read(iprot);
                                    ImplementationConstraint.Add(_elem1286);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                Property = new List <TDDIPropertyRef>();
                                TList _list1293 = iprot.ReadListBegin();
                                for (int _i1294 = 0; _i1294 < _list1293.Count; ++_i1294)
                                {
                                    TDDIPropertyRef _elem1295;
                                    _elem1295 = new TDDIPropertyRef();
                                    _elem1295.Read(iprot);
                                    Property.Add(_elem1295);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 13:
                        if (field.Type == TType.String)
                        {
                            EndTime = iprot.ReadString();
                        }
                        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 _list1256 = iprot.ReadListBegin();
                                for (int _i1257 = 0; _i1257 < _list1256.Count; ++_i1257)
                                {
                                    TDDIImplementationConstraintRef _elem1258;
                                    _elem1258 = new TDDIImplementationConstraintRef();
                                    _elem1258.Read(iprot);
                                    ImplementationConstraint.Add(_elem1258);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                TerminologyElement = new List <TDDIAbstractTerminologyElement>();
                                TList _list1265 = iprot.ReadListBegin();
                                for (int _i1266 = 0; _i1266 < _list1265.Count; ++_i1266)
                                {
                                    TDDIAbstractTerminologyElement _elem1267;
                                    _elem1267 = new TDDIAbstractTerminologyElement();
                                    _elem1267.Read(iprot);
                                    TerminologyElement.Add(_elem1267);
                                }
                                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 _list1324 = iprot.ReadListBegin();
                                for (int _i1325 = 0; _i1325 < _list1324.Count; ++_i1325)
                                {
                                    TDDIImplementationConstraintRef _elem1326;
                                    _elem1326 = new TDDIImplementationConstraintRef();
                                    _elem1326.Read(iprot);
                                    ImplementationConstraint.Add(_elem1326);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Example #20
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 _list764 = iprot.ReadListBegin();
                                for (int _i765 = 0; _i765 < _list764.Count; ++_i765)
                                {
                                    TDDIImplementationConstraintRef _elem766;
                                    _elem766 = new TDDIImplementationConstraintRef();
                                    _elem766.Read(iprot);
                                    ImplementationConstraint.Add(_elem766);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                ArgumentationElement = new List <TDDIAbstractArgumentationElementRef>();
                                TList _list773 = iprot.ReadListBegin();
                                for (int _i774 = 0; _i774 < _list773.Count; ++_i774)
                                {
                                    TDDIAbstractArgumentationElementRef _elem775;
                                    _elem775 = new TDDIAbstractArgumentationElementRef();
                                    _elem775.Read(iprot);
                                    ArgumentationElement.Add(_elem775);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.Struct)
                        {
                            Implements = new TDDIAbstractArgumentPackage();
                            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 _list952 = iprot.ReadListBegin();
                                for (int _i953 = 0; _i953 < _list952.Count; ++_i953)
                                {
                                    TDDIImplementationConstraintRef _elem954;
                                    _elem954 = new TDDIImplementationConstraintRef();
                                    _elem954.Read(iprot);
                                    ImplementationConstraint.Add(_elem954);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                ArgumentationElement = new List <TDDIAbstractArgumentationElementRef>();
                                TList _list961 = iprot.ReadListBegin();
                                for (int _i962 = 0; _i962 < _list961.Count; ++_i962)
                                {
                                    TDDIAbstractArgumentationElementRef _elem963;
                                    _elem963 = new TDDIAbstractArgumentationElementRef();
                                    _elem963.Read(iprot);
                                    ArgumentationElement.Add(_elem963);
                                }
                                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 _list1048 = iprot.ReadListBegin();
                                for (int _i1049 = 0; _i1049 < _list1048.Count; ++_i1049)
                                {
                                    TDDIImplementationConstraintRef _elem1050;
                                    _elem1050 = new TDDIImplementationConstraintRef();
                                    _elem1050.Read(iprot);
                                    ImplementationConstraint.Add(_elem1050);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                MetaClaim = new List <TDDIClaimRef>();
                                TList _list1057 = iprot.ReadListBegin();
                                for (int _i1058 = 0; _i1058 < _list1057.Count; ++_i1058)
                                {
                                    TDDIClaimRef _elem1059;
                                    _elem1059 = new TDDIClaimRef();
                                    _elem1059.Read(iprot);
                                    MetaClaim.Add(_elem1059);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 14:
                        if (field.Type == TType.List)
                        {
                            {
                                Source = new List <TDDIAbstractArgumentAssetRef>();
                                TList _list1060 = iprot.ReadListBegin();
                                for (int _i1061 = 0; _i1061 < _list1060.Count; ++_i1061)
                                {
                                    TDDIAbstractArgumentAssetRef _elem1062;
                                    _elem1062 = new TDDIAbstractArgumentAssetRef();
                                    _elem1062.Read(iprot);
                                    Source.Add(_elem1062);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                Target = new List <TDDIAbstractArgumentAssetRef>();
                                TList _list1063 = iprot.ReadListBegin();
                                for (int _i1064 = 0; _i1064 < _list1063.Count; ++_i1064)
                                {
                                    TDDIAbstractArgumentAssetRef _elem1065;
                                    _elem1065 = new TDDIAbstractArgumentAssetRef();
                                    _elem1065.Read(iprot);
                                    Target.Add(_elem1065);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.Struct)
                        {
                            Reasoning = new TDDIArgumentReasoning();
                            Reasoning.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 _list900 = iprot.ReadListBegin();
                                for (int _i901 = 0; _i901 < _list900.Count; ++_i901)
                                {
                                    TDDIImplementationConstraintRef _elem902;
                                    _elem902 = new TDDIImplementationConstraintRef();
                                    _elem902.Read(iprot);
                                    ImplementationConstraint.Add(_elem902);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                MetaClaim = new List <TDDIClaimRef>();
                                TList _list909 = iprot.ReadListBegin();
                                for (int _i910 = 0; _i910 < _list909.Count; ++_i910)
                                {
                                    TDDIClaimRef _elem911;
                                    _elem911 = new TDDIClaimRef();
                                    _elem911.Read(iprot);
                                    MetaClaim.Add(_elem911);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 14:
                        if (field.Type == TType.List)
                        {
                            {
                                Source = new List <TDDIAbstractArgumentAssetRef>();
                                TList _list912 = iprot.ReadListBegin();
                                for (int _i913 = 0; _i913 < _list912.Count; ++_i913)
                                {
                                    TDDIAbstractArgumentAssetRef _elem914;
                                    _elem914 = new TDDIAbstractArgumentAssetRef();
                                    _elem914.Read(iprot);
                                    Source.Add(_elem914);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                Target = new List <TDDIAbstractArgumentAssetRef>();
                                TList _list915 = iprot.ReadListBegin();
                                for (int _i916 = 0; _i916 < _list915.Count; ++_i916)
                                {
                                    TDDIAbstractArgumentAssetRef _elem917;
                                    _elem917 = new TDDIAbstractArgumentAssetRef();
                                    _elem917.Read(iprot);
                                    Target.Add(_elem917);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.Struct)
                        {
                            Reasoning = new TDDIArgumentReasoning();
                            Reasoning.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 _list936 = iprot.ReadListBegin();
                                for (int _i937 = 0; _i937 < _list936.Count; ++_i937)
                                {
                                    TDDIImplementationConstraintRef _elem938;
                                    _elem938 = new TDDIImplementationConstraintRef();
                                    _elem938.Read(iprot);
                                    ImplementationConstraint.Add(_elem938);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                ReferencedArtifactElement = new List <TDDIAbstractArtifactElementRef>();
                                TList _list945 = iprot.ReadListBegin();
                                for (int _i946 = 0; _i946 < _list945.Count; ++_i946)
                                {
                                    TDDIAbstractArtifactElementRef _elem947;
                                    _elem947 = new TDDIAbstractArtifactElementRef();
                                    _elem947.Read(iprot);
                                    ReferencedArtifactElement.Add(_elem947);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Example #25
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 _list1080 = iprot.ReadListBegin();
                                for (int _i1081 = 0; _i1081 < _list1080.Count; ++_i1081)
                                {
                                    TDDIImplementationConstraintRef _elem1082;
                                    _elem1082 = new TDDIImplementationConstraintRef();
                                    _elem1082.Read(iprot);
                                    ImplementationConstraint.Add(_elem1082);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                Property = new List <TDDIPropertyRef>();
                                TList _list1089 = iprot.ReadListBegin();
                                for (int _i1090 = 0; _i1090 < _list1089.Count; ++_i1090)
                                {
                                    TDDIPropertyRef _elem1091;
                                    _elem1091 = new TDDIPropertyRef();
                                    _elem1091.Read(iprot);
                                    Property.Add(_elem1091);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Example #26
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 _list1112 = iprot.ReadListBegin();
                                for (int _i1113 = 0; _i1113 < _list1112.Count; ++_i1113)
                                {
                                    TDDIImplementationConstraintRef _elem1114;
                                    _elem1114 = new TDDIImplementationConstraintRef();
                                    _elem1114.Read(iprot);
                                    ImplementationConstraint.Add(_elem1114);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                Property = new List <TDDIPropertyRef>();
                                TList _list1121 = iprot.ReadListBegin();
                                for (int _i1122 = 0; _i1122 < _list1121.Count; ++_i1122)
                                {
                                    TDDIPropertyRef _elem1123;
                                    _elem1123 = new TDDIPropertyRef();
                                    _elem1123.Read(iprot);
                                    Property.Add(_elem1123);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Example #27
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 _list1436 = iprot.ReadListBegin();
                                for (int _i1437 = 0; _i1437 < _list1436.Count; ++_i1437)
                                {
                                    TDDIImplementationConstraintRef _elem1438;
                                    _elem1438 = new TDDIImplementationConstraintRef();
                                    _elem1438.Read(iprot);
                                    ImplementationConstraint.Add(_elem1438);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

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

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

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

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

                    case 16:
                        if (field.Type == TType.List)
                        {
                            {
                                ParticipantPackage = new List <TDDIAbstractAssuranceCasePackageRef>();
                                TList _list1460 = iprot.ReadListBegin();
                                for (int _i1461 = 0; _i1461 < _list1460.Count; ++_i1461)
                                {
                                    TDDIAbstractAssuranceCasePackageRef _elem1462;
                                    _elem1462 = new TDDIAbstractAssuranceCasePackageRef();
                                    _elem1462.Read(iprot);
                                    ParticipantPackage.Add(_elem1462);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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