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 _list860 = iprot.ReadListBegin();
for (int _i861 = 0; _i861 < _list860.Count; ++_i861)
{
TDDIKeyValueMapRef _elem862;
_elem862 = new TDDIKeyValueMapRef();
_elem862.Read(iprot);
KeyValueMaps.Add(_elem862);
}
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 <TDDIAbstractFailureAnalysisArtifactRef>();
TList _list863 = iprot.ReadListBegin();
for (int _i864 = 0; _i864 < _list863.Count; ++_i864)
{
TDDIAbstractFailureAnalysisArtifactRef _elem865;
_elem865 = new TDDIAbstractFailureAnalysisArtifactRef();
_elem865.Read(iprot);
FailureAnalysisArtifacts.Add(_elem865);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
MarkovArtifacts = new List <TDDIAbstractMarkovArtifact>();
TList _list866 = iprot.ReadListBegin();
for (int _i867 = 0; _i867 < _list866.Count; ++_i867)
{
TDDIAbstractMarkovArtifact _elem868;
_elem868 = new TDDIAbstractMarkovArtifact();
_elem868.Read(iprot);
MarkovArtifacts.Add(_elem868);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
FailStates = new List <TDDIFailState>();
TList _list869 = iprot.ReadListBegin();
for (int _i870 = 0; _i870 < _list869.Count; ++_i870)
{
TDDIFailState _elem871;
_elem871 = new TDDIFailState();
_elem871.Read(iprot);
FailStates.Add(_elem871);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
ParticipantPackages = new List <TDDIAbstractMarkovChainPackageRef>();
TList _list872 = iprot.ReadListBegin();
for (int _i873 = 0; _i873 < _list872.Count; ++_i873)
{
TDDIAbstractMarkovChainPackageRef _elem874;
_elem874 = new TDDIAbstractMarkovChainPackageRef();
_elem874.Read(iprot);
ParticipantPackages.Add(_elem874);
}
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 _list636 = iprot.ReadListBegin();
for (int _i637 = 0; _i637 < _list636.Count; ++_i637)
{
TDDIKeyValueMapRef _elem638;
_elem638 = new TDDIKeyValueMapRef();
_elem638.Read(iprot);
KeyValueMaps.Add(_elem638);
}
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 <TDDIAbstractFailureAnalysisArtifactRef>();
TList _list639 = iprot.ReadListBegin();
for (int _i640 = 0; _i640 < _list639.Count; ++_i640)
{
TDDIAbstractFailureAnalysisArtifactRef _elem641;
_elem641 = new TDDIAbstractFailureAnalysisArtifactRef();
_elem641.Read(iprot);
FailureAnalysisArtifacts.Add(_elem641);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
FTAArtifacts = new List <TDDIAbstractFTAArtifact>();
TList _list642 = iprot.ReadListBegin();
for (int _i643 = 0; _i643 < _list642.Count; ++_i643)
{
TDDIAbstractFTAArtifact _elem644;
_elem644 = new TDDIAbstractFTAArtifact();
_elem644.Read(iprot);
FTAArtifacts.Add(_elem644);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
BasicEvents = new List <TDDIBasicEvent>();
TList _list645 = iprot.ReadListBegin();
for (int _i646 = 0; _i646 < _list645.Count; ++_i646)
{
TDDIBasicEvent _elem647;
_elem647 = new TDDIBasicEvent();
_elem647.Read(iprot);
BasicEvents.Add(_elem647);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
ParticipantPackages = new List <TDDIAbstractFTAPackageRef>();
TList _list648 = iprot.ReadListBegin();
for (int _i649 = 0; _i649 < _list648.Count; ++_i649)
{
TDDIAbstractFTAPackageRef _elem650;
_elem650 = new TDDIAbstractFTAPackageRef();
_elem650.Read(iprot);
ParticipantPackages.Add(_elem650);
}
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 _list388 = iprot.ReadListBegin();
for (int _i389 = 0; _i389 < _list388.Count; ++_i389)
{
TDDIKeyValueMapRef _elem390;
_elem390 = new TDDIKeyValueMapRef();
_elem390.Read(iprot);
KeyValueMaps.Add(_elem390);
}
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)
{
{
DomainElements = new List <TDDIAbstractDomainElementRef>();
TList _list391 = iprot.ReadListBegin();
for (int _i392 = 0; _i392 < _list391.Count; ++_i392)
{
TDDIAbstractDomainElementRef _elem393;
_elem393 = new TDDIAbstractDomainElementRef();
_elem393.Read(iprot);
DomainElements.Add(_elem393);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
Implements = new TDDIAbstractDomainPackage();
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 _list48 = iprot.ReadListBegin();
for (int _i49 = 0; _i49 < _list48.Count; ++_i49)
{
TDDIKeyValueMapRef _elem50;
_elem50 = new TDDIKeyValueMapRef();
_elem50.Read(iprot);
KeyValueMaps.Add(_elem50);
}
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 _list51 = iprot.ReadListBegin();
for (int _i52 = 0; _i52 < _list51.Count; ++_i52)
{
TDDIAbstractDependabilityRequirementRef _elem53;
_elem53 = new TDDIAbstractDependabilityRequirementRef();
_elem53.Read(iprot);
DependabilityRequirements.Add(_elem53);
}
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.String)
{
FlowType = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.I32)
{
Direction = (TDDIPortDirection)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
RefinedPorts = new List <TDDIPortRef>();
TList _list54 = iprot.ReadListBegin();
for (int _i55 = 0; _i55 < _list54.Count; ++_i55)
{
TDDIPortRef _elem56;
_elem56 = new TDDIPortRef();
_elem56.Read(iprot);
RefinedPorts.Add(_elem56);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
InterfaceFailures = new List <TDDIAbstractInterfaceFailureRef>();
TList _list57 = iprot.ReadListBegin();
for (int _i58 = 0; _i58 < _list57.Count; ++_i58)
{
TDDIAbstractInterfaceFailureRef _elem59;
_elem59 = new TDDIAbstractInterfaceFailureRef();
_elem59.Read(iprot);
InterfaceFailures.Add(_elem59);
}
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 _list40 = iprot.ReadListBegin();
for (int _i41 = 0; _i41 < _list40.Count; ++_i41)
{
TDDIKeyValueMapRef _elem42;
_elem42 = new TDDIKeyValueMapRef();
_elem42.Read(iprot);
KeyValueMaps.Add(_elem42);
}
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 _list43 = iprot.ReadListBegin();
for (int _i44 = 0; _i44 < _list43.Count; ++_i44)
{
TDDIAbstractDependabilityRequirementRef _elem45;
_elem45 = new TDDIAbstractDependabilityRequirementRef();
_elem45.Read(iprot);
DependabilityRequirements.Add(_elem45);
}
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.Double)
{
ResponseTime = iprot.ReadDouble();
}
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 _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 _list376 = iprot.ReadListBegin();
for (int _i377 = 0; _i377 < _list376.Count; ++_i377)
{
TDDIKeyValueMapRef _elem378;
_elem378 = new TDDIKeyValueMapRef();
_elem378.Read(iprot);
KeyValueMaps.Add(_elem378);
}
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.String)
{
ActivityDescription = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.String)
{
TechnicalDescription = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
ToolSpecification = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.I32)
{
StaffNumber = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.String)
{
StaffSkillLevel = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.String)
{
StafftrainingDescription = 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 _list504 = iprot.ReadListBegin();
for (int _i505 = 0; _i505 < _list504.Count; ++_i505)
{
TDDIKeyValueMapRef _elem506;
_elem506 = new TDDIKeyValueMapRef();
_elem506.Read(iprot);
KeyValueMaps.Add(_elem506);
}
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 <TDDIAbstractFailureAnalysisArtifactRef>();
TList _list507 = iprot.ReadListBegin();
for (int _i508 = 0; _i508 < _list507.Count; ++_i508)
{
TDDIAbstractFailureAnalysisArtifactRef _elem509;
_elem509 = new TDDIAbstractFailureAnalysisArtifactRef();
_elem509.Read(iprot);
FailureAnalysisArtifacts.Add(_elem509);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
FMEAArtifacts = new List <TDDIAbstractFMEAArtifactRef>();
TList _list510 = iprot.ReadListBegin();
for (int _i511 = 0; _i511 < _list510.Count; ++_i511)
{
TDDIAbstractFMEAArtifactRef _elem512;
_elem512 = new TDDIAbstractFMEAArtifactRef();
_elem512.Read(iprot);
FMEAArtifacts.Add(_elem512);
}
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 _list84 = iprot.ReadListBegin();
for (int _i85 = 0; _i85 < _list84.Count; ++_i85)
{
TDDIKeyValueMapRef _elem86;
_elem86 = new TDDIKeyValueMapRef();
_elem86.Read(iprot);
KeyValueMaps.Add(_elem86);
}
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 _list87 = iprot.ReadListBegin();
for (int _i88 = 0; _i88 < _list87.Count; ++_i88)
{
TDDIAbstractDependabilityRequirementRef _elem89;
_elem89 = new TDDIAbstractDependabilityRequirementRef();
_elem89.Read(iprot);
DependabilityRequirements.Add(_elem89);
}
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.String)
{
UsageHistory = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Double)
{
MissionTime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I32)
{
MissionTimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
}
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 _list828 = iprot.ReadListBegin();
for (int _i829 = 0; _i829 < _list828.Count; ++_i829)
{
TDDIKeyValueMapRef _elem830;
_elem830 = new TDDIKeyValueMapRef();
_elem830.Read(iprot);
KeyValueMaps.Add(_elem830);
}
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 <TDDIAbstractFailureAnalysisArtifactRef>();
TList _list831 = iprot.ReadListBegin();
for (int _i832 = 0; _i832 < _list831.Count; ++_i832)
{
TDDIAbstractFailureAnalysisArtifactRef _elem833;
_elem833 = new TDDIAbstractFailureAnalysisArtifactRef();
_elem833.Read(iprot);
FailureAnalysisArtifacts.Add(_elem833);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
MarkovArtifacts = new List <TDDIAbstractMarkovArtifact>();
TList _list834 = iprot.ReadListBegin();
for (int _i835 = 0; _i835 < _list834.Count; ++_i835)
{
TDDIAbstractMarkovArtifact _elem836;
_elem836 = new TDDIAbstractMarkovArtifact();
_elem836.Read(iprot);
MarkovArtifacts.Add(_elem836);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
FailStates = new List <TDDIFailState>();
TList _list837 = iprot.ReadListBegin();
for (int _i838 = 0; _i838 < _list837.Count; ++_i838)
{
TDDIFailState _elem839;
_elem839 = new TDDIFailState();
_elem839.Read(iprot);
FailStates.Add(_elem839);
}
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 _list684 = iprot.ReadListBegin();
for (int _i685 = 0; _i685 < _list684.Count; ++_i685)
{
TDDIKeyValueMapRef _elem686;
_elem686 = new TDDIKeyValueMapRef();
_elem686.Read(iprot);
KeyValueMaps.Add(_elem686);
}
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.String)
{
Condition = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
HazardType = new TDDIHazardType();
HazardType.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
Measures = new List <TDDIAbstractMeasureRef>();
TList _list687 = iprot.ReadListBegin();
for (int _i688 = 0; _i688 < _list687.Count; ++_i688)
{
TDDIAbstractMeasureRef _elem689;
_elem689 = new TDDIAbstractMeasureRef();
_elem689.Read(iprot);
Measures.Add(_elem689);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
OutputFailure = new TDDIOutputFailure();
OutputFailure.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 _list352 = iprot.ReadListBegin();
for (int _i353 = 0; _i353 < _list352.Count; ++_i353)
{
TDDIKeyValueMapRef _elem354;
_elem354 = new TDDIKeyValueMapRef();
_elem354.Read(iprot);
KeyValueMaps.Add(_elem354);
}
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)
{
{
DependabilityArtifacts = new List <TDDIAbstractDependabilityArtifactRef>();
TList _list355 = iprot.ReadListBegin();
for (int _i356 = 0; _i356 < _list355.Count; ++_i356)
{
TDDIAbstractDependabilityArtifactRef _elem357;
_elem357 = new TDDIAbstractDependabilityArtifactRef();
_elem357.Read(iprot);
DependabilityArtifacts.Add(_elem357);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
ParticipantPackages = new List <TDDIAbstractDependabilityPackageRef>();
TList _list358 = iprot.ReadListBegin();
for (int _i359 = 0; _i359 < _list358.Count; ++_i359)
{
TDDIAbstractDependabilityPackageRef _elem360;
_elem360 = new TDDIAbstractDependabilityPackageRef();
_elem360.Read(iprot);
ParticipantPackages.Add(_elem360);
}
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 _list724 = iprot.ReadListBegin();
for (int _i725 = 0; _i725 < _list724.Count; ++_i725)
{
TDDIKeyValueMapRef _elem726;
_elem726 = new TDDIKeyValueMapRef();
_elem726.Read(iprot);
KeyValueMaps.Add(_elem726);
}
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)
{
{
HARAArtifacts = new List <TDDIAbstractHARAArtifact>();
TList _list727 = iprot.ReadListBegin();
for (int _i728 = 0; _i728 < _list727.Count; ++_i728)
{
TDDIAbstractHARAArtifact _elem729;
_elem729 = new TDDIAbstractHARAArtifact();
_elem729.Read(iprot);
HARAArtifacts.Add(_elem729);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
ParticipantPackages = new List <TDDIAbstractHARAPackageRef>();
TList _list730 = iprot.ReadListBegin();
for (int _i731 = 0; _i731 < _list730.Count; ++_i731)
{
TDDIAbstractHARAPackageRef _elem732;
_elem732 = new TDDIAbstractHARAPackageRef();
_elem732.Read(iprot);
ParticipantPackages.Add(_elem732);
}
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 _list412 = iprot.ReadListBegin();
for (int _i413 = 0; _i413 < _list412.Count; ++_i413)
{
TDDIKeyValueMapRef _elem414;
_elem414 = new TDDIKeyValueMapRef();
_elem414.Read(iprot);
KeyValueMaps.Add(_elem414);
}
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;
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 _list824 = iprot.ReadListBegin();
for (int _i825 = 0; _i825 < _list824.Count; ++_i825)
{
TDDIKeyValueMapRef _elem826;
_elem826 = new TDDIKeyValueMapRef();
_elem826.Read(iprot);
KeyValueMaps.Add(_elem826);
}
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.Double)
{
Probability = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
ProbabilityDistribution = new TDDIProbabilityDistribution();
ProbabilityDistribution.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Struct)
{
FromFailState = new TDDIFailState();
FromFailState.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
ToFailState = new TDDIFailState();
ToFailState.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Struct)
{
FromState = new TDDIState();
FromState.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Struct)
{
ToState = new TDDIState();
ToState.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 _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
{
bool isset_FromPort = false;
bool isset_ToPort = false;
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 _list64 = iprot.ReadListBegin();
for (int _i65 = 0; _i65 < _list64.Count; ++_i65)
{
TDDIKeyValueMapRef _elem66;
_elem66 = new TDDIKeyValueMapRef();
_elem66.Read(iprot);
KeyValueMaps.Add(_elem66);
}
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 _list67 = iprot.ReadListBegin();
for (int _i68 = 0; _i68 < _list67.Count; ++_i68)
{
TDDIAbstractDependabilityRequirementRef _elem69;
_elem69 = new TDDIAbstractDependabilityRequirementRef();
_elem69.Read(iprot);
DependabilityRequirements.Add(_elem69);
}
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.Struct)
{
FromPort = new TDDIPort();
FromPort.Read(iprot);
isset_FromPort = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
ToPort = new TDDIPort();
ToPort.Read(iprot);
isset_ToPort = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_FromPort)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field FromPort not set");
}
if (!isset_ToPort)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field ToPort not set");
}
}
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 _list476 = iprot.ReadListBegin();
for (int _i477 = 0; _i477 < _list476.Count; ++_i477)
{
TDDIKeyValueMapRef _elem478;
_elem478 = new TDDIKeyValueMapRef();
_elem478.Read(iprot);
KeyValueMaps.Add(_elem478);
}
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 _list479 = iprot.ReadListBegin();
for (int _i480 = 0; _i480 < _list479.Count; ++_i480)
{
TDDIAbstractFailureAnalysisArtifact _elem481;
_elem481 = new TDDIAbstractFailureAnalysisArtifact();
_elem481.Read(iprot);
FailureAnalysisArtifacts.Add(_elem481);
}
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 _list912 = iprot.ReadListBegin();
for (int _i913 = 0; _i913 < _list912.Count; ++_i913)
{
TDDIKeyValueMapRef _elem914;
_elem914 = new TDDIKeyValueMapRef();
_elem914.Read(iprot);
KeyValueMaps.Add(_elem914);
}
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.String)
{
DecompositionArgument = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
RefinedRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list915 = iprot.ReadListBegin();
for (int _i916 = 0; _i916 < _list915.Count; ++_i916)
{
TDDIAbstractDependabilityRequirementRef _elem917;
_elem917 = new TDDIAbstractDependabilityRequirementRef();
_elem917.Read(iprot);
RefinedRequirements.Add(_elem917);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Struct)
{
RequirementSource = new TDDIAbstractRequirementSource();
RequirementSource.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
Measures = new List <TDDIAbstractMeasureRef>();
TList _list918 = iprot.ReadListBegin();
for (int _i919 = 0; _i919 < _list918.Count; ++_i919)
{
TDDIAbstractMeasureRef _elem920;
_elem920 = new TDDIAbstractMeasureRef();
_elem920.Read(iprot);
Measures.Add(_elem920);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
FailureModes = new List <TDDIAbstractFailureRef>();
TList _list921 = iprot.ReadListBegin();
for (int _i922 = 0; _i922 < _list921.Count; ++_i922)
{
TDDIAbstractFailureRef _elem923;
_elem923 = new TDDIAbstractFailureRef();
_elem923.Read(iprot);
FailureModes.Add(_elem923);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.List)
{
{
MaintenanceProcedures = new List <TDDIMaintenanceProcedureRef>();
TList _list924 = iprot.ReadListBegin();
for (int _i925 = 0; _i925 < _list924.Count; ++_i925)
{
TDDIMaintenanceProcedureRef _elem926;
_elem926 = new TDDIMaintenanceProcedureRef();
_elem926.Read(iprot);
MaintenanceProcedures.Add(_elem926);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
Hazards = new List <TDDIHazardRef>();
TList _list927 = iprot.ReadListBegin();
for (int _i928 = 0; _i928 < _list927.Count; ++_i928)
{
TDDIHazardRef _elem929;
_elem929 = new TDDIHazardRef();
_elem929.Read(iprot);
Hazards.Add(_elem929);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.Double)
{
FailureReactionTime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.Double)
{
FailureDetectionTime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.Double)
{
FailureLatencyTime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.Bool)
{
IsSafetyGoal = iprot.ReadBool();
}
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 _list368 = iprot.ReadListBegin();
for (int _i369 = 0; _i369 < _list368.Count; ++_i369)
{
TDDIKeyValueMapRef _elem370;
_elem370 = new TDDIKeyValueMapRef();
_elem370.Read(iprot);
KeyValueMaps.Add(_elem370);
}
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.String)
{
IntrinsicSafety = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.String)
{
SafeGuard = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
ApplierInformation = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Bool)
{
RiskAcceptability = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.String)
{
FurtherAction = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.String)
{
Source = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.Struct)
{
MeasureType = new TDDIMeasureType();
MeasureType.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 _list72 = iprot.ReadListBegin();
for (int _i73 = 0; _i73 < _list72.Count; ++_i73)
{
TDDIKeyValueMapRef _elem74;
_elem74 = new TDDIKeyValueMapRef();
_elem74.Read(iprot);
KeyValueMaps.Add(_elem74);
}
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 _list75 = iprot.ReadListBegin();
for (int _i76 = 0; _i76 < _list75.Count; ++_i76)
{
TDDIAbstractDependabilityRequirementRef _elem77;
_elem77 = new TDDIAbstractDependabilityRequirementRef();
_elem77.Read(iprot);
DependabilityRequirements.Add(_elem77);
}
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 _list78 = iprot.ReadListBegin();
for (int _i79 = 0; _i79 < _list78.Count; ++_i79)
{
TDDIAbstractSystemRef _elem80;
_elem80 = new TDDIAbstractSystemRef();
_elem80.Read(iprot);
SubSystems.Add(_elem80);
}
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 _list224 = iprot.ReadListBegin();
for (int _i225 = 0; _i225 < _list224.Count; ++_i225)
{
TDDIKeyValueMapRef _elem226;
_elem226 = new TDDIKeyValueMapRef();
_elem226.Read(iprot);
KeyValueMaps.Add(_elem226);
}
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 _list227 = iprot.ReadListBegin();
for (int _i228 = 0; _i228 < _list227.Count; ++_i228)
{
TDDIAbstractDependabilityRequirementRef _elem229;
_elem229 = new TDDIAbstractDependabilityRequirementRef();
_elem229.Read(iprot);
DependabilityRequirements.Add(_elem229);
}
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.String)
{
Value = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
Conditions = new List <TDDILifecycleConditionRef>();
TList _list230 = iprot.ReadListBegin();
for (int _i231 = 0; _i231 < _list230.Count; ++_i231)
{
TDDILifecycleConditionRef _elem232;
_elem232 = new TDDILifecycleConditionRef();
_elem232.Read(iprot);
Conditions.Add(_elem232);
}
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 _list844 = iprot.ReadListBegin();
for (int _i845 = 0; _i845 < _list844.Count; ++_i845)
{
TDDIKeyValueMapRef _elem846;
_elem846 = new TDDIKeyValueMapRef();
_elem846.Read(iprot);
KeyValueMaps.Add(_elem846);
}
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 <TDDIAbstractFailureAnalysisArtifactRef>();
TList _list847 = iprot.ReadListBegin();
for (int _i848 = 0; _i848 < _list847.Count; ++_i848)
{
TDDIAbstractFailureAnalysisArtifactRef _elem849;
_elem849 = new TDDIAbstractFailureAnalysisArtifactRef();
_elem849.Read(iprot);
FailureAnalysisArtifacts.Add(_elem849);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
MarkovArtifacts = new List <TDDIAbstractMarkovArtifact>();
TList _list850 = iprot.ReadListBegin();
for (int _i851 = 0; _i851 < _list850.Count; ++_i851)
{
TDDIAbstractMarkovArtifact _elem852;
_elem852 = new TDDIAbstractMarkovArtifact();
_elem852.Read(iprot);
MarkovArtifacts.Add(_elem852);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
FailStates = new List <TDDIFailState>();
TList _list853 = iprot.ReadListBegin();
for (int _i854 = 0; _i854 < _list853.Count; ++_i854)
{
TDDIFailState _elem855;
_elem855 = new TDDIFailState();
_elem855.Read(iprot);
FailStates.Add(_elem855);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
Implements = new TDDIAbstractMarkovChainPackage();
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 _list620 = iprot.ReadListBegin();
for (int _i621 = 0; _i621 < _list620.Count; ++_i621)
{
TDDIKeyValueMapRef _elem622;
_elem622 = new TDDIKeyValueMapRef();
_elem622.Read(iprot);
KeyValueMaps.Add(_elem622);
}
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 <TDDIAbstractFailureAnalysisArtifactRef>();
TList _list623 = iprot.ReadListBegin();
for (int _i624 = 0; _i624 < _list623.Count; ++_i624)
{
TDDIAbstractFailureAnalysisArtifactRef _elem625;
_elem625 = new TDDIAbstractFailureAnalysisArtifactRef();
_elem625.Read(iprot);
FailureAnalysisArtifacts.Add(_elem625);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
FTAArtifacts = new List <TDDIAbstractFTAArtifact>();
TList _list626 = iprot.ReadListBegin();
for (int _i627 = 0; _i627 < _list626.Count; ++_i627)
{
TDDIAbstractFTAArtifact _elem628;
_elem628 = new TDDIAbstractFTAArtifact();
_elem628.Read(iprot);
FTAArtifacts.Add(_elem628);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
BasicEvents = new List <TDDIBasicEvent>();
TList _list629 = iprot.ReadListBegin();
for (int _i630 = 0; _i630 < _list629.Count; ++_i630)
{
TDDIBasicEvent _elem631;
_elem631 = new TDDIBasicEvent();
_elem631.Read(iprot);
BasicEvents.Add(_elem631);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
Implements = new TDDIAbstractFTAPackage();
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 _list716 = iprot.ReadListBegin();
for (int _i717 = 0; _i717 < _list716.Count; ++_i717)
{
TDDIKeyValueMapRef _elem718;
_elem718 = new TDDIKeyValueMapRef();
_elem718.Read(iprot);
KeyValueMaps.Add(_elem718);
}
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)
{
{
HARAArtifacts = new List <TDDIAbstractHARAArtifact>();
TList _list719 = iprot.ReadListBegin();
for (int _i720 = 0; _i720 < _list719.Count; ++_i720)
{
TDDIAbstractHARAArtifact _elem721;
_elem721 = new TDDIAbstractHARAArtifact();
_elem721.Read(iprot);
HARAArtifacts.Add(_elem721);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
Implements = new TDDIAbstractHARAPackage();
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 _list448 = iprot.ReadListBegin();
for (int _i449 = 0; _i449 < _list448.Count; ++_i449)
{
TDDIKeyValueMapRef _elem450;
_elem450 = new TDDIKeyValueMapRef();
_elem450.Read(iprot);
KeyValueMaps.Add(_elem450);
}
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.Double)
{
FailureRate = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
FailureMode = new TDDIFailureMode();
FailureMode.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Struct)
{
ProbabilityDistribution = new TDDIProbabilityDistribution();
ProbabilityDistribution.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
MinimalCutsets = new List <TDDIMinimalCutset>();
TList _list451 = iprot.ReadListBegin();
for (int _i452 = 0; _i452 < _list451.Count; ++_i452)
{
TDDIMinimalCutset _elem453;
_elem453 = new TDDIMinimalCutset();
_elem453.Read(iprot);
MinimalCutsets.Add(_elem453);
}
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();
}
}
