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 TDDIAssuranceLevel();
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 _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
{
bool isset_FromPort = false;
bool isset_ToPort = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list64 = iprot.ReadListBegin();
for (int _i65 = 0; _i65 < _list64.Count; ++_i65)
{
TDDIKeyValueMapRef _elem66;
_elem66 = new TDDIKeyValueMapRef();
_elem66.Read(iprot);
KeyValueMaps.Add(_elem66);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list67 = iprot.ReadListBegin();
for (int _i68 = 0; _i68 < _list67.Count; ++_i68)
{
TDDIAbstractDependabilityRequirementRef _elem69;
_elem69 = new TDDIAbstractDependabilityRequirementRef();
_elem69.Read(iprot);
DependabilityRequirements.Add(_elem69);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Struct)
{
FromPort = new TDDIPort();
FromPort.Read(iprot);
isset_FromPort = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
ToPort = new TDDIPort();
ToPort.Read(iprot);
isset_ToPort = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_FromPort)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field FromPort not set");
}
if (!isset_ToPort)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field ToPort not set");
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list416 = iprot.ReadListBegin();
for (int _i417 = 0; _i417 < _list416.Count; ++_i417)
{
TDDIKeyValueMapRef _elem418;
_elem418 = new TDDIKeyValueMapRef();
_elem418.Read(iprot);
KeyValueMaps.Add(_elem418);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
AssuranceLevels = new List <TDDIAssuranceLevel>();
TList _list419 = iprot.ReadListBegin();
for (int _i420 = 0; _i420 < _list419.Count; ++_i420)
{
TDDIAssuranceLevel _elem421;
_elem421 = new TDDIAssuranceLevel();
_elem421.Read(iprot);
AssuranceLevels.Add(_elem421);
}
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 _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.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list368 = iprot.ReadListBegin();
for (int _i369 = 0; _i369 < _list368.Count; ++_i369)
{
TDDIKeyValueMapRef _elem370;
_elem370 = new TDDIKeyValueMapRef();
_elem370.Read(iprot);
KeyValueMaps.Add(_elem370);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
IntrinsicSafety = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.String)
{
SafeGuard = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
ApplierInformation = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Bool)
{
RiskAcceptability = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.String)
{
FurtherAction = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.String)
{
Source = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.Struct)
{
MeasureType = new TDDIMeasureType();
MeasureType.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list104 = iprot.ReadListBegin();
for (int _i105 = 0; _i105 < _list104.Count; ++_i105)
{
TDDIKeyValueMapRef _elem106;
_elem106 = new TDDIKeyValueMapRef();
_elem106.Read(iprot);
KeyValueMaps.Add(_elem106);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list107 = iprot.ReadListBegin();
for (int _i108 = 0; _i108 < _list107.Count; ++_i108)
{
TDDIAbstractDependabilityRequirementRef _elem109;
_elem109 = new TDDIAbstractDependabilityRequirementRef();
_elem109.Read(iprot);
DependabilityRequirements.Add(_elem109);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
SubSystems = new List <TDDIAbstractSystemRef>();
TList _list110 = iprot.ReadListBegin();
for (int _i111 = 0; _i111 < _list110.Count; ++_i111)
{
TDDIAbstractSystemRef _elem112;
_elem112 = new TDDIAbstractSystemRef();
_elem112.Read(iprot);
SubSystems.Add(_elem112);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Double)
{
OverallLifetime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I32)
{
OverallLifetimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
RealisedFunctions = new List <TDDIAbstractFunctionRef>();
TList _list113 = iprot.ReadListBegin();
for (int _i114 = 0; _i114 < _list113.Count; ++_i114)
{
TDDIAbstractFunctionRef _elem115;
_elem115 = new TDDIAbstractFunctionRef();
_elem115.Read(iprot);
RealisedFunctions.Add(_elem115);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.List)
{
{
Configurations = new List <TDDIConfiguration>();
TList _list116 = iprot.ReadListBegin();
for (int _i117 = 0; _i117 < _list116.Count; ++_i117)
{
TDDIConfiguration _elem118;
_elem118 = new TDDIConfiguration();
_elem118.Read(iprot);
Configurations.Add(_elem118);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
Contexts = new List <TDDIContext>();
TList _list119 = iprot.ReadListBegin();
for (int _i120 = 0; _i120 < _list119.Count; ++_i120)
{
TDDIContext _elem121;
_elem121 = new TDDIContext();
_elem121.Read(iprot);
Contexts.Add(_elem121);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.List)
{
{
SystemBoundaries = new List <TDDISystemBoundary>();
TList _list122 = iprot.ReadListBegin();
for (int _i123 = 0; _i123 < _list122.Count; ++_i123)
{
TDDISystemBoundary _elem124;
_elem124 = new TDDISystemBoundary();
_elem124.Read(iprot);
SystemBoundaries.Add(_elem124);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.List)
{
{
AppliedStandards = new List <TDDIAbstractStandardRef>();
TList _list125 = iprot.ReadListBegin();
for (int _i126 = 0; _i126 < _list125.Count; ++_i126)
{
TDDIAbstractStandardRef _elem127;
_elem127 = new TDDIAbstractStandardRef();
_elem127.Read(iprot);
AppliedStandards.Add(_elem127);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list128 = iprot.ReadListBegin();
for (int _i129 = 0; _i129 < _list128.Count; ++_i129)
{
TDDIAbstractFailureLogicPackageRef _elem130;
_elem130 = new TDDIAbstractFailureLogicPackageRef();
_elem130.Read(iprot);
FailureModels.Add(_elem130);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPortRef>();
TList _list131 = iprot.ReadListBegin();
for (int _i132 = 0; _i132 < _list131.Count; ++_i132)
{
TDDIPortRef _elem133;
_elem133 = new TDDIPortRef();
_elem133.Read(iprot);
Ports.Add(_elem133);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list284 = iprot.ReadListBegin();
for (int _i285 = 0; _i285 < _list284.Count; ++_i285)
{
TDDIKeyValueMapRef _elem286;
_elem286 = new TDDIKeyValueMapRef();
_elem286.Read(iprot);
KeyValueMaps.Add(_elem286);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list287 = iprot.ReadListBegin();
for (int _i288 = 0; _i288 < _list287.Count; ++_i288)
{
TDDIAbstractDependabilityRequirementRef _elem289;
_elem289 = new TDDIAbstractDependabilityRequirementRef();
_elem289.Read(iprot);
DependabilityRequirements.Add(_elem289);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
SubFunctions = new List <TDDIAbstractFunctionRef>();
TList _list290 = iprot.ReadListBegin();
for (int _i291 = 0; _i291 < _list290.Count; ++_i291)
{
TDDIAbstractFunctionRef _elem292;
_elem292 = new TDDIAbstractFunctionRef();
_elem292.Read(iprot);
SubFunctions.Add(_elem292);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPortRef>();
TList _list293 = iprot.ReadListBegin();
for (int _i294 = 0; _i294 < _list293.Count; ++_i294)
{
TDDIPortRef _elem295;
_elem295 = new TDDIPortRef();
_elem295.Read(iprot);
Ports.Add(_elem295);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Struct)
{
PerfChars = new TDDIPerfChars();
PerfChars.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list296 = iprot.ReadListBegin();
for (int _i297 = 0; _i297 < _list296.Count; ++_i297)
{
TDDIAbstractFailureLogicPackageRef _elem298;
_elem298 = new TDDIAbstractFailureLogicPackageRef();
_elem298.Read(iprot);
FailureModels.Add(_elem298);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.List)
{
{
Malfunctions = new List <TDDIMalFunctionRef>();
TList _list299 = iprot.ReadListBegin();
for (int _i300 = 0; _i300 < _list299.Count; ++_i300)
{
TDDIMalFunctionRef _elem301;
_elem301 = new TDDIMalFunctionRef();
_elem301.Read(iprot);
Malfunctions.Add(_elem301);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list356 = iprot.ReadListBegin();
for (int _i357 = 0; _i357 < _list356.Count; ++_i357)
{
TDDIKeyValueMap _elem358;
_elem358 = new TDDIKeyValueMap();
_elem358.Read(iprot);
KeyValueMaps.Add(_elem358);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
Standards = new List <TDDIAbstractStandard>();
TList _list359 = iprot.ReadListBegin();
for (int _i360 = 0; _i360 < _list359.Count; ++_i360)
{
TDDIAbstractStandard _elem361;
_elem361 = new TDDIAbstractStandard();
_elem361.Read(iprot);
Standards.Add(_elem361);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
AssuranceLevels = new List <TDDIAssuranceLevel>();
TList _list362 = iprot.ReadListBegin();
for (int _i363 = 0; _i363 < _list362.Count; ++_i363)
{
TDDIAssuranceLevel _elem364;
_elem364 = new TDDIAssuranceLevel();
_elem364.Read(iprot);
AssuranceLevels.Add(_elem364);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list184 = iprot.ReadListBegin();
for (int _i185 = 0; _i185 < _list184.Count; ++_i185)
{
TDDIKeyValueMapRef _elem186;
_elem186 = new TDDIKeyValueMapRef();
_elem186.Read(iprot);
KeyValueMaps.Add(_elem186);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list187 = iprot.ReadListBegin();
for (int _i188 = 0; _i188 < _list187.Count; ++_i188)
{
TDDIAbstractDependabilityRequirementRef _elem189;
_elem189 = new TDDIAbstractDependabilityRequirementRef();
_elem189.Read(iprot);
DependabilityRequirements.Add(_elem189);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
SubSystems = new List <TDDIAbstractSystemRef>();
TList _list190 = iprot.ReadListBegin();
for (int _i191 = 0; _i191 < _list190.Count; ++_i191)
{
TDDIAbstractSystemRef _elem192;
_elem192 = new TDDIAbstractSystemRef();
_elem192.Read(iprot);
SubSystems.Add(_elem192);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Double)
{
OverallLifetime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I32)
{
OverallLifetimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
RealisedFunctions = new List <TDDIAbstractFunctionRef>();
TList _list193 = iprot.ReadListBegin();
for (int _i194 = 0; _i194 < _list193.Count; ++_i194)
{
TDDIAbstractFunctionRef _elem195;
_elem195 = new TDDIAbstractFunctionRef();
_elem195.Read(iprot);
RealisedFunctions.Add(_elem195);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.List)
{
{
Configurations = new List <TDDIConfiguration>();
TList _list196 = iprot.ReadListBegin();
for (int _i197 = 0; _i197 < _list196.Count; ++_i197)
{
TDDIConfiguration _elem198;
_elem198 = new TDDIConfiguration();
_elem198.Read(iprot);
Configurations.Add(_elem198);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
Contexts = new List <TDDIContext>();
TList _list199 = iprot.ReadListBegin();
for (int _i200 = 0; _i200 < _list199.Count; ++_i200)
{
TDDIContext _elem201;
_elem201 = new TDDIContext();
_elem201.Read(iprot);
Contexts.Add(_elem201);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.List)
{
{
SystemBoundaries = new List <TDDISystemBoundary>();
TList _list202 = iprot.ReadListBegin();
for (int _i203 = 0; _i203 < _list202.Count; ++_i203)
{
TDDISystemBoundary _elem204;
_elem204 = new TDDISystemBoundary();
_elem204.Read(iprot);
SystemBoundaries.Add(_elem204);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.List)
{
{
AppliedStandards = new List <TDDIAbstractStandardRef>();
TList _list205 = iprot.ReadListBegin();
for (int _i206 = 0; _i206 < _list205.Count; ++_i206)
{
TDDIAbstractStandardRef _elem207;
_elem207 = new TDDIAbstractStandardRef();
_elem207.Read(iprot);
AppliedStandards.Add(_elem207);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list208 = iprot.ReadListBegin();
for (int _i209 = 0; _i209 < _list208.Count; ++_i209)
{
TDDIAbstractFailureLogicPackageRef _elem210;
_elem210 = new TDDIAbstractFailureLogicPackageRef();
_elem210.Read(iprot);
FailureModels.Add(_elem210);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPortRef>();
TList _list211 = iprot.ReadListBegin();
for (int _i212 = 0; _i212 < _list211.Count; ++_i212)
{
TDDIPortRef _elem213;
_elem213 = new TDDIPortRef();
_elem213.Read(iprot);
Ports.Add(_elem213);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 20:
if (field.Type == TType.String)
{
SafeState = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMap>();
TList _list112 = iprot.ReadListBegin();
for (int _i113 = 0; _i113 < _list112.Count; ++_i113)
{
TDDIKeyValueMap _elem114;
_elem114 = new TDDIKeyValueMap();
_elem114.Read(iprot);
KeyValueMaps.Add(_elem114);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list115 = iprot.ReadListBegin();
for (int _i116 = 0; _i116 < _list115.Count; ++_i116)
{
TDDIAbstractDependabilityRequirementRef _elem117;
_elem117 = new TDDIAbstractDependabilityRequirementRef();
_elem117.Read(iprot);
DependabilityRequirements.Add(_elem117);
}
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 _list118 = iprot.ReadListBegin();
for (int _i119 = 0; _i119 < _list118.Count; ++_i119)
{
TDDIAbstractFunctionRef _elem120;
_elem120 = new TDDIAbstractFunctionRef();
_elem120.Read(iprot);
SubFunctions.Add(_elem120);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPort>();
TList _list121 = iprot.ReadListBegin();
for (int _i122 = 0; _i122 < _list121.Count; ++_i122)
{
TDDIPort _elem123;
_elem123 = new TDDIPort();
_elem123.Read(iprot);
Ports.Add(_elem123);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Signals = new List <TDDISignal>();
TList _list124 = iprot.ReadListBegin();
for (int _i125 = 0; _i125 < _list124.Count; ++_i125)
{
TDDISignal _elem126;
_elem126 = new TDDISignal();
_elem126.Read(iprot);
Signals.Add(_elem126);
}
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 _list127 = iprot.ReadListBegin();
for (int _i128 = 0; _i128 < _list127.Count; ++_i128)
{
TDDIAbstractFailureModelRef _elem129;
_elem129 = new TDDIAbstractFailureModelRef();
_elem129.Read(iprot);
FailureModels.Add(_elem129);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
Malfunctions = new List <TDDIMalfunctionRef>();
TList _list130 = iprot.ReadListBegin();
for (int _i131 = 0; _i131 < _list130.Count; ++_i131)
{
TDDIMalfunctionRef _elem132;
_elem132 = new TDDIMalfunctionRef();
_elem132.Read(iprot);
Malfunctions.Add(_elem132);
}
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;
case 14:
if (field.Type == TType.String)
{
Object = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.String)
{
Behavior = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.String)
{
SafeState = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list12 = iprot.ReadListBegin();
for (int _i13 = 0; _i13 < _list12.Count; ++_i13)
{
TDDIKeyValueMapRef _elem14;
_elem14 = new TDDIKeyValueMapRef();
_elem14.Read(iprot);
KeyValueMaps.Add(_elem14);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list15 = iprot.ReadListBegin();
for (int _i16 = 0; _i16 < _list15.Count; ++_i16)
{
TDDIAbstractDependabilityRequirementRef _elem17;
_elem17 = new TDDIAbstractDependabilityRequirementRef();
_elem17.Read(iprot);
DependabilityRequirements.Add(_elem17);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
DesignArtifacts = new List <TDDIAbstractDesignArtifactRef>();
TList _list18 = iprot.ReadListBegin();
for (int _i19 = 0; _i19 < _list18.Count; ++_i19)
{
TDDIAbstractDesignArtifactRef _elem20;
_elem20 = new TDDIAbstractDesignArtifactRef();
_elem20.Read(iprot);
DesignArtifacts.Add(_elem20);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
Implements = new TDDIAbstractArchitecturePackage();
Implements.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list144 = iprot.ReadListBegin();
for (int _i145 = 0; _i145 < _list144.Count; ++_i145)
{
TDDIKeyValueMapRef _elem146;
_elem146 = new TDDIKeyValueMapRef();
_elem146.Read(iprot);
KeyValueMaps.Add(_elem146);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list147 = iprot.ReadListBegin();
for (int _i148 = 0; _i148 < _list147.Count; ++_i148)
{
TDDIAbstractDependabilityRequirementRef _elem149;
_elem149 = new TDDIAbstractDependabilityRequirementRef();
_elem149.Read(iprot);
DependabilityRequirements.Add(_elem149);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
SubSystems = new List <TDDIAbstractSystemRef>();
TList _list150 = iprot.ReadListBegin();
for (int _i151 = 0; _i151 < _list150.Count; ++_i151)
{
TDDIAbstractSystemRef _elem152;
_elem152 = new TDDIAbstractSystemRef();
_elem152.Read(iprot);
SubSystems.Add(_elem152);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Double)
{
OverallLifetime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I32)
{
OverallLifetimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
RealisedFunctions = new List <TDDIAbstractFunctionRef>();
TList _list153 = iprot.ReadListBegin();
for (int _i154 = 0; _i154 < _list153.Count; ++_i154)
{
TDDIAbstractFunctionRef _elem155;
_elem155 = new TDDIAbstractFunctionRef();
_elem155.Read(iprot);
RealisedFunctions.Add(_elem155);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.List)
{
{
Configurations = new List <TDDIConfiguration>();
TList _list156 = iprot.ReadListBegin();
for (int _i157 = 0; _i157 < _list156.Count; ++_i157)
{
TDDIConfiguration _elem158;
_elem158 = new TDDIConfiguration();
_elem158.Read(iprot);
Configurations.Add(_elem158);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
Contexts = new List <TDDIContext>();
TList _list159 = iprot.ReadListBegin();
for (int _i160 = 0; _i160 < _list159.Count; ++_i160)
{
TDDIContext _elem161;
_elem161 = new TDDIContext();
_elem161.Read(iprot);
Contexts.Add(_elem161);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.List)
{
{
SystemBoundaries = new List <TDDISystemBoundary>();
TList _list162 = iprot.ReadListBegin();
for (int _i163 = 0; _i163 < _list162.Count; ++_i163)
{
TDDISystemBoundary _elem164;
_elem164 = new TDDISystemBoundary();
_elem164.Read(iprot);
SystemBoundaries.Add(_elem164);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.List)
{
{
AppliedStandards = new List <TDDIAbstractStandardRef>();
TList _list165 = iprot.ReadListBegin();
for (int _i166 = 0; _i166 < _list165.Count; ++_i166)
{
TDDIAbstractStandardRef _elem167;
_elem167 = new TDDIAbstractStandardRef();
_elem167.Read(iprot);
AppliedStandards.Add(_elem167);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list168 = iprot.ReadListBegin();
for (int _i169 = 0; _i169 < _list168.Count; ++_i169)
{
TDDIAbstractFailureLogicPackageRef _elem170;
_elem170 = new TDDIAbstractFailureLogicPackageRef();
_elem170.Read(iprot);
FailureModels.Add(_elem170);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPortRef>();
TList _list171 = iprot.ReadListBegin();
for (int _i172 = 0; _i172 < _list171.Count; ++_i172)
{
TDDIPortRef _elem173;
_elem173 = new TDDIPortRef();
_elem173.Read(iprot);
Ports.Add(_elem173);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _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 _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.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list72 = iprot.ReadListBegin();
for (int _i73 = 0; _i73 < _list72.Count; ++_i73)
{
TDDIKeyValueMapRef _elem74;
_elem74 = new TDDIKeyValueMapRef();
_elem74.Read(iprot);
KeyValueMaps.Add(_elem74);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list75 = iprot.ReadListBegin();
for (int _i76 = 0; _i76 < _list75.Count; ++_i76)
{
TDDIAbstractDependabilityRequirementRef _elem77;
_elem77 = new TDDIAbstractDependabilityRequirementRef();
_elem77.Read(iprot);
DependabilityRequirements.Add(_elem77);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
SubSystems = new List <TDDIAbstractSystemRef>();
TList _list78 = iprot.ReadListBegin();
for (int _i79 = 0; _i79 < _list78.Count; ++_i79)
{
TDDIAbstractSystemRef _elem80;
_elem80 = new TDDIAbstractSystemRef();
_elem80.Read(iprot);
SubSystems.Add(_elem80);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list84 = iprot.ReadListBegin();
for (int _i85 = 0; _i85 < _list84.Count; ++_i85)
{
TDDIKeyValueMapRef _elem86;
_elem86 = new TDDIKeyValueMapRef();
_elem86.Read(iprot);
KeyValueMaps.Add(_elem86);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list87 = iprot.ReadListBegin();
for (int _i88 = 0; _i88 < _list87.Count; ++_i88)
{
TDDIAbstractDependabilityRequirementRef _elem89;
_elem89 = new TDDIAbstractDependabilityRequirementRef();
_elem89.Read(iprot);
DependabilityRequirements.Add(_elem89);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
UsageHistory = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Double)
{
MissionTime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I32)
{
MissionTimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list48 = iprot.ReadListBegin();
for (int _i49 = 0; _i49 < _list48.Count; ++_i49)
{
TDDIKeyValueMapRef _elem50;
_elem50 = new TDDIKeyValueMapRef();
_elem50.Read(iprot);
KeyValueMaps.Add(_elem50);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list51 = iprot.ReadListBegin();
for (int _i52 = 0; _i52 < _list51.Count; ++_i52)
{
TDDIAbstractDependabilityRequirementRef _elem53;
_elem53 = new TDDIAbstractDependabilityRequirementRef();
_elem53.Read(iprot);
DependabilityRequirements.Add(_elem53);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
FlowType = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.I32)
{
Direction = (TDDIPortDirection)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
RefinedPorts = new List <TDDIPortRef>();
TList _list54 = iprot.ReadListBegin();
for (int _i55 = 0; _i55 < _list54.Count; ++_i55)
{
TDDIPortRef _elem56;
_elem56 = new TDDIPortRef();
_elem56.Read(iprot);
RefinedPorts.Add(_elem56);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
InterfaceFailures = new List <TDDIAbstractInterfaceFailureRef>();
TList _list57 = iprot.ReadListBegin();
for (int _i58 = 0; _i58 < _list57.Count; ++_i58)
{
TDDIAbstractInterfaceFailureRef _elem59;
_elem59 = new TDDIAbstractInterfaceFailureRef();
_elem59.Read(iprot);
InterfaceFailures.Add(_elem59);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.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.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list40 = iprot.ReadListBegin();
for (int _i41 = 0; _i41 < _list40.Count; ++_i41)
{
TDDIKeyValueMapRef _elem42;
_elem42 = new TDDIKeyValueMapRef();
_elem42.Read(iprot);
KeyValueMaps.Add(_elem42);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list43 = iprot.ReadListBegin();
for (int _i44 = 0; _i44 < _list43.Count; ++_i44)
{
TDDIAbstractDependabilityRequirementRef _elem45;
_elem45 = new TDDIAbstractDependabilityRequirementRef();
_elem45.Read(iprot);
DependabilityRequirements.Add(_elem45);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Double)
{
ResponseTime = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct)
{
DomainPackage = new TDDIAbstractDomainPackage();
DomainPackage.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct)
{
Standard = new TDDIAbstractStandard();
Standard.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list224 = iprot.ReadListBegin();
for (int _i225 = 0; _i225 < _list224.Count; ++_i225)
{
TDDIKeyValueMapRef _elem226;
_elem226 = new TDDIKeyValueMapRef();
_elem226.Read(iprot);
KeyValueMaps.Add(_elem226);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list227 = iprot.ReadListBegin();
for (int _i228 = 0; _i228 < _list227.Count; ++_i228)
{
TDDIAbstractDependabilityRequirementRef _elem229;
_elem229 = new TDDIAbstractDependabilityRequirementRef();
_elem229.Read(iprot);
DependabilityRequirements.Add(_elem229);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
Value = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
Conditions = new List <TDDILifecycleConditionRef>();
TList _list230 = iprot.ReadListBegin();
for (int _i231 = 0; _i231 < _list230.Count; ++_i231)
{
TDDILifecycleConditionRef _elem232;
_elem232 = new TDDILifecycleConditionRef();
_elem232.Read(iprot);
Conditions.Add(_elem232);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.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 _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 _list308 = iprot.ReadListBegin();
for (int _i309 = 0; _i309 < _list308.Count; ++_i309)
{
TDDIKeyValueMapRef _elem310;
_elem310 = new TDDIKeyValueMapRef();
_elem310.Read(iprot);
KeyValueMaps.Add(_elem310);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
TList _list311 = iprot.ReadListBegin();
for (int _i312 = 0; _i312 < _list311.Count; ++_i312)
{
TDDIAbstractDependabilityRequirementRef _elem313;
_elem313 = new TDDIAbstractDependabilityRequirementRef();
_elem313.Read(iprot);
DependabilityRequirements.Add(_elem313);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
AssuranceLevel = new TDDIAssuranceLevel();
AssuranceLevel.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
SubFunctions = new List <TDDIAbstractFunctionRef>();
TList _list314 = iprot.ReadListBegin();
for (int _i315 = 0; _i315 < _list314.Count; ++_i315)
{
TDDIAbstractFunctionRef _elem316;
_elem316 = new TDDIAbstractFunctionRef();
_elem316.Read(iprot);
SubFunctions.Add(_elem316);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
Ports = new List <TDDIPortRef>();
TList _list317 = iprot.ReadListBegin();
for (int _i318 = 0; _i318 < _list317.Count; ++_i318)
{
TDDIPortRef _elem319;
_elem319 = new TDDIPortRef();
_elem319.Read(iprot);
Ports.Add(_elem319);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Struct)
{
PerfChars = new TDDIPerfChars();
PerfChars.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
TList _list320 = iprot.ReadListBegin();
for (int _i321 = 0; _i321 < _list320.Count; ++_i321)
{
TDDIAbstractFailureLogicPackageRef _elem322;
_elem322 = new TDDIAbstractFailureLogicPackageRef();
_elem322.Read(iprot);
FailureModels.Add(_elem322);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.List)
{
{
Malfunctions = new List <TDDIMalFunctionRef>();
TList _list323 = iprot.ReadListBegin();
for (int _i324 = 0; _i324 < _list323.Count; ++_i324)
{
TDDIMalFunctionRef _elem325;
_elem325 = new TDDIMalFunctionRef();
_elem325.Read(iprot);
Malfunctions.Add(_elem325);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.String)
{
Object = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.String)
{
Behavior = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.String)
{
SafeState = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}