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.Struct)
{
Ref = new TDDIKeyValueMap();
Ref.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 _list196 = iprot.ReadListBegin();
for (int _i197 = 0; _i197 < _list196.Count; ++_i197)
{
TDDIKeyValueMap _elem198;
_elem198 = new TDDIKeyValueMap();
_elem198.Read(iprot);
KeyValueMaps.Add(_elem198);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Double)
{
OverallLifetime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I32)
{
OverallLifetimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
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 8:
if (field.Type == TType.List)
{
{
Configurations = new List <TDDIConfiguration>();
TList _list202 = iprot.ReadListBegin();
for (int _i203 = 0; _i203 < _list202.Count; ++_i203)
{
TDDIConfiguration _elem204;
_elem204 = new TDDIConfiguration();
_elem204.Read(iprot);
Configurations.Add(_elem204);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPort>();
TList _list205 = iprot.ReadListBegin();
for (int _i206 = 0; _i206 < _list205.Count; ++_i206)
{
TDDIPort _elem207;
_elem207 = new TDDIPort();
_elem207.Read(iprot);
Ports.Add(_elem207);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
Signals = new List <TDDISignal>();
TList _list208 = iprot.ReadListBegin();
for (int _i209 = 0; _i209 < _list208.Count; ++_i209)
{
TDDISignal _elem210;
_elem210 = new TDDISignal();
_elem210.Read(iprot);
Signals.Add(_elem210);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
SystemBoundaries = new List <TDDISystemBoundary>();
TList _list211 = iprot.ReadListBegin();
for (int _i212 = 0; _i212 < _list211.Count; ++_i212)
{
TDDISystemBoundary _elem213;
_elem213 = new TDDISystemBoundary();
_elem213.Read(iprot);
SystemBoundaries.Add(_elem213);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
AppliedStandards = new List <TDDIAbstractStandardRef>();
TList _list214 = iprot.ReadListBegin();
for (int _i215 = 0; _i215 < _list214.Count; ++_i215)
{
TDDIAbstractStandardRef _elem216;
_elem216 = new TDDIAbstractStandardRef();
_elem216.Read(iprot);
AppliedStandards.Add(_elem216);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
RealisedFunctions = new List <TDDIAbstractFunctionRef>();
TList _list217 = iprot.ReadListBegin();
for (int _i218 = 0; _i218 < _list217.Count; ++_i218)
{
TDDIAbstractFunctionRef _elem219;
_elem219 = new TDDIAbstractFunctionRef();
_elem219.Read(iprot);
RealisedFunctions.Add(_elem219);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.Struct)
{
AsAsset = new TDDIAbstractAsset();
AsAsset.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list220 = iprot.ReadListBegin();
for (int _i221 = 0; _i221 < _list220.Count; ++_i221)
{
TDDIAbstractDependabilityRequirementRef _elem222;
_elem222 = new TDDIAbstractDependabilityRequirementRef();
_elem222.Read(iprot);
DependabilityRequirements.Add(_elem222);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureModelRef>();
TList _list223 = iprot.ReadListBegin();
for (int _i224 = 0; _i224 < _list223.Count; ++_i224)
{
TDDIAbstractFailureModelRef _elem225;
_elem225 = new TDDIAbstractFailureModelRef();
_elem225.Read(iprot);
FailureModels.Add(_elem225);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.List)
{
{
SubSystems = new List <TDDIAbstractSystemRef>();
TList _list226 = iprot.ReadListBegin();
for (int _i227 = 0; _i227 < _list226.Count; ++_i227)
{
TDDIAbstractSystemRef _elem228;
_elem228 = new TDDIAbstractSystemRef();
_elem228.Read(iprot);
SubSystems.Add(_elem228);
}
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 _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.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list84 = iprot.ReadListBegin();
for (int _i85 = 0; _i85 < _list84.Count; ++_i85)
{
TDDIKeyValueMap _elem86;
_elem86 = new TDDIKeyValueMap();
_elem86.Read(iprot);
KeyValueMaps.Add(_elem86);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
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 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.List)
{
{
SubFunctions = new List <TDDIAbstractFunctionRef>();
TList _list90 = iprot.ReadListBegin();
for (int _i91 = 0; _i91 < _list90.Count; ++_i91)
{
TDDIAbstractFunctionRef _elem92;
_elem92 = new TDDIAbstractFunctionRef();
_elem92.Read(iprot);
SubFunctions.Add(_elem92);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPort>();
TList _list93 = iprot.ReadListBegin();
for (int _i94 = 0; _i94 < _list93.Count; ++_i94)
{
TDDIPort _elem95;
_elem95 = new TDDIPort();
_elem95.Read(iprot);
Ports.Add(_elem95);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Signals = new List <TDDISignal>();
TList _list96 = iprot.ReadListBegin();
for (int _i97 = 0; _i97 < _list96.Count; ++_i97)
{
TDDISignal _elem98;
_elem98 = new TDDISignal();
_elem98.Read(iprot);
Signals.Add(_elem98);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Struct)
{
PerfChars = new TDDIPerfChars();
PerfChars.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureModelRef>();
TList _list99 = iprot.ReadListBegin();
for (int _i100 = 0; _i100 < _list99.Count; ++_i100)
{
TDDIAbstractFailureModelRef _elem101;
_elem101 = new TDDIAbstractFailureModelRef();
_elem101.Read(iprot);
FailureModels.Add(_elem101);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
Malfunctions = new List <TDDIMalfunctionRef>();
TList _list102 = iprot.ReadListBegin();
for (int _i103 = 0; _i103 < _list102.Count; ++_i103)
{
TDDIMalfunctionRef _elem104;
_elem104 = new TDDIMalfunctionRef();
_elem104.Read(iprot);
Malfunctions.Add(_elem104);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Struct)
{
AsAsset = new TDDIAbstractAsset();
AsAsset.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 _list456 = iprot.ReadListBegin();
for (int _i457 = 0; _i457 < _list456.Count; ++_i457)
{
TDDIKeyValueMap _elem458;
_elem458 = new TDDIKeyValueMap();
_elem458.Read(iprot);
KeyValueMaps.Add(_elem458);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Struct)
{
Effect = new TDDIAbstractFailure();
Effect.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct)
{
Mode = new TDDIAbstractFailure();
Mode.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 _list520 = iprot.ReadListBegin();
for (int _i521 = 0; _i521 < _list520.Count; ++_i521)
{
TDDIKeyValueMap _elem522;
_elem522 = new TDDIKeyValueMap();
_elem522.Read(iprot);
KeyValueMaps.Add(_elem522);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
HazardTypes = new List <TDDIHazardTypeRef>();
TList _list523 = iprot.ReadListBegin();
for (int _i524 = 0; _i524 < _list523.Count; ++_i524)
{
TDDIHazardTypeRef _elem525;
_elem525 = new TDDIHazardTypeRef();
_elem525.Read(iprot);
HazardTypes.Add(_elem525);
}
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 _list344 = iprot.ReadListBegin();
for (int _i345 = 0; _i345 < _list344.Count; ++_i345)
{
TDDIKeyValueMap _elem346;
_elem346 = new TDDIKeyValueMap();
_elem346.Read(iprot);
KeyValueMaps.Add(_elem346);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
Systems = new List <TDDIAbstractSystem>();
TList _list347 = iprot.ReadListBegin();
for (int _i348 = 0; _i348 < _list347.Count; ++_i348)
{
TDDIAbstractSystem _elem349;
_elem349 = new TDDIAbstractSystem();
_elem349.Read(iprot);
Systems.Add(_elem349);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
Functions = new List <TDDIAbstractFunction>();
TList _list350 = iprot.ReadListBegin();
for (int _i351 = 0; _i351 < _list350.Count; ++_i351)
{
TDDIAbstractFunction _elem352;
_elem352 = new TDDIAbstractFunction();
_elem352.Read(iprot);
Functions.Add(_elem352);
}
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 _list600 = iprot.ReadListBegin();
for (int _i601 = 0; _i601 < _list600.Count; ++_i601)
{
TDDIKeyValueMap _elem602;
_elem602 = new TDDIKeyValueMap();
_elem602.Read(iprot);
KeyValueMaps.Add(_elem602);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
ODEProductPackages = new List <TDDIAbstractODEProductPackage>();
TList _list603 = iprot.ReadListBegin();
for (int _i604 = 0; _i604 < _list603.Count; ++_i604)
{
TDDIAbstractODEProductPackage _elem605;
_elem605 = new TDDIAbstractODEProductPackage();
_elem605.Read(iprot);
ODEProductPackages.Add(_elem605);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
AssuranceCasePackages = new List <TDDIAbstractAssuranceCasePackage>();
TList _list606 = iprot.ReadListBegin();
for (int _i607 = 0; _i607 < _list606.Count; ++_i607)
{
TDDIAbstractAssuranceCasePackage _elem608;
_elem608 = new TDDIAbstractAssuranceCasePackage();
_elem608.Read(iprot);
AssuranceCasePackages.Add(_elem608);
}
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 _list448 = iprot.ReadListBegin();
for (int _i449 = 0; _i449 < _list448.Count; ++_i449)
{
TDDIKeyValueMap _elem450;
_elem450 = new TDDIKeyValueMap();
_elem450.Read(iprot);
KeyValueMaps.Add(_elem450);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureModel>();
TList _list451 = iprot.ReadListBegin();
for (int _i452 = 0; _i452 < _list451.Count; ++_i452)
{
TDDIAbstractFailureModel _elem453;
_elem453 = new TDDIAbstractFailureModel();
_elem453.Read(iprot);
FailureModels.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.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list16 = iprot.ReadListBegin();
for (int _i17 = 0; _i17 < _list16.Count; ++_i17)
{
TDDIKeyValueMap _elem18;
_elem18 = new TDDIKeyValueMap();
_elem18.Read(iprot);
KeyValueMaps.Add(_elem18);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
ActivityDescription = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
TechnicalDescription = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
ToolSpecification = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.I32)
{
StaffNumber = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.String)
{
StaffSkillLevel = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
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.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list1484 = iprot.ReadListBegin();
for (int _i1485 = 0; _i1485 < _list1484.Count; ++_i1485)
{
TDDIKeyValueMap _elem1486;
_elem1486 = new TDDIKeyValueMap();
_elem1486.Read(iprot);
KeyValueMaps.Add(_elem1486);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
SkillLevel = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
Motivation = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
AnonymityDesire = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
AttackerGoals = new List <TDDIAttackerGoal>();
TList _list1487 = iprot.ReadListBegin();
for (int _i1488 = 0; _i1488 < _list1487.Count; ++_i1488)
{
TDDIAttackerGoal _elem1489;
_elem1489 = new TDDIAttackerGoal();
_elem1489.Read(iprot);
AttackerGoals.Add(_elem1489);
}
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 _list556 = iprot.ReadListBegin();
for (int _i557 = 0; _i557 < _list556.Count; ++_i557)
{
TDDIKeyValueMap _elem558;
_elem558 = new TDDIKeyValueMap();
_elem558.Read(iprot);
KeyValueMaps.Add(_elem558);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
RelatedStandard = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
RiskParamaters = new List <TDDIAbstractRiskParameterRef>();
TList _list559 = iprot.ReadListBegin();
for (int _i560 = 0; _i560 < _list559.Count; ++_i560)
{
TDDIAbstractRiskParameterRef _elem561;
_elem561 = new TDDIAbstractRiskParameterRef();
_elem561.Read(iprot);
RiskParamaters.Add(_elem561);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Struct)
{
Hazard = new TDDIHazard();
Hazard.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
{
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.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list76 = iprot.ReadListBegin();
for (int _i77 = 0; _i77 < _list76.Count; ++_i77)
{
TDDIKeyValueMap _elem78;
_elem78 = new TDDIKeyValueMap();
_elem78.Read(iprot);
KeyValueMaps.Add(_elem78);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Struct)
{
FromPort = new TDDIPort();
FromPort.Read(iprot);
isset_FromPort = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
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.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list20 = iprot.ReadListBegin();
for (int _i21 = 0; _i21 < _list20.Count; ++_i21)
{
TDDIKeyValueMap _elem22;
_elem22 = new TDDIKeyValueMap();
_elem22.Read(iprot);
KeyValueMaps.Add(_elem22);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
Measures = new List <TDDIAbstractMeasure>();
TList _list23 = iprot.ReadListBegin();
for (int _i24 = 0; _i24 < _list23.Count; ++_i24)
{
TDDIAbstractMeasure _elem25;
_elem25 = new TDDIAbstractMeasure();
_elem25.Read(iprot);
Measures.Add(_elem25);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
MeasureTypes = new List <TDDIMeasureType>();
TList _list26 = iprot.ReadListBegin();
for (int _i27 = 0; _i27 < _list26.Count; ++_i27)
{
TDDIMeasureType _elem28;
_elem28 = new TDDIMeasureType();
_elem28.Read(iprot);
MeasureTypes.Add(_elem28);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.List)
{
{
MaintenanceProcedures = new List <TDDIMaintenanceProcedure>();
TList _list29 = iprot.ReadListBegin();
for (int _i30 = 0; _i30 < _list29.Count; ++_i30)
{
TDDIMaintenanceProcedure _elem31;
_elem31 = new TDDIMaintenanceProcedure();
_elem31.Read(iprot);
MaintenanceProcedures.Add(_elem31);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DomainPackages = new List <TDDIDomainPackage>();
TList _list32 = iprot.ReadListBegin();
for (int _i33 = 0; _i33 < _list32.Count; ++_i33)
{
TDDIDomainPackage _elem34;
_elem34 = new TDDIDomainPackage();
_elem34.Read(iprot);
DomainPackages.Add(_elem34);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
TARAPackages = new List <TDDITARAPackage>();
TList _list35 = iprot.ReadListBegin();
for (int _i36 = 0; _i36 < _list35.Count; ++_i36)
{
TDDITARAPackage _elem37;
_elem37 = new TDDITARAPackage();
_elem37.Read(iprot);
TARAPackages.Add(_elem37);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
HARAPackages = new List <TDDIHARAPackage>();
TList _list38 = iprot.ReadListBegin();
for (int _i39 = 0; _i39 < _list38.Count; ++_i39)
{
TDDIHARAPackage _elem40;
_elem40 = new TDDIHARAPackage();
_elem40.Read(iprot);
HARAPackages.Add(_elem40);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
RequirementPackages = new List <TDDIRequirementPackage>();
TList _list41 = iprot.ReadListBegin();
for (int _i42 = 0; _i42 < _list41.Count; ++_i42)
{
TDDIRequirementPackage _elem43;
_elem43 = new TDDIRequirementPackage();
_elem43.Read(iprot);
RequirementPackages.Add(_elem43);
}
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 _list1512 = iprot.ReadListBegin();
for (int _i1513 = 0; _i1513 < _list1512.Count; ++_i1513)
{
TDDIKeyValueMap _elem1514;
_elem1514 = new TDDIKeyValueMap();
_elem1514.Read(iprot);
KeyValueMaps.Add(_elem1514);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
IdentifiedRisks = new List <TDDISecurityRisk>();
TList _list1515 = iprot.ReadListBegin();
for (int _i1516 = 0; _i1516 < _list1515.Count; ++_i1516)
{
TDDISecurityRisk _elem1517;
_elem1517 = new TDDISecurityRisk();
_elem1517.Read(iprot);
IdentifiedRisks.Add(_elem1517);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
Controls = new List <TDDISecurityControl>();
TList _list1518 = iprot.ReadListBegin();
for (int _i1519 = 0; _i1519 < _list1518.Count; ++_i1519)
{
TDDISecurityControl _elem1520;
_elem1520 = new TDDISecurityControl();
_elem1520.Read(iprot);
Controls.Add(_elem1520);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.List)
{
{
ConsideredAssets = new List <TDDIAbstractAsset>();
TList _list1521 = iprot.ReadListBegin();
for (int _i1522 = 0; _i1522 < _list1521.Count; ++_i1522)
{
TDDIAbstractAsset _elem1523;
_elem1523 = new TDDIAbstractAsset();
_elem1523.Read(iprot);
ConsideredAssets.Add(_elem1523);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
ConsideredThreatAgents = new List <TDDIAbstractThreatAgent>();
TList _list1524 = iprot.ReadListBegin();
for (int _i1525 = 0; _i1525 < _list1524.Count; ++_i1525)
{
TDDIAbstractThreatAgent _elem1526;
_elem1526 = new TDDIAbstractThreatAgent();
_elem1526.Read(iprot);
ConsideredThreatAgents.Add(_elem1526);
}
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 _list488 = iprot.ReadListBegin();
for (int _i489 = 0; _i489 < _list488.Count; ++_i489)
{
TDDIKeyValueMap _elem490;
_elem490 = new TDDIKeyValueMap();
_elem490.Read(iprot);
KeyValueMaps.Add(_elem490);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32)
{
Type = (TDDICauseType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct)
{
Failure = new TDDIAbstractFailure();
Failure.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.I32)
{
GateType = (TDDIGateType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
Causes = new List <TDDIAbstractCauseRef>();
TList _list491 = iprot.ReadListBegin();
for (int _i492 = 0; _i492 < _list491.Count; ++_i492)
{
TDDIAbstractCauseRef _elem493;
_elem493 = new TDDIAbstractCauseRef();
_elem493.Read(iprot);
Causes.Add(_elem493);
}
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 _list1492 = iprot.ReadListBegin();
for (int _i1493 = 0; _i1493 < _list1492.Count; ++_i1493)
{
TDDIKeyValueMap _elem1494;
_elem1494 = new TDDIKeyValueMap();
_elem1494.Read(iprot);
KeyValueMaps.Add(_elem1494);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
SkillLevel = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
Motivation = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
AnonymityDesire = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
AttackerGoals = new List <TDDIAttackerGoal>();
TList _list1495 = iprot.ReadListBegin();
for (int _i1496 = 0; _i1496 < _list1495.Count; ++_i1496)
{
TDDIAttackerGoal _elem1497;
_elem1497 = new TDDIAttackerGoal();
_elem1497.Read(iprot);
AttackerGoals.Add(_elem1497);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Actions = new List <TDDIActionRef>();
TList _list1498 = iprot.ReadListBegin();
for (int _i1499 = 0; _i1499 < _list1498.Count; ++_i1499)
{
TDDIActionRef _elem1500;
_elem1500 = new TDDIActionRef();
_elem1500.Read(iprot);
Actions.Add(_elem1500);
}
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 _list240 = iprot.ReadListBegin();
for (int _i241 = 0; _i241 < _list240.Count; ++_i241)
{
TDDIKeyValueMap _elem242;
_elem242 = new TDDIKeyValueMap();
_elem242.Read(iprot);
KeyValueMaps.Add(_elem242);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Double)
{
OverallLifetime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I32)
{
OverallLifetimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.List)
{
{
Contexts = new List <TDDIContext>();
TList _list243 = iprot.ReadListBegin();
for (int _i244 = 0; _i244 < _list243.Count; ++_i244)
{
TDDIContext _elem245;
_elem245 = new TDDIContext();
_elem245.Read(iprot);
Contexts.Add(_elem245);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
Configurations = new List <TDDIConfiguration>();
TList _list246 = iprot.ReadListBegin();
for (int _i247 = 0; _i247 < _list246.Count; ++_i247)
{
TDDIConfiguration _elem248;
_elem248 = new TDDIConfiguration();
_elem248.Read(iprot);
Configurations.Add(_elem248);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPort>();
TList _list249 = iprot.ReadListBegin();
for (int _i250 = 0; _i250 < _list249.Count; ++_i250)
{
TDDIPort _elem251;
_elem251 = new TDDIPort();
_elem251.Read(iprot);
Ports.Add(_elem251);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
Signals = new List <TDDISignal>();
TList _list252 = iprot.ReadListBegin();
for (int _i253 = 0; _i253 < _list252.Count; ++_i253)
{
TDDISignal _elem254;
_elem254 = new TDDISignal();
_elem254.Read(iprot);
Signals.Add(_elem254);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
SystemBoundaries = new List <TDDISystemBoundary>();
TList _list255 = iprot.ReadListBegin();
for (int _i256 = 0; _i256 < _list255.Count; ++_i256)
{
TDDISystemBoundary _elem257;
_elem257 = new TDDISystemBoundary();
_elem257.Read(iprot);
SystemBoundaries.Add(_elem257);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
AppliedStandards = new List <TDDIAbstractStandardRef>();
TList _list258 = iprot.ReadListBegin();
for (int _i259 = 0; _i259 < _list258.Count; ++_i259)
{
TDDIAbstractStandardRef _elem260;
_elem260 = new TDDIAbstractStandardRef();
_elem260.Read(iprot);
AppliedStandards.Add(_elem260);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
RealisedFunctions = new List <TDDIAbstractFunctionRef>();
TList _list261 = iprot.ReadListBegin();
for (int _i262 = 0; _i262 < _list261.Count; ++_i262)
{
TDDIAbstractFunctionRef _elem263;
_elem263 = new TDDIAbstractFunctionRef();
_elem263.Read(iprot);
RealisedFunctions.Add(_elem263);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.Struct)
{
AsAsset = new TDDIAbstractAsset();
AsAsset.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list264 = iprot.ReadListBegin();
for (int _i265 = 0; _i265 < _list264.Count; ++_i265)
{
TDDIAbstractDependabilityRequirementRef _elem266;
_elem266 = new TDDIAbstractDependabilityRequirementRef();
_elem266.Read(iprot);
DependabilityRequirements.Add(_elem266);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureModelRef>();
TList _list267 = iprot.ReadListBegin();
for (int _i268 = 0; _i268 < _list267.Count; ++_i268)
{
TDDIAbstractFailureModelRef _elem269;
_elem269 = new TDDIAbstractFailureModelRef();
_elem269.Read(iprot);
FailureModels.Add(_elem269);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.List)
{
{
SubSystems = new List <TDDIAbstractSystemRef>();
TList _list270 = iprot.ReadListBegin();
for (int _i271 = 0; _i271 < _list270.Count; ++_i271)
{
TDDIAbstractSystemRef _elem272;
_elem272 = new TDDIAbstractSystemRef();
_elem272.Read(iprot);
SubSystems.Add(_elem272);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.String)
{
SafeState = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.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 _list540 = iprot.ReadListBegin();
for (int _i541 = 0; _i541 < _list540.Count; ++_i541)
{
TDDIKeyValueMap _elem542;
_elem542 = new TDDIKeyValueMap();
_elem542.Read(iprot);
KeyValueMaps.Add(_elem542);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
Argument = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
Controlability = 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.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list1396 = iprot.ReadListBegin();
for (int _i1397 = 0; _i1397 < _list1396.Count; ++_i1397)
{
TDDIKeyValueMap _elem1398;
_elem1398 = new TDDIKeyValueMap();
_elem1398.Read(iprot);
KeyValueMaps.Add(_elem1398);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Double)
{
FinancialValue = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I32)
{
FinancialCostType = (TDDIFinancialCostType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Double)
{
OperationalCost = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.I32)
{
OperationalCostType = (TDDIOperationalCostType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Vulnerabilities = new List <TDDIVulnerability>();
TList _list1399 = iprot.ReadListBegin();
for (int _i1400 = 0; _i1400 < _list1399.Count; ++_i1400)
{
TDDIVulnerability _elem1401;
_elem1401 = new TDDIVulnerability();
_elem1401.Read(iprot);
Vulnerabilities.Add(_elem1401);
}
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 _list140 = iprot.ReadListBegin();
for (int _i141 = 0; _i141 < _list140.Count; ++_i141)
{
TDDIKeyValueMap _elem142;
_elem142 = new TDDIKeyValueMap();
_elem142.Read(iprot);
KeyValueMaps.Add(_elem142);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
SubSystems = new List <TDDIAbstractSystemRef>();
TList _list143 = iprot.ReadListBegin();
for (int _i144 = 0; _i144 < _list143.Count; ++_i144)
{
TDDIAbstractSystemRef _elem145;
_elem145 = new TDDIAbstractSystemRef();
_elem145.Read(iprot);
SubSystems.Add(_elem145);
}
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 _list1456 = iprot.ReadListBegin();
for (int _i1457 = 0; _i1457 < _list1456.Count; ++_i1457)
{
TDDIKeyValueMap _elem1458;
_elem1458 = new TDDIKeyValueMap();
_elem1458.Read(iprot);
KeyValueMaps.Add(_elem1458);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
Category = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Double)
{
FinancialCost = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.I32)
{
FinancialCostType = (TDDIFinancialCostType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.Double)
{
TimeRequired = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.I32)
{
TimeUnit = (TDDITimeUnit)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
Difficulty = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.String)
{
Detectability = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
ExploitedVulnerabilities = new List <TDDIVulnerabilityRef>();
TList _list1459 = iprot.ReadListBegin();
for (int _i1460 = 0; _i1460 < _list1459.Count; ++_i1460)
{
TDDIVulnerabilityRef _elem1461;
_elem1461 = new TDDIVulnerabilityRef();
_elem1461.Read(iprot);
ExploitedVulnerabilities.Add(_elem1461);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
Violations = new List <TDDISecurityViolationRef>();
TList _list1462 = iprot.ReadListBegin();
for (int _i1463 = 0; _i1463 < _list1462.Count; ++_i1463)
{
TDDISecurityViolationRef _elem1464;
_elem1464 = new TDDISecurityViolationRef();
_elem1464.Read(iprot);
Violations.Add(_elem1464);
}
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 _list464 = iprot.ReadListBegin();
for (int _i465 = 0; _i465 < _list464.Count; ++_i465)
{
TDDIKeyValueMap _elem466;
_elem466 = new TDDIKeyValueMap();
_elem466.Read(iprot);
KeyValueMaps.Add(_elem466);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
MinimalCutSets = new List <TDDIMinimalCutSets>();
TList _list467 = iprot.ReadListBegin();
for (int _i468 = 0; _i468 < _list467.Count; ++_i468)
{
TDDIMinimalCutSets _elem469;
_elem469 = new TDDIMinimalCutSets();
_elem469.Read(iprot);
MinimalCutSets.Add(_elem469);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
Failures = new List <TDDIAbstractFailure>();
TList _list470 = iprot.ReadListBegin();
for (int _i471 = 0; _i471 < _list470.Count; ++_i471)
{
TDDIAbstractFailure _elem472;
_elem472 = new TDDIAbstractFailure();
_elem472.Read(iprot);
Failures.Add(_elem472);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.List)
{
{
SubModels = new List <TDDIAbstractFailureModelRef>();
TList _list473 = iprot.ReadListBegin();
for (int _i474 = 0; _i474 < _list473.Count; ++_i474)
{
TDDIAbstractFailureModelRef _elem475;
_elem475 = new TDDIAbstractFailureModelRef();
_elem475.Read(iprot);
SubModels.Add(_elem475);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.I32)
{
Type = (TDDIFMEAType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Entries = new List <TDDIAbstractFMEAEntry>();
TList _list476 = iprot.ReadListBegin();
for (int _i477 = 0; _i477 < _list476.Count; ++_i477)
{
TDDIAbstractFMEAEntry _elem478;
_elem478 = new TDDIAbstractFMEAEntry();
_elem478.Read(iprot);
Entries.Add(_elem478);
}
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 _list1404 = iprot.ReadListBegin();
for (int _i1405 = 0; _i1405 < _list1404.Count; ++_i1405)
{
TDDIKeyValueMap _elem1406;
_elem1406 = new TDDIKeyValueMap();
_elem1406.Read(iprot);
KeyValueMaps.Add(_elem1406);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
IntrinsicSafety = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
SafeGuard = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
ApplierInformation = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.Bool)
{
RiskAcceptability = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.String)
{
FurtherAction = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
Source = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Struct)
{
MeasureType = new TDDIMeasureType();
MeasureType.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.String)
{
Category = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.I32)
{
Type = (TDDISecurityApplicationType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
Vulnerabilities = new List <TDDIVulnerabilityRef>();
TList _list1407 = iprot.ReadListBegin();
for (int _i1408 = 0; _i1408 < _list1407.Count; ++_i1408)
{
TDDIVulnerabilityRef _elem1409;
_elem1409 = new TDDIVulnerabilityRef();
_elem1409.Read(iprot);
Vulnerabilities.Add(_elem1409);
}
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 _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 _list616 = iprot.ReadListBegin();
for (int _i617 = 0; _i617 < _list616.Count; ++_i617)
{
TDDIKeyValueMap _elem618;
_elem618 = new TDDIKeyValueMap();
_elem618.Read(iprot);
KeyValueMaps.Add(_elem618);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Double)
{
Transition = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct)
{
TransitionProbDistribution = new TDDIProbDist();
TransitionProbDistribution.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.List)
{
{
FromStates = new List <TDDIStateRef>();
TList _list619 = iprot.ReadListBegin();
for (int _i620 = 0; _i620 < _list619.Count; ++_i620)
{
TDDIStateRef _elem621;
_elem621 = new TDDIStateRef();
_elem621.Read(iprot);
FromStates.Add(_elem621);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
ToStates = new List <TDDIStateRef>();
TList _list622 = iprot.ReadListBegin();
for (int _i623 = 0; _i623 < _list622.Count; ++_i623)
{
TDDIStateRef _elem624;
_elem624 = new TDDIStateRef();
_elem624.Read(iprot);
ToStates.Add(_elem624);
}
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 _list68 = iprot.ReadListBegin();
for (int _i69 = 0; _i69 < _list68.Count; ++_i69)
{
TDDIKeyValueMap _elem70;
_elem70 = new TDDIKeyValueMap();
_elem70.Read(iprot);
KeyValueMaps.Add(_elem70);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPortRef>();
TList _list71 = iprot.ReadListBegin();
for (int _i72 = 0; _i72 < _list71.Count; ++_i72)
{
TDDIPortRef _elem73;
_elem73 = new TDDIPortRef();
_elem73.Read(iprot);
Ports.Add(_elem73);
}
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 _list1424 = iprot.ReadListBegin();
for (int _i1425 = 0; _i1425 < _list1424.Count; ++_i1425)
{
TDDIKeyValueMap _elem1426;
_elem1426 = new TDDIKeyValueMap();
_elem1426.Read(iprot);
KeyValueMaps.Add(_elem1426);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Double)
{
Likelihood = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
ImpactAsset = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
ImpactIndividuals = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
ImpactBusiness = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
AttackerGoals = new List <TDDIAttackerGoalRef>();
TList _list1427 = iprot.ReadListBegin();
for (int _i1428 = 0; _i1428 < _list1427.Count; ++_i1428)
{
TDDIAttackerGoalRef _elem1429;
_elem1429 = new TDDIAttackerGoalRef();
_elem1429.Read(iprot);
AttackerGoals.Add(_elem1429);
}
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 _list572 = iprot.ReadListBegin();
for (int _i573 = 0; _i573 < _list572.Count; ++_i573)
{
TDDIKeyValueMap _elem574;
_elem574 = new TDDIKeyValueMap();
_elem574.Read(iprot);
KeyValueMaps.Add(_elem574);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
Hazards = new List <TDDIHazard>();
TList _list575 = iprot.ReadListBegin();
for (int _i576 = 0; _i576 < _list575.Count; ++_i576)
{
TDDIHazard _elem577;
_elem577 = new TDDIHazard();
_elem577.Read(iprot);
Hazards.Add(_elem577);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
HazardTypes = new List <TDDIHazardType>();
TList _list578 = iprot.ReadListBegin();
for (int _i579 = 0; _i579 < _list578.Count; ++_i579)
{
TDDIHazardType _elem580;
_elem580 = new TDDIHazardType();
_elem580.Read(iprot);
HazardTypes.Add(_elem580);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.List)
{
{
HazardTypeSystems = new List <TDDIHazardTypeSystem>();
TList _list581 = iprot.ReadListBegin();
for (int _i582 = 0; _i582 < _list581.Count; ++_i582)
{
TDDIHazardTypeSystem _elem583;
_elem583 = new TDDIHazardTypeSystem();
_elem583.Read(iprot);
HazardTypeSystems.Add(_elem583);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
Malfunctions = new List <TDDIMalfunction>();
TList _list584 = iprot.ReadListBegin();
for (int _i585 = 0; _i585 < _list584.Count; ++_i585)
{
TDDIMalfunction _elem586;
_elem586 = new TDDIMalfunction();
_elem586.Read(iprot);
Malfunctions.Add(_elem586);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
RiskAssessments = new List <TDDIRiskAssessment>();
TList _list587 = iprot.ReadListBegin();
for (int _i588 = 0; _i588 < _list587.Count; ++_i588)
{
TDDIRiskAssessment _elem589;
_elem589 = new TDDIRiskAssessment();
_elem589.Read(iprot);
RiskAssessments.Add(_elem589);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
RiskParameters = new List <TDDIAbstractRiskParameter>();
TList _list590 = iprot.ReadListBegin();
for (int _i591 = 0; _i591 < _list590.Count; ++_i591)
{
TDDIAbstractRiskParameter _elem592;
_elem592 = new TDDIAbstractRiskParameter();
_elem592.Read(iprot);
RiskParameters.Add(_elem592);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}