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 _list1544 = iprot.ReadListBegin();
for (int _i1545 = 0; _i1545 < _list1544.Count; ++_i1545)
{
TDDIImplementationConstraintRef _elem1546;
_elem1546 = new TDDIImplementationConstraintRef();
_elem1546.Read(iprot);
ImplementationConstraint.Add(_elem1546);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Note = new List <TDDINoteRef>();
TList _list1547 = iprot.ReadListBegin();
for (int _i1548 = 0; _i1548 < _list1547.Count; ++_i1548)
{
TDDINoteRef _elem1549;
_elem1549 = new TDDINoteRef();
_elem1549.Read(iprot);
Note.Add(_elem1549);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
TaggedValue = new List <TDDITaggedValueRef>();
TList _list1550 = iprot.ReadListBegin();
for (int _i1551 = 0; _i1551 < _list1550.Count; ++_i1551)
{
TDDITaggedValueRef _elem1552;
_elem1552 = new TDDITaggedValueRef();
_elem1552.Read(iprot);
TaggedValue.Add(_elem1552);
}
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 _list800 = iprot.ReadListBegin();
for (int _i801 = 0; _i801 < _list800.Count; ++_i801)
{
TDDIImplementationConstraintRef _elem802;
_elem802 = new TDDIImplementationConstraintRef();
_elem802.Read(iprot);
ImplementationConstraint.Add(_elem802);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Note = new List <TDDINoteRef>();
TList _list803 = iprot.ReadListBegin();
for (int _i804 = 0; _i804 < _list803.Count; ++_i804)
{
TDDINoteRef _elem805;
_elem805 = new TDDINoteRef();
_elem805.Read(iprot);
Note.Add(_elem805);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
TaggedValue = new List <TDDITaggedValueRef>();
TList _list806 = iprot.ReadListBegin();
for (int _i807 = 0; _i807 < _list806.Count; ++_i807)
{
TDDITaggedValueRef _elem808;
_elem808 = new TDDITaggedValueRef();
_elem808.Read(iprot);
TaggedValue.Add(_elem808);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
Structure = new TDDIAbstractArgumentPackage();
Structure.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 <TDDIAbstractAssuranceCasePackageRef>();
TList _list1225 = iprot.ReadListBegin();
for (int _i1226 = 0; _i1226 < _list1225.Count; ++_i1226)
{
TDDIAbstractAssuranceCasePackageRef _elem1227;
_elem1227 = new TDDIAbstractAssuranceCasePackageRef();
_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 <TDDIAbstractArtifactPackageRef>();
TList _list1231 = iprot.ReadListBegin();
for (int _i1232 = 0; _i1232 < _list1231.Count; ++_i1232)
{
TDDIAbstractArtifactPackageRef _elem1233;
_elem1233 = new TDDIAbstractArtifactPackageRef();
_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 <TDDIAbstractArgumentPackageRef>();
TList _list1234 = iprot.ReadListBegin();
for (int _i1235 = 0; _i1235 < _list1234.Count; ++_i1235)
{
TDDIAbstractArgumentPackageRef _elem1236;
_elem1236 = new TDDIAbstractArgumentPackageRef();
_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 <TDDIAbstractTerminologyPackageRef>();
TList _list1237 = iprot.ReadListBegin();
for (int _i1238 = 0; _i1238 < _list1237.Count; ++_i1238)
{
TDDIAbstractTerminologyPackageRef _elem1239;
_elem1239 = new TDDIAbstractTerminologyPackageRef();
_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 _list1144 = iprot.ReadListBegin();
for (int _i1145 = 0; _i1145 < _list1144.Count; ++_i1145)
{
TDDIImplementationConstraintRef _elem1146;
_elem1146 = new TDDIImplementationConstraintRef();
_elem1146.Read(iprot);
ImplementationConstraint.Add(_elem1146);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Note = new List <TDDINoteRef>();
TList _list1147 = iprot.ReadListBegin();
for (int _i1148 = 0; _i1148 < _list1147.Count; ++_i1148)
{
TDDINoteRef _elem1149;
_elem1149 = new TDDINoteRef();
_elem1149.Read(iprot);
Note.Add(_elem1149);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
TaggedValue = new List <TDDITaggedValueRef>();
TList _list1150 = iprot.ReadListBegin();
for (int _i1151 = 0; _i1151 < _list1150.Count; ++_i1151)
{
TDDITaggedValueRef _elem1152;
_elem1152 = new TDDITaggedValueRef();
_elem1152.Read(iprot);
TaggedValue.Add(_elem1152);
}
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 _list1153 = iprot.ReadListBegin();
for (int _i1154 = 0; _i1154 < _list1153.Count; ++_i1154)
{
TDDIClaimRef _elem1155;
_elem1155 = new TDDIClaimRef();
_elem1155.Read(iprot);
MetaClaim.Add(_elem1155);
}
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 _list1156 = iprot.ReadListBegin();
for (int _i1157 = 0; _i1157 < _list1156.Count; ++_i1157)
{
TDDIAbstractArgumentAssetRef _elem1158;
_elem1158 = new TDDIAbstractArgumentAssetRef();
_elem1158.Read(iprot);
Source.Add(_elem1158);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
Target = new List <TDDIAbstractArgumentAssetRef>();
TList _list1159 = iprot.ReadListBegin();
for (int _i1160 = 0; _i1160 < _list1159.Count; ++_i1160)
{
TDDIAbstractArgumentAssetRef _elem1161;
_elem1161 = new TDDIAbstractArgumentAssetRef();
_elem1161.Read(iprot);
Target.Add(_elem1161);
}
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 _list1252 = iprot.ReadListBegin();
for (int _i1253 = 0; _i1253 < _list1252.Count; ++_i1253)
{
TDDIImplementationConstraintRef _elem1254;
_elem1254 = new TDDIImplementationConstraintRef();
_elem1254.Read(iprot);
ImplementationConstraint.Add(_elem1254);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Note = new List <TDDINoteRef>();
TList _list1255 = iprot.ReadListBegin();
for (int _i1256 = 0; _i1256 < _list1255.Count; ++_i1256)
{
TDDINoteRef _elem1257;
_elem1257 = new TDDINoteRef();
_elem1257.Read(iprot);
Note.Add(_elem1257);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
TaggedValue = new List <TDDITaggedValueRef>();
TList _list1258 = iprot.ReadListBegin();
for (int _i1259 = 0; _i1259 < _list1258.Count; ++_i1259)
{
TDDITaggedValueRef _elem1260;
_elem1260 = new TDDITaggedValueRef();
_elem1260.Read(iprot);
TaggedValue.Add(_elem1260);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
Property = new List <TDDIPropertyRef>();
TList _list1261 = iprot.ReadListBegin();
for (int _i1262 = 0; _i1262 < _list1261.Count; ++_i1262)
{
TDDIPropertyRef _elem1263;
_elem1263 = new TDDIPropertyRef();
_elem1263.Read(iprot);
Property.Add(_elem1263);
}
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 <TDDIAbstractAssuranceCasePackageRef>();
TList _list1193 = iprot.ReadListBegin();
for (int _i1194 = 0; _i1194 < _list1193.Count; ++_i1194)
{
TDDIAbstractAssuranceCasePackageRef _elem1195;
_elem1195 = new TDDIAbstractAssuranceCasePackageRef();
_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 <TDDIAbstractArtifactPackageRef>();
TList _list1199 = iprot.ReadListBegin();
for (int _i1200 = 0; _i1200 < _list1199.Count; ++_i1200)
{
TDDIAbstractArtifactPackageRef _elem1201;
_elem1201 = new TDDIAbstractArtifactPackageRef();
_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 <TDDIAbstractArgumentPackageRef>();
TList _list1202 = iprot.ReadListBegin();
for (int _i1203 = 0; _i1203 < _list1202.Count; ++_i1203)
{
TDDIAbstractArgumentPackageRef _elem1204;
_elem1204 = new TDDIAbstractArgumentPackageRef();
_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 <TDDIAbstractTerminologyPackageRef>();
TList _list1205 = iprot.ReadListBegin();
for (int _i1206 = 0; _i1206 < _list1205.Count; ++_i1206)
{
TDDIAbstractTerminologyPackageRef _elem1207;
_elem1207 = new TDDIAbstractTerminologyPackageRef();
_elem1207.Read(iprot);
TerminologyPackage.Add(_elem1207);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.Struct)
{
Implements = new TDDIAbstractAssuranceCasePackage();
Implements.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
Gid = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractSACMElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Struct)
{
AbstractForm = new TDDIAbstractSACMElement();
AbstractForm.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct)
{
Name = new TDDIAbstractLangString();
Name.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
Description = new TDDIDescription();
Description.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
ImplementationConstraint = new List <TDDIImplementationConstraintRef>();
TList _list1528 = iprot.ReadListBegin();
for (int _i1529 = 0; _i1529 < _list1528.Count; ++_i1529)
{
TDDIImplementationConstraintRef _elem1530;
_elem1530 = new TDDIImplementationConstraintRef();
_elem1530.Read(iprot);
ImplementationConstraint.Add(_elem1530);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Note = new List <TDDINoteRef>();
TList _list1531 = iprot.ReadListBegin();
for (int _i1532 = 0; _i1532 < _list1531.Count; ++_i1532)
{
TDDINoteRef _elem1533;
_elem1533 = new TDDINoteRef();
_elem1533.Read(iprot);
Note.Add(_elem1533);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
TaggedValue = new List <TDDITaggedValueRef>();
TList _list1534 = iprot.ReadListBegin();
for (int _i1535 = 0; _i1535 < _list1534.Count; ++_i1535)
{
TDDITaggedValueRef _elem1536;
_elem1536 = new TDDITaggedValueRef();
_elem1536.Read(iprot);
TaggedValue.Add(_elem1536);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
TerminologyElement = new List <TDDIAbstractTerminologyElement>();
TList _list1537 = iprot.ReadListBegin();
for (int _i1538 = 0; _i1538 < _list1537.Count; ++_i1538)
{
TDDIAbstractTerminologyElement _elem1539;
_elem1539 = new TDDIAbstractTerminologyElement();
_elem1539.Read(iprot);
TerminologyElement.Add(_elem1539);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Struct)
{
Implements = new TDDIAbstractTerminologyPackage();
Implements.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
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 _list1336 = iprot.ReadListBegin();
for (int _i1337 = 0; _i1337 < _list1336.Count; ++_i1337)
{
TDDIImplementationConstraintRef _elem1338;
_elem1338 = new TDDIImplementationConstraintRef();
_elem1338.Read(iprot);
ImplementationConstraint.Add(_elem1338);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Note = new List <TDDINoteRef>();
TList _list1339 = iprot.ReadListBegin();
for (int _i1340 = 0; _i1340 < _list1339.Count; ++_i1340)
{
TDDINoteRef _elem1341;
_elem1341 = new TDDINoteRef();
_elem1341.Read(iprot);
Note.Add(_elem1341);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
TaggedValue = new List <TDDITaggedValueRef>();
TList _list1342 = iprot.ReadListBegin();
for (int _i1343 = 0; _i1343 < _list1342.Count; ++_i1343)
{
TDDITaggedValueRef _elem1344;
_elem1344 = new TDDITaggedValueRef();
_elem1344.Read(iprot);
TaggedValue.Add(_elem1344);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.String)
{
Value = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
Categories = new List <TDDICategoryRef>();
TList _list1345 = iprot.ReadListBegin();
for (int _i1346 = 0; _i1346 < _list1345.Count; ++_i1346)
{
TDDICategoryRef _elem1347;
_elem1347 = new TDDICategoryRef();
_elem1347.Read(iprot);
Categories.Add(_elem1347);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
Element = new List <TDDIAbstractExpressionElementRef>();
TList _list1348 = iprot.ReadListBegin();
for (int _i1349 = 0; _i1349 < _list1348.Count; ++_i1349)
{
TDDIAbstractExpressionElementRef _elem1350;
_elem1350 = new TDDIAbstractExpressionElementRef();
_elem1350.Read(iprot);
Element.Add(_elem1350);
}
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 _list1556 = iprot.ReadListBegin();
for (int _i1557 = 0; _i1557 < _list1556.Count; ++_i1557)
{
TDDIImplementationConstraintRef _elem1558;
_elem1558 = new TDDIImplementationConstraintRef();
_elem1558.Read(iprot);
ImplementationConstraint.Add(_elem1558);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Note = new List <TDDINoteRef>();
TList _list1559 = iprot.ReadListBegin();
for (int _i1560 = 0; _i1560 < _list1559.Count; ++_i1560)
{
TDDINoteRef _elem1561;
_elem1561 = new TDDINoteRef();
_elem1561.Read(iprot);
Note.Add(_elem1561);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
TaggedValue = new List <TDDITaggedValueRef>();
TList _list1562 = iprot.ReadListBegin();
for (int _i1563 = 0; _i1563 < _list1562.Count; ++_i1563)
{
TDDITaggedValueRef _elem1564;
_elem1564 = new TDDITaggedValueRef();
_elem1564.Read(iprot);
TaggedValue.Add(_elem1564);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.String)
{
Value = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Struct)
{
Category = new TDDICategory();
Category.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
Element = new List <TDDIAbstractExpressionElementRef>();
TList _list1565 = iprot.ReadListBegin();
for (int _i1566 = 0; _i1566 < _list1565.Count; ++_i1566)
{
TDDIAbstractExpressionElementRef _elem1567;
_elem1567 = new TDDIAbstractExpressionElementRef();
_elem1567.Read(iprot);
Element.Add(_elem1567);
}
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 _list984 = iprot.ReadListBegin();
for (int _i985 = 0; _i985 < _list984.Count; ++_i985)
{
TDDIImplementationConstraintRef _elem986;
_elem986 = new TDDIImplementationConstraintRef();
_elem986.Read(iprot);
ImplementationConstraint.Add(_elem986);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Note = new List <TDDINoteRef>();
TList _list987 = iprot.ReadListBegin();
for (int _i988 = 0; _i988 < _list987.Count; ++_i988)
{
TDDINoteRef _elem989;
_elem989 = new TDDINoteRef();
_elem989.Read(iprot);
Note.Add(_elem989);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
TaggedValue = new List <TDDITaggedValueRef>();
TList _list990 = iprot.ReadListBegin();
for (int _i991 = 0; _i991 < _list990.Count; ++_i991)
{
TDDITaggedValueRef _elem992;
_elem992 = new TDDITaggedValueRef();
_elem992.Read(iprot);
TaggedValue.Add(_elem992);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
ArgumentationElement = new List <TDDIAbstractArgumentationElementRef>();
TList _list993 = iprot.ReadListBegin();
for (int _i994 = 0; _i994 < _list993.Count; ++_i994)
{
TDDIAbstractArgumentationElementRef _elem995;
_elem995 = new TDDIAbstractArgumentationElementRef();
_elem995.Read(iprot);
ArgumentationElement.Add(_elem995);
}
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 _list1348 = iprot.ReadListBegin();
for (int _i1349 = 0; _i1349 < _list1348.Count; ++_i1349)
{
TDDIImplementationConstraintRef _elem1350;
_elem1350 = new TDDIImplementationConstraintRef();
_elem1350.Read(iprot);
ImplementationConstraint.Add(_elem1350);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Note = new List <TDDINoteRef>();
TList _list1351 = iprot.ReadListBegin();
for (int _i1352 = 0; _i1352 < _list1351.Count; ++_i1352)
{
TDDINoteRef _elem1353;
_elem1353 = new TDDINoteRef();
_elem1353.Read(iprot);
Note.Add(_elem1353);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
TaggedValue = new List <TDDITaggedValueRef>();
TList _list1354 = iprot.ReadListBegin();
for (int _i1355 = 0; _i1355 < _list1354.Count; ++_i1355)
{
TDDITaggedValueRef _elem1356;
_elem1356 = new TDDITaggedValueRef();
_elem1356.Read(iprot);
TaggedValue.Add(_elem1356);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
Property = new List <TDDIPropertyRef>();
TList _list1357 = iprot.ReadListBegin();
for (int _i1358 = 0; _i1358 < _list1357.Count; ++_i1358)
{
TDDIPropertyRef _elem1359;
_elem1359 = new TDDIPropertyRef();
_elem1359.Read(iprot);
Property.Add(_elem1359);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
Source = new List <TDDIAbstractArtifactAssetRef>();
TList _list1360 = iprot.ReadListBegin();
for (int _i1361 = 0; _i1361 < _list1360.Count; ++_i1361)
{
TDDIAbstractArtifactAssetRef _elem1362;
_elem1362 = new TDDIAbstractArtifactAssetRef();
_elem1362.Read(iprot);
Source.Add(_elem1362);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
Target = new List <TDDIAbstractArtifactAssetRef>();
TList _list1363 = iprot.ReadListBegin();
for (int _i1364 = 0; _i1364 < _list1363.Count; ++_i1364)
{
TDDIAbstractArtifactAssetRef _elem1365;
_elem1365 = new TDDIAbstractArtifactAssetRef();
_elem1365.Read(iprot);
Target.Add(_elem1365);
}
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 _list828 = iprot.ReadListBegin();
for (int _i829 = 0; _i829 < _list828.Count; ++_i829)
{
TDDIImplementationConstraintRef _elem830;
_elem830 = new TDDIImplementationConstraintRef();
_elem830.Read(iprot);
ImplementationConstraint.Add(_elem830);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Note = new List <TDDINoteRef>();
TList _list831 = iprot.ReadListBegin();
for (int _i832 = 0; _i832 < _list831.Count; ++_i832)
{
TDDINoteRef _elem833;
_elem833 = new TDDINoteRef();
_elem833.Read(iprot);
Note.Add(_elem833);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
TaggedValue = new List <TDDITaggedValueRef>();
TList _list834 = iprot.ReadListBegin();
for (int _i835 = 0; _i835 < _list834.Count; ++_i835)
{
TDDITaggedValueRef _elem836;
_elem836 = new TDDITaggedValueRef();
_elem836.Read(iprot);
TaggedValue.Add(_elem836);
}
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 _list837 = iprot.ReadListBegin();
for (int _i838 = 0; _i838 < _list837.Count; ++_i838)
{
TDDIClaimRef _elem839;
_elem839 = new TDDIClaimRef();
_elem839.Read(iprot);
MetaClaim.Add(_elem839);
}
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 _list840 = iprot.ReadListBegin();
for (int _i841 = 0; _i841 < _list840.Count; ++_i841)
{
TDDIAbstractArgumentAssetRef _elem842;
_elem842 = new TDDIAbstractArgumentAssetRef();
_elem842.Read(iprot);
Source.Add(_elem842);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
Target = new List <TDDIAbstractArgumentAssetRef>();
TList _list843 = iprot.ReadListBegin();
for (int _i844 = 0; _i844 < _list843.Count; ++_i844)
{
TDDIAbstractArgumentAssetRef _elem845;
_elem845 = new TDDIAbstractArgumentAssetRef();
_elem845.Read(iprot);
Target.Add(_elem845);
}
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 _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();
}
}
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 <TDDIAbstractAssuranceCasePackageRef>();
TList _list1161 = iprot.ReadListBegin();
for (int _i1162 = 0; _i1162 < _list1161.Count; ++_i1162)
{
TDDIAbstractAssuranceCasePackageRef _elem1163;
_elem1163 = new TDDIAbstractAssuranceCasePackageRef();
_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 <TDDIAbstractArtifactPackageRef>();
TList _list1167 = iprot.ReadListBegin();
for (int _i1168 = 0; _i1168 < _list1167.Count; ++_i1168)
{
TDDIAbstractArtifactPackageRef _elem1169;
_elem1169 = new TDDIAbstractArtifactPackageRef();
_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 <TDDIAbstractArgumentPackageRef>();
TList _list1170 = iprot.ReadListBegin();
for (int _i1171 = 0; _i1171 < _list1170.Count; ++_i1171)
{
TDDIAbstractArgumentPackageRef _elem1172;
_elem1172 = new TDDIAbstractArgumentPackageRef();
_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 <TDDIAbstractTerminologyPackageRef>();
TList _list1173 = iprot.ReadListBegin();
for (int _i1174 = 0; _i1174 < _list1173.Count; ++_i1174)
{
TDDIAbstractTerminologyPackageRef _elem1175;
_elem1175 = new TDDIAbstractTerminologyPackageRef();
_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();
}
}