public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list104 = iprot.ReadListBegin();
for (int _i105 = 0; _i105 < _list104.Count; ++_i105)
{
TDDIKeyValueMapRef _elem106;
_elem106 = new TDDIKeyValueMapRef();
_elem106.Read(iprot);
KeyValueMaps.Add(_elem106);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list107 = iprot.ReadListBegin();
for (int _i108 = 0; _i108 < _list107.Count; ++_i108)
{
TDDIAbstractDependabilityRequirementRef _elem109;
_elem109 = new TDDIAbstractDependabilityRequirementRef();
_elem109.Read(iprot);
DependabilityRequirements.Add(_elem109);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
SubSystems = new List <TDDIAbstractSystemRef>();
TList _list110 = iprot.ReadListBegin();
for (int _i111 = 0; _i111 < _list110.Count; ++_i111)
{
TDDIAbstractSystemRef _elem112;
_elem112 = new TDDIAbstractSystemRef();
_elem112.Read(iprot);
SubSystems.Add(_elem112);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Double)
{
OverallLifetime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I32)
{
OverallLifetimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
RealisedFunctions = new List <TDDIAbstractFunctionRef>();
TList _list113 = iprot.ReadListBegin();
for (int _i114 = 0; _i114 < _list113.Count; ++_i114)
{
TDDIAbstractFunctionRef _elem115;
_elem115 = new TDDIAbstractFunctionRef();
_elem115.Read(iprot);
RealisedFunctions.Add(_elem115);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.List)
{
{
Configurations = new List <TDDIConfiguration>();
TList _list116 = iprot.ReadListBegin();
for (int _i117 = 0; _i117 < _list116.Count; ++_i117)
{
TDDIConfiguration _elem118;
_elem118 = new TDDIConfiguration();
_elem118.Read(iprot);
Configurations.Add(_elem118);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
Contexts = new List <TDDIContext>();
TList _list119 = iprot.ReadListBegin();
for (int _i120 = 0; _i120 < _list119.Count; ++_i120)
{
TDDIContext _elem121;
_elem121 = new TDDIContext();
_elem121.Read(iprot);
Contexts.Add(_elem121);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.List)
{
{
SystemBoundaries = new List <TDDISystemBoundary>();
TList _list122 = iprot.ReadListBegin();
for (int _i123 = 0; _i123 < _list122.Count; ++_i123)
{
TDDISystemBoundary _elem124;
_elem124 = new TDDISystemBoundary();
_elem124.Read(iprot);
SystemBoundaries.Add(_elem124);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.List)
{
{
AppliedStandards = new List <TDDIAbstractStandardRef>();
TList _list125 = iprot.ReadListBegin();
for (int _i126 = 0; _i126 < _list125.Count; ++_i126)
{
TDDIAbstractStandardRef _elem127;
_elem127 = new TDDIAbstractStandardRef();
_elem127.Read(iprot);
AppliedStandards.Add(_elem127);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list128 = iprot.ReadListBegin();
for (int _i129 = 0; _i129 < _list128.Count; ++_i129)
{
TDDIAbstractFailureLogicPackageRef _elem130;
_elem130 = new TDDIAbstractFailureLogicPackageRef();
_elem130.Read(iprot);
FailureModels.Add(_elem130);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPortRef>();
TList _list131 = iprot.ReadListBegin();
for (int _i132 = 0; _i132 < _list131.Count; ++_i132)
{
TDDIPortRef _elem133;
_elem133 = new TDDIPortRef();
_elem133.Read(iprot);
Ports.Add(_elem133);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list784 = iprot.ReadListBegin();
for (int _i785 = 0; _i785 < _list784.Count; ++_i785)
{
TDDIKeyValueMapRef _elem786;
_elem786 = new TDDIKeyValueMapRef();
_elem786.Read(iprot);
KeyValueMaps.Add(_elem786);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
ODEPackages = new List <TDDIAbstractODEPackageRef>();
TList _list787 = iprot.ReadListBegin();
for (int _i788 = 0; _i788 < _list787.Count; ++_i788)
{
TDDIAbstractODEPackageRef _elem789;
_elem789 = new TDDIAbstractODEPackageRef();
_elem789.Read(iprot);
ODEPackages.Add(_elem789);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
ArchitecturePackages = new List <TDDIAbstractArchitecturePackageRef>();
TList _list790 = iprot.ReadListBegin();
for (int _i791 = 0; _i791 < _list790.Count; ++_i791)
{
TDDIAbstractArchitecturePackageRef _elem792;
_elem792 = new TDDIAbstractArchitecturePackageRef();
_elem792.Read(iprot);
ArchitecturePackages.Add(_elem792);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
DependabilityPackages = new List <TDDIAbstractDependabilityPackageRef>();
TList _list793 = iprot.ReadListBegin();
for (int _i794 = 0; _i794 < _list793.Count; ++_i794)
{
TDDIAbstractDependabilityPackageRef _elem795;
_elem795 = new TDDIAbstractDependabilityPackageRef();
_elem795.Read(iprot);
DependabilityPackages.Add(_elem795);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
FailureLogicPackages = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list796 = iprot.ReadListBegin();
for (int _i797 = 0; _i797 < _list796.Count; ++_i797)
{
TDDIAbstractFailureLogicPackageRef _elem798;
_elem798 = new TDDIAbstractFailureLogicPackageRef();
_elem798.Read(iprot);
FailureLogicPackages.Add(_elem798);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
AssuranceCasePackages = new List <TDDIAbstractAssuranceCasePackageRef>();
TList _list799 = iprot.ReadListBegin();
for (int _i800 = 0; _i800 < _list799.Count; ++_i800)
{
TDDIAbstractAssuranceCasePackageRef _elem801;
_elem801 = new TDDIAbstractAssuranceCasePackageRef();
_elem801.Read(iprot);
AssuranceCasePackages.Add(_elem801);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
ParticipantPackages = new List <TDDIAbstractODEPackageRef>();
TList _list802 = iprot.ReadListBegin();
for (int _i803 = 0; _i803 < _list802.Count; ++_i803)
{
TDDIAbstractODEPackageRef _elem804;
_elem804 = new TDDIAbstractODEPackageRef();
_elem804.Read(iprot);
ParticipantPackages.Add(_elem804);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list736 = iprot.ReadListBegin();
for (int _i737 = 0; _i737 < _list736.Count; ++_i737)
{
TDDIKeyValueMapRef _elem738;
_elem738 = new TDDIKeyValueMapRef();
_elem738.Read(iprot);
KeyValueMaps.Add(_elem738);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
ODEPackages = new List <TDDIAbstractODEPackageRef>();
TList _list739 = iprot.ReadListBegin();
for (int _i740 = 0; _i740 < _list739.Count; ++_i740)
{
TDDIAbstractODEPackageRef _elem741;
_elem741 = new TDDIAbstractODEPackageRef();
_elem741.Read(iprot);
ODEPackages.Add(_elem741);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
ArchitecturePackages = new List <TDDIAbstractArchitecturePackageRef>();
TList _list742 = iprot.ReadListBegin();
for (int _i743 = 0; _i743 < _list742.Count; ++_i743)
{
TDDIAbstractArchitecturePackageRef _elem744;
_elem744 = new TDDIAbstractArchitecturePackageRef();
_elem744.Read(iprot);
ArchitecturePackages.Add(_elem744);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
DependabilityPackages = new List <TDDIAbstractDependabilityPackageRef>();
TList _list745 = iprot.ReadListBegin();
for (int _i746 = 0; _i746 < _list745.Count; ++_i746)
{
TDDIAbstractDependabilityPackageRef _elem747;
_elem747 = new TDDIAbstractDependabilityPackageRef();
_elem747.Read(iprot);
DependabilityPackages.Add(_elem747);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
FailureLogicPackages = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list748 = iprot.ReadListBegin();
for (int _i749 = 0; _i749 < _list748.Count; ++_i749)
{
TDDIAbstractFailureLogicPackageRef _elem750;
_elem750 = new TDDIAbstractFailureLogicPackageRef();
_elem750.Read(iprot);
FailureLogicPackages.Add(_elem750);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
AssuranceCasePackages = new List <TDDIAbstractAssuranceCasePackageRef>();
TList _list751 = iprot.ReadListBegin();
for (int _i752 = 0; _i752 < _list751.Count; ++_i752)
{
TDDIAbstractAssuranceCasePackageRef _elem753;
_elem753 = new TDDIAbstractAssuranceCasePackageRef();
_elem753.Read(iprot);
AssuranceCasePackages.Add(_elem753);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list492 = iprot.ReadListBegin();
for (int _i493 = 0; _i493 < _list492.Count; ++_i493)
{
TDDIKeyValueMapRef _elem494;
_elem494 = new TDDIKeyValueMapRef();
_elem494.Read(iprot);
KeyValueMaps.Add(_elem494);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
FailureAnalysisArtifacts = new List <TDDIAbstractFailureAnalysisArtifact>();
TList _list495 = iprot.ReadListBegin();
for (int _i496 = 0; _i496 < _list495.Count; ++_i496)
{
TDDIAbstractFailureAnalysisArtifact _elem497;
_elem497 = new TDDIAbstractFailureAnalysisArtifact();
_elem497.Read(iprot);
FailureAnalysisArtifacts.Add(_elem497);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
ParticipantPackages = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list498 = iprot.ReadListBegin();
for (int _i499 = 0; _i499 < _list498.Count; ++_i499)
{
TDDIAbstractFailureLogicPackageRef _elem500;
_elem500 = new TDDIAbstractFailureLogicPackageRef();
_elem500.Read(iprot);
ParticipantPackages.Add(_elem500);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list284 = iprot.ReadListBegin();
for (int _i285 = 0; _i285 < _list284.Count; ++_i285)
{
TDDIKeyValueMapRef _elem286;
_elem286 = new TDDIKeyValueMapRef();
_elem286.Read(iprot);
KeyValueMaps.Add(_elem286);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list287 = iprot.ReadListBegin();
for (int _i288 = 0; _i288 < _list287.Count; ++_i288)
{
TDDIAbstractDependabilityRequirementRef _elem289;
_elem289 = new TDDIAbstractDependabilityRequirementRef();
_elem289.Read(iprot);
DependabilityRequirements.Add(_elem289);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
SubFunctions = new List <TDDIAbstractFunctionRef>();
TList _list290 = iprot.ReadListBegin();
for (int _i291 = 0; _i291 < _list290.Count; ++_i291)
{
TDDIAbstractFunctionRef _elem292;
_elem292 = new TDDIAbstractFunctionRef();
_elem292.Read(iprot);
SubFunctions.Add(_elem292);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPortRef>();
TList _list293 = iprot.ReadListBegin();
for (int _i294 = 0; _i294 < _list293.Count; ++_i294)
{
TDDIPortRef _elem295;
_elem295 = new TDDIPortRef();
_elem295.Read(iprot);
Ports.Add(_elem295);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Struct)
{
PerfChars = new TDDIPerfChars();
PerfChars.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list296 = iprot.ReadListBegin();
for (int _i297 = 0; _i297 < _list296.Count; ++_i297)
{
TDDIAbstractFailureLogicPackageRef _elem298;
_elem298 = new TDDIAbstractFailureLogicPackageRef();
_elem298.Read(iprot);
FailureModels.Add(_elem298);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.List)
{
{
Malfunctions = new List <TDDIMalFunctionRef>();
TList _list299 = iprot.ReadListBegin();
for (int _i300 = 0; _i300 < _list299.Count; ++_i300)
{
TDDIMalFunctionRef _elem301;
_elem301 = new TDDIMalFunctionRef();
_elem301.Read(iprot);
Malfunctions.Add(_elem301);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list184 = iprot.ReadListBegin();
for (int _i185 = 0; _i185 < _list184.Count; ++_i185)
{
TDDIKeyValueMapRef _elem186;
_elem186 = new TDDIKeyValueMapRef();
_elem186.Read(iprot);
KeyValueMaps.Add(_elem186);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list187 = iprot.ReadListBegin();
for (int _i188 = 0; _i188 < _list187.Count; ++_i188)
{
TDDIAbstractDependabilityRequirementRef _elem189;
_elem189 = new TDDIAbstractDependabilityRequirementRef();
_elem189.Read(iprot);
DependabilityRequirements.Add(_elem189);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
SubSystems = new List <TDDIAbstractSystemRef>();
TList _list190 = iprot.ReadListBegin();
for (int _i191 = 0; _i191 < _list190.Count; ++_i191)
{
TDDIAbstractSystemRef _elem192;
_elem192 = new TDDIAbstractSystemRef();
_elem192.Read(iprot);
SubSystems.Add(_elem192);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Double)
{
OverallLifetime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I32)
{
OverallLifetimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
RealisedFunctions = new List <TDDIAbstractFunctionRef>();
TList _list193 = iprot.ReadListBegin();
for (int _i194 = 0; _i194 < _list193.Count; ++_i194)
{
TDDIAbstractFunctionRef _elem195;
_elem195 = new TDDIAbstractFunctionRef();
_elem195.Read(iprot);
RealisedFunctions.Add(_elem195);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.List)
{
{
Configurations = new List <TDDIConfiguration>();
TList _list196 = iprot.ReadListBegin();
for (int _i197 = 0; _i197 < _list196.Count; ++_i197)
{
TDDIConfiguration _elem198;
_elem198 = new TDDIConfiguration();
_elem198.Read(iprot);
Configurations.Add(_elem198);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
Contexts = new List <TDDIContext>();
TList _list199 = iprot.ReadListBegin();
for (int _i200 = 0; _i200 < _list199.Count; ++_i200)
{
TDDIContext _elem201;
_elem201 = new TDDIContext();
_elem201.Read(iprot);
Contexts.Add(_elem201);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.List)
{
{
SystemBoundaries = new List <TDDISystemBoundary>();
TList _list202 = iprot.ReadListBegin();
for (int _i203 = 0; _i203 < _list202.Count; ++_i203)
{
TDDISystemBoundary _elem204;
_elem204 = new TDDISystemBoundary();
_elem204.Read(iprot);
SystemBoundaries.Add(_elem204);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.List)
{
{
AppliedStandards = new List <TDDIAbstractStandardRef>();
TList _list205 = iprot.ReadListBegin();
for (int _i206 = 0; _i206 < _list205.Count; ++_i206)
{
TDDIAbstractStandardRef _elem207;
_elem207 = new TDDIAbstractStandardRef();
_elem207.Read(iprot);
AppliedStandards.Add(_elem207);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list208 = iprot.ReadListBegin();
for (int _i209 = 0; _i209 < _list208.Count; ++_i209)
{
TDDIAbstractFailureLogicPackageRef _elem210;
_elem210 = new TDDIAbstractFailureLogicPackageRef();
_elem210.Read(iprot);
FailureModels.Add(_elem210);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPortRef>();
TList _list211 = iprot.ReadListBegin();
for (int _i212 = 0; _i212 < _list211.Count; ++_i212)
{
TDDIPortRef _elem213;
_elem213 = new TDDIPortRef();
_elem213.Read(iprot);
Ports.Add(_elem213);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 20:
if (field.Type == TType.String)
{
SafeState = 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.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list760 = iprot.ReadListBegin();
for (int _i761 = 0; _i761 < _list760.Count; ++_i761)
{
TDDIKeyValueMapRef _elem762;
_elem762 = new TDDIKeyValueMapRef();
_elem762.Read(iprot);
KeyValueMaps.Add(_elem762);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
ODEPackages = new List <TDDIAbstractODEPackageRef>();
TList _list763 = iprot.ReadListBegin();
for (int _i764 = 0; _i764 < _list763.Count; ++_i764)
{
TDDIAbstractODEPackageRef _elem765;
_elem765 = new TDDIAbstractODEPackageRef();
_elem765.Read(iprot);
ODEPackages.Add(_elem765);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
ArchitecturePackages = new List <TDDIAbstractArchitecturePackageRef>();
TList _list766 = iprot.ReadListBegin();
for (int _i767 = 0; _i767 < _list766.Count; ++_i767)
{
TDDIAbstractArchitecturePackageRef _elem768;
_elem768 = new TDDIAbstractArchitecturePackageRef();
_elem768.Read(iprot);
ArchitecturePackages.Add(_elem768);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
DependabilityPackages = new List <TDDIAbstractDependabilityPackageRef>();
TList _list769 = iprot.ReadListBegin();
for (int _i770 = 0; _i770 < _list769.Count; ++_i770)
{
TDDIAbstractDependabilityPackageRef _elem771;
_elem771 = new TDDIAbstractDependabilityPackageRef();
_elem771.Read(iprot);
DependabilityPackages.Add(_elem771);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
FailureLogicPackages = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list772 = iprot.ReadListBegin();
for (int _i773 = 0; _i773 < _list772.Count; ++_i773)
{
TDDIAbstractFailureLogicPackageRef _elem774;
_elem774 = new TDDIAbstractFailureLogicPackageRef();
_elem774.Read(iprot);
FailureLogicPackages.Add(_elem774);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
AssuranceCasePackages = new List <TDDIAbstractAssuranceCasePackageRef>();
TList _list775 = iprot.ReadListBegin();
for (int _i776 = 0; _i776 < _list775.Count; ++_i776)
{
TDDIAbstractAssuranceCasePackageRef _elem777;
_elem777 = new TDDIAbstractAssuranceCasePackageRef();
_elem777.Read(iprot);
AssuranceCasePackages.Add(_elem777);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Struct)
{
Implements = new TDDIAbstractODEPackage();
Implements.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list144 = iprot.ReadListBegin();
for (int _i145 = 0; _i145 < _list144.Count; ++_i145)
{
TDDIKeyValueMapRef _elem146;
_elem146 = new TDDIKeyValueMapRef();
_elem146.Read(iprot);
KeyValueMaps.Add(_elem146);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list147 = iprot.ReadListBegin();
for (int _i148 = 0; _i148 < _list147.Count; ++_i148)
{
TDDIAbstractDependabilityRequirementRef _elem149;
_elem149 = new TDDIAbstractDependabilityRequirementRef();
_elem149.Read(iprot);
DependabilityRequirements.Add(_elem149);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
SubSystems = new List <TDDIAbstractSystemRef>();
TList _list150 = iprot.ReadListBegin();
for (int _i151 = 0; _i151 < _list150.Count; ++_i151)
{
TDDIAbstractSystemRef _elem152;
_elem152 = new TDDIAbstractSystemRef();
_elem152.Read(iprot);
SubSystems.Add(_elem152);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Double)
{
OverallLifetime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I32)
{
OverallLifetimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
RealisedFunctions = new List <TDDIAbstractFunctionRef>();
TList _list153 = iprot.ReadListBegin();
for (int _i154 = 0; _i154 < _list153.Count; ++_i154)
{
TDDIAbstractFunctionRef _elem155;
_elem155 = new TDDIAbstractFunctionRef();
_elem155.Read(iprot);
RealisedFunctions.Add(_elem155);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.List)
{
{
Configurations = new List <TDDIConfiguration>();
TList _list156 = iprot.ReadListBegin();
for (int _i157 = 0; _i157 < _list156.Count; ++_i157)
{
TDDIConfiguration _elem158;
_elem158 = new TDDIConfiguration();
_elem158.Read(iprot);
Configurations.Add(_elem158);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
Contexts = new List <TDDIContext>();
TList _list159 = iprot.ReadListBegin();
for (int _i160 = 0; _i160 < _list159.Count; ++_i160)
{
TDDIContext _elem161;
_elem161 = new TDDIContext();
_elem161.Read(iprot);
Contexts.Add(_elem161);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.List)
{
{
SystemBoundaries = new List <TDDISystemBoundary>();
TList _list162 = iprot.ReadListBegin();
for (int _i163 = 0; _i163 < _list162.Count; ++_i163)
{
TDDISystemBoundary _elem164;
_elem164 = new TDDISystemBoundary();
_elem164.Read(iprot);
SystemBoundaries.Add(_elem164);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.List)
{
{
AppliedStandards = new List <TDDIAbstractStandardRef>();
TList _list165 = iprot.ReadListBegin();
for (int _i166 = 0; _i166 < _list165.Count; ++_i166)
{
TDDIAbstractStandardRef _elem167;
_elem167 = new TDDIAbstractStandardRef();
_elem167.Read(iprot);
AppliedStandards.Add(_elem167);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list168 = iprot.ReadListBegin();
for (int _i169 = 0; _i169 < _list168.Count; ++_i169)
{
TDDIAbstractFailureLogicPackageRef _elem170;
_elem170 = new TDDIAbstractFailureLogicPackageRef();
_elem170.Read(iprot);
FailureModels.Add(_elem170);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPortRef>();
TList _list171 = iprot.ReadListBegin();
for (int _i172 = 0; _i172 < _list171.Count; ++_i172)
{
TDDIPortRef _elem173;
_elem173 = new TDDIPortRef();
_elem173.Read(iprot);
Ports.Add(_elem173);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list308 = iprot.ReadListBegin();
for (int _i309 = 0; _i309 < _list308.Count; ++_i309)
{
TDDIKeyValueMapRef _elem310;
_elem310 = new TDDIKeyValueMapRef();
_elem310.Read(iprot);
KeyValueMaps.Add(_elem310);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list311 = iprot.ReadListBegin();
for (int _i312 = 0; _i312 < _list311.Count; ++_i312)
{
TDDIAbstractDependabilityRequirementRef _elem313;
_elem313 = new TDDIAbstractDependabilityRequirementRef();
_elem313.Read(iprot);
DependabilityRequirements.Add(_elem313);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
SubFunctions = new List <TDDIAbstractFunctionRef>();
TList _list314 = iprot.ReadListBegin();
for (int _i315 = 0; _i315 < _list314.Count; ++_i315)
{
TDDIAbstractFunctionRef _elem316;
_elem316 = new TDDIAbstractFunctionRef();
_elem316.Read(iprot);
SubFunctions.Add(_elem316);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPortRef>();
TList _list317 = iprot.ReadListBegin();
for (int _i318 = 0; _i318 < _list317.Count; ++_i318)
{
TDDIPortRef _elem319;
_elem319 = new TDDIPortRef();
_elem319.Read(iprot);
Ports.Add(_elem319);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Struct)
{
PerfChars = new TDDIPerfChars();
PerfChars.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list320 = iprot.ReadListBegin();
for (int _i321 = 0; _i321 < _list320.Count; ++_i321)
{
TDDIAbstractFailureLogicPackageRef _elem322;
_elem322 = new TDDIAbstractFailureLogicPackageRef();
_elem322.Read(iprot);
FailureModels.Add(_elem322);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.List)
{
{
Malfunctions = new List <TDDIMalFunctionRef>();
TList _list323 = iprot.ReadListBegin();
for (int _i324 = 0; _i324 < _list323.Count; ++_i324)
{
TDDIMalFunctionRef _elem325;
_elem325 = new TDDIMalFunctionRef();
_elem325.Read(iprot);
Malfunctions.Add(_elem325);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.String)
{
Object = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.String)
{
Behavior = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.String)
{
SafeState = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
