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();
}
}
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();
}
}
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();
}
}
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();
}
}
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();
}
}
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();
}
}
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();
}
}
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();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
Gid = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractSACMElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Struct)
{
AbstractForm = new TDDIAbstractSACMElement();
AbstractForm.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct)
{
Name = new TDDIAbstractLangString();
Name.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
Description = new TDDIDescription();
Description.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
ImplementationConstraint = new List <TDDIImplementationConstraintRef>();
TList _list1508 = iprot.ReadListBegin();
for (int _i1509 = 0; _i1509 < _list1508.Count; ++_i1509)
{
TDDIImplementationConstraintRef _elem1510;
_elem1510 = new TDDIImplementationConstraintRef();
_elem1510.Read(iprot);
ImplementationConstraint.Add(_elem1510);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Note = new List <TDDINoteRef>();
TList _list1511 = iprot.ReadListBegin();
for (int _i1512 = 0; _i1512 < _list1511.Count; ++_i1512)
{
TDDINoteRef _elem1513;
_elem1513 = new TDDINoteRef();
_elem1513.Read(iprot);
Note.Add(_elem1513);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
TaggedValue = new List <TDDITaggedValueRef>();
TList _list1514 = iprot.ReadListBegin();
for (int _i1515 = 0; _i1515 < _list1514.Count; ++_i1515)
{
TDDITaggedValueRef _elem1516;
_elem1516 = new TDDITaggedValueRef();
_elem1516.Read(iprot);
TaggedValue.Add(_elem1516);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
TerminologyElement = new List <TDDIAbstractTerminologyElement>();
TList _list1517 = iprot.ReadListBegin();
for (int _i1518 = 0; _i1518 < _list1517.Count; ++_i1518)
{
TDDIAbstractTerminologyElement _elem1519;
_elem1519 = new TDDIAbstractTerminologyElement();
_elem1519.Read(iprot);
TerminologyElement.Add(_elem1519);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
ParticipantPackage = new List <TDDIAbstractTerminologyPackage>();
TList _list1520 = iprot.ReadListBegin();
for (int _i1521 = 0; _i1521 < _list1520.Count; ++_i1521)
{
TDDIAbstractTerminologyPackage _elem1522;
_elem1522 = new TDDIAbstractTerminologyPackage();
_elem1522.Read(iprot);
ParticipantPackage.Add(_elem1522);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
Gid = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractSACMElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Struct)
{
AbstractForm = new TDDIAbstractSACMElement();
AbstractForm.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct)
{
Name = new TDDIAbstractLangString();
Name.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
Description = new TDDIDescription();
Description.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
ImplementationConstraint = new List <TDDIImplementationConstraintRef>();
TList _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();
}
}
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();
}
}
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();
}
}
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();
}
}
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();
}
}