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.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list680 = iprot.ReadListBegin();
for (int _i681 = 0; _i681 < _list680.Count; ++_i681)
{
TDDIKeyValueMap _elem682;
_elem682 = new TDDIKeyValueMap();
_elem682.Read(iprot);
KeyValueMaps.Add(_elem682);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
DecompositionArgument = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
RefinedRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list683 = iprot.ReadListBegin();
for (int _i684 = 0; _i684 < _list683.Count; ++_i684)
{
TDDIAbstractDependabilityRequirementRef _elem685;
_elem685 = new TDDIAbstractDependabilityRequirementRef();
_elem685.Read(iprot);
RefinedRequirements.Add(_elem685);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
RequirementSource = new TDDIAbstractRequirementSource();
RequirementSource.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
Measures = new List <TDDIAbstractMeasureRef>();
TList _list686 = iprot.ReadListBegin();
for (int _i687 = 0; _i687 < _list686.Count; ++_i687)
{
TDDIAbstractMeasureRef _elem688;
_elem688 = new TDDIAbstractMeasureRef();
_elem688.Read(iprot);
Measures.Add(_elem688);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Failures = new List <TDDIAbstractFailureRef>();
TList _list689 = iprot.ReadListBegin();
for (int _i690 = 0; _i690 < _list689.Count; ++_i690)
{
TDDIAbstractFailureRef _elem691;
_elem691 = new TDDIAbstractFailureRef();
_elem691.Read(iprot);
Failures.Add(_elem691);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
MaintenanceProcedures = new List <TDDIMaintenanceProcedureRef>();
TList _list692 = iprot.ReadListBegin();
for (int _i693 = 0; _i693 < _list692.Count; ++_i693)
{
TDDIMaintenanceProcedureRef _elem694;
_elem694 = new TDDIMaintenanceProcedureRef();
_elem694.Read(iprot);
MaintenanceProcedures.Add(_elem694);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
SecurityCapabilities = new List <TDDISecurityCapabilityRef>();
TList _list695 = iprot.ReadListBegin();
for (int _i696 = 0; _i696 < _list695.Count; ++_i696)
{
TDDISecurityCapabilityRef _elem697;
_elem697 = new TDDISecurityCapabilityRef();
_elem697.Read(iprot);
SecurityCapabilities.Add(_elem697);
}
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.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list396 = iprot.ReadListBegin();
for (int _i397 = 0; _i397 < _list396.Count; ++_i397)
{
TDDIKeyValueMap _elem398;
_elem398 = new TDDIKeyValueMap();
_elem398.Read(iprot);
KeyValueMaps.Add(_elem398);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32)
{
OriginType = (TDDIFailureOriginType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
FailureClass = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Double)
{
FailureRate = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.Bool)
{
IsCCF = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
CCFFailures = new List <TDDIAbstractFailureRef>();
TList _list399 = iprot.ReadListBegin();
for (int _i400 = 0; _i400 < _list399.Count; ++_i400)
{
TDDIAbstractFailureRef _elem401;
_elem401 = new TDDIAbstractFailureRef();
_elem401.Read(iprot);
CCFFailures.Add(_elem401);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Struct)
{
FailureProbDistribution = new TDDIProbDist();
FailureProbDistribution.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.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list52 = iprot.ReadListBegin();
for (int _i53 = 0; _i53 < _list52.Count; ++_i53)
{
TDDIKeyValueMap _elem54;
_elem54 = new TDDIKeyValueMap();
_elem54.Read(iprot);
KeyValueMaps.Add(_elem54);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list55 = iprot.ReadListBegin();
for (int _i56 = 0; _i56 < _list55.Count; ++_i56)
{
TDDIAbstractDependabilityRequirementRef _elem57;
_elem57 = new TDDIAbstractDependabilityRequirementRef();
_elem57.Read(iprot);
DependabilityRequirements.Add(_elem57);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
FlowType = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.I32)
{
Direction = (TDDIPortDirection)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
RefinedPorts = new List <TDDIPortRef>();
TList _list58 = iprot.ReadListBegin();
for (int _i59 = 0; _i59 < _list58.Count; ++_i59)
{
TDDIPortRef _elem60;
_elem60 = new TDDIPortRef();
_elem60.Read(iprot);
RefinedPorts.Add(_elem60);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
InterfaceFailures = new List <TDDIAbstractFailureRef>();
TList _list61 = iprot.ReadListBegin();
for (int _i62 = 0; _i62 < _list61.Count; ++_i62)
{
TDDIAbstractFailureRef _elem63;
_elem63 = new TDDIAbstractFailureRef();
_elem63.Read(iprot);
InterfaceFailures.Add(_elem63);
}
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.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list544 = iprot.ReadListBegin();
for (int _i545 = 0; _i545 < _list544.Count; ++_i545)
{
TDDIKeyValueMap _elem546;
_elem546 = new TDDIKeyValueMap();
_elem546.Read(iprot);
KeyValueMaps.Add(_elem546);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
Condition = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct)
{
HazardType = new TDDIHazardType();
HazardType.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.List)
{
{
Measures = new List <TDDIAbstractMeasureRef>();
TList _list547 = iprot.ReadListBegin();
for (int _i548 = 0; _i548 < _list547.Count; ++_i548)
{
TDDIAbstractMeasureRef _elem549;
_elem549 = new TDDIAbstractMeasureRef();
_elem549.Read(iprot);
Measures.Add(_elem549);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
Failures = new List <TDDIAbstractFailureRef>();
TList _list550 = iprot.ReadListBegin();
for (int _i551 = 0; _i551 < _list550.Count; ++_i551)
{
TDDIAbstractFailureRef _elem552;
_elem552 = new TDDIAbstractFailureRef();
_elem552.Read(iprot);
Failures.Add(_elem552);
}
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.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list412 = iprot.ReadListBegin();
for (int _i413 = 0; _i413 < _list412.Count; ++_i413)
{
TDDIKeyValueMap _elem414;
_elem414 = new TDDIKeyValueMap();
_elem414.Read(iprot);
KeyValueMaps.Add(_elem414);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
Failures = new List <TDDIAbstractFailureRef>();
TList _list415 = iprot.ReadListBegin();
for (int _i416 = 0; _i416 < _list415.Count; ++_i416)
{
TDDIAbstractFailureRef _elem417;
_elem417 = new TDDIAbstractFailureRef();
_elem417.Read(iprot);
Failures.Add(_elem417);
}
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.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list656 = iprot.ReadListBegin();
for (int _i657 = 0; _i657 < _list656.Count; ++_i657)
{
TDDIKeyValueMap _elem658;
_elem658 = new TDDIKeyValueMap();
_elem658.Read(iprot);
KeyValueMaps.Add(_elem658);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
DecompositionArgument = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
RefinedRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list659 = iprot.ReadListBegin();
for (int _i660 = 0; _i660 < _list659.Count; ++_i660)
{
TDDIAbstractDependabilityRequirementRef _elem661;
_elem661 = new TDDIAbstractDependabilityRequirementRef();
_elem661.Read(iprot);
RefinedRequirements.Add(_elem661);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
RequirementSource = new TDDIAbstractRequirementSource();
RequirementSource.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
Measures = new List <TDDIAbstractMeasureRef>();
TList _list662 = iprot.ReadListBegin();
for (int _i663 = 0; _i663 < _list662.Count; ++_i663)
{
TDDIAbstractMeasureRef _elem664;
_elem664 = new TDDIAbstractMeasureRef();
_elem664.Read(iprot);
Measures.Add(_elem664);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Failures = new List <TDDIAbstractFailureRef>();
TList _list665 = iprot.ReadListBegin();
for (int _i666 = 0; _i666 < _list665.Count; ++_i666)
{
TDDIAbstractFailureRef _elem667;
_elem667 = new TDDIAbstractFailureRef();
_elem667.Read(iprot);
Failures.Add(_elem667);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
MaintenanceProcedures = new List <TDDIMaintenanceProcedureRef>();
TList _list668 = iprot.ReadListBegin();
for (int _i669 = 0; _i669 < _list668.Count; ++_i669)
{
TDDIMaintenanceProcedureRef _elem670;
_elem670 = new TDDIMaintenanceProcedureRef();
_elem670.Read(iprot);
MaintenanceProcedures.Add(_elem670);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
Hazards = new List <TDDIHazardRef>();
TList _list671 = iprot.ReadListBegin();
for (int _i672 = 0; _i672 < _list671.Count; ++_i672)
{
TDDIHazardRef _elem673;
_elem673 = new TDDIHazardRef();
_elem673.Read(iprot);
Hazards.Add(_elem673);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Double)
{
FailureReactionTime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.Double)
{
FailureDetectionTime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.Double)
{
FailureLatencyTime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
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.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list420 = iprot.ReadListBegin();
for (int _i421 = 0; _i421 < _list420.Count; ++_i421)
{
TDDIKeyValueMap _elem422;
_elem422 = new TDDIKeyValueMap();
_elem422.Read(iprot);
KeyValueMaps.Add(_elem422);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
Cutsets = new List <TDDIMinimalCutSet>();
TList _list423 = iprot.ReadListBegin();
for (int _i424 = 0; _i424 < _list423.Count; ++_i424)
{
TDDIMinimalCutSet _elem425;
_elem425 = new TDDIMinimalCutSet();
_elem425.Read(iprot);
Cutsets.Add(_elem425);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
Failures = new List <TDDIAbstractFailureRef>();
TList _list426 = iprot.ReadListBegin();
for (int _i427 = 0; _i427 < _list426.Count; ++_i427)
{
TDDIAbstractFailureRef _elem428;
_elem428 = new TDDIAbstractFailureRef();
_elem428.Read(iprot);
Failures.Add(_elem428);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}