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.String)
{
V_null = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Byte)
{
V_void = iprot.ReadByte();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Bool)
{
V_boolean = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
V_boolean_box = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Byte)
{
V_byte = iprot.ReadByte();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Byte)
{
V_byte_box = iprot.ReadByte();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.I16)
{
V_short = iprot.ReadI16();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.I16)
{
V_short_box = iprot.ReadI16();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.I32)
{
V_int = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.I32)
{
V_int_box = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.I64)
{
V_long = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I64)
{
V_long_box = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Double)
{
V_float = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.Double)
{
V_float_box = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.Double)
{
V_double = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.Double)
{
V_double_box = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.String)
{
V_string = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.Struct)
{
V_object = new @object();
V_object.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.List)
{
{
V_array = new List <Variant>();
TList _list4 = iprot.ReadListBegin();
for (int _i5 = 0; _i5 < _list4.Count; ++_i5)
{
Variant _elem6;
_elem6 = new Variant();
_elem6.Read(iprot);
V_array.Add(_elem6);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 20:
if (field.Type == TType.List)
{
{
V_list = new List <Variant>();
TList _list7 = iprot.ReadListBegin();
for (int _i8 = 0; _i8 < _list7.Count; ++_i8)
{
Variant _elem9;
_elem9 = new Variant();
_elem9.Read(iprot);
V_list.Add(_elem9);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 21:
if (field.Type == TType.Set)
{
{
V_set = new THashSet <Variant>();
TSet _set10 = iprot.ReadSetBegin();
for (int _i11 = 0; _i11 < _set10.Count; ++_i11)
{
Variant _elem12;
_elem12 = new Variant();
_elem12.Read(iprot);
V_set.Add(_elem12);
}
iprot.ReadSetEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 22:
if (field.Type == TType.Map)
{
{
V_map = new Dictionary <Variant, Variant>();
TMap _map13 = iprot.ReadMapBegin();
for (int _i14 = 0; _i14 < _map13.Count; ++_i14)
{
Variant _key15;
Variant _val16;
_key15 = new Variant();
_key15.Read(iprot);
_val16 = new Variant();
_val16.Read(iprot);
V_map[_key15] = _val16;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 23:
if (field.Type == TType.String)
{
V_big_decimal = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 24:
if (field.Type == TType.Struct)
{
V_amount = new Amount();
V_amount.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 25:
if (field.Type == TType.String)
{
V_byte_array = iprot.ReadBinary();
}
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 _list1440 = iprot.ReadListBegin();
for (int _i1441 = 0; _i1441 < _list1440.Count; ++_i1441)
{
TDDIKeyValueMap _elem1442;
_elem1442 = new TDDIKeyValueMap();
_elem1442.Read(iprot);
KeyValueMaps.Add(_elem1442);
}
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 _list1443 = iprot.ReadListBegin();
for (int _i1444 = 0; _i1444 < _list1443.Count; ++_i1444)
{
TDDIVulnerabilityRef _elem1445;
_elem1445 = new TDDIVulnerabilityRef();
_elem1445.Read(iprot);
ExploitedVulnerabilities.Add(_elem1445);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
Violations = new List <TDDISecurityViolationRef>();
TList _list1446 = iprot.ReadListBegin();
for (int _i1447 = 0; _i1447 < _list1446.Count; ++_i1447)
{
TDDISecurityViolationRef _elem1448;
_elem1448 = new TDDISecurityViolationRef();
_elem1448.Read(iprot);
Violations.Add(_elem1448);
}
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_Events = false;
bool isset_SimulationTime = false;
bool isset_FrameNumber = 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.List)
{
{
Events = new List <MMIStandard.MSimulationEvent>();
TList _list0 = iprot.ReadListBegin();
for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
{
MMIStandard.MSimulationEvent _elem2;
_elem2 = new MMIStandard.MSimulationEvent();
_elem2.Read(iprot);
Events.Add(_elem2);
}
iprot.ReadListEnd();
}
isset_Events = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Double)
{
SimulationTime = iprot.ReadDouble();
isset_SimulationTime = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32)
{
FrameNumber = iprot.ReadI32();
isset_FrameNumber = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_Events)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Events not set");
}
if (!isset_SimulationTime)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field SimulationTime not set");
}
if (!isset_FrameNumber)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field FrameNumber not set");
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Double)
{
Execute_latency_ms = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Double)
{
Process_latency_ms = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I64)
{
Executed = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Double)
{
Capacity = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Double)
{
LatitudeCenter = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Double)
{
LatitudePad = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Double)
{
LongitudeCenter = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Double)
{
LongitudePad = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Double)
{
ScoreBoost = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I32)
{
Requirement = (RelatedNotesRequirement)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
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 _list404 = iprot.ReadListBegin();
for (int _i405 = 0; _i405 < _list404.Count; ++_i405)
{
TDDIKeyValueMap _elem406;
_elem406 = new TDDIKeyValueMap();
_elem406.Read(iprot);
KeyValueMaps.Add(_elem406);
}
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 _list407 = iprot.ReadListBegin();
for (int _i408 = 0; _i408 < _list407.Count; ++_i408)
{
TDDIAbstractFailureRef _elem409;
_elem409 = new TDDIAbstractFailureRef();
_elem409.Read(iprot);
CCFFailures.Add(_elem409);
}
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)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I32)
{
ID = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
FileName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
MapResName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Double)
{
Duration = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I64)
{
TimeStamp = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
FrameDatalist = new List <ActionFrameData>();
TList _list16 = iprot.ReadListBegin();
for (int _i17 = 0; _i17 < _list16.Count; ++_i17)
{
ActionFrameData _elem18 = new ActionFrameData();
_elem18 = new ActionFrameData();
_elem18.Read(iprot);
FrameDatalist.Add(_elem18);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_Min = false;
bool isset_Max = 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.Double)
{
Min = iprot.ReadDouble();
isset_Min = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Double)
{
Max = iprot.ReadDouble();
isset_Max = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_Min)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Min not set");
}
if (!isset_Max)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Max not set");
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
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)
{
Timestamp = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Sym = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Double)
{
Bid = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32)
{
BidSize = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
Last = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Byte)
{
Pool = iprot.ReadByte();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.I16)
{
Mode = iprot.ReadI16();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
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.I32)
{
Name = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
Color = iprot.ReadI32();
}
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.Double)
{
Weight = 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)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
OrderId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
SenderId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
RecipientId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
Destination = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
PaymentStatus = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.String)
{
OrderStaus = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Double)
{
TotalCost = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Double)
{
TotalValue = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I32)
{
TotalQuantity = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.String)
{
CreateBy = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.String)
{
CreateDate = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.String)
{
CloseDate = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.Bool)
{
IsDeleted = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
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.I32)
{
VerticeInicio = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
VerticeFim = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Bool)
{
FlagBidirecional = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Double)
{
Peso = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
Descricao = 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 _list576 = iprot.ReadListBegin();
for (int _i577 = 0; _i577 < _list576.Count; ++_i577)
{
TDDIKeyValueMapRef _elem578;
_elem578 = new TDDIKeyValueMapRef();
_elem578.Read(iprot);
KeyValueMaps.Add(_elem578);
}
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.Struct)
{
FMEACause = new TDDIFMEAFailure();
FMEACause.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
FMEAEffect = new TDDIFMEAFailure();
FMEAEffect.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Double)
{
DiagnosisRate = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
ProbabilityDistribution = new TDDIProbabilityDistribution();
ProbabilityDistribution.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)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 10:
if (field.Type == TType.List)
{
{
AuxFitness = new List <CAuxFitnessInfo>();
TList _list16 = iprot.ReadListBegin();
for (int _i17 = 0; _i17 < _list16.Count; ++_i17)
{
CAuxFitnessInfo _elem18 = new CAuxFitnessInfo();
_elem18 = new CAuxFitnessInfo();
_elem18.Read(iprot);
AuxFitness.Add(_elem18);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 20:
if (field.Type == TType.Double)
{
Fitness = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 30:
if (field.Type == TType.Bool)
{
StopConditionSatisfied = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I32)
{
Id = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I16)
{
Width = iprot.ReadI16();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I16)
{
Height = iprot.ReadI16();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
AdvertiserName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
ImageUrl = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
DestinationUrl = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.I16)
{
DisplaySeconds = iprot.ReadI16();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.Double)
{
Score = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.String)
{
Image = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
ImageMime = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.String)
{
Html = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Double)
{
DisplayFrequency = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Bool)
{
OpenInTrunk = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Double)
{
X = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Double)
{
Y = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Double)
{
Width = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Double)
{
Height = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 10:
if (field.Type == TType.String)
{
Message = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 20:
if (field.Type == TType.String)
{
FunctionCall = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 30:
if (field.Type == TType.String)
{
Parameters = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 40:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 50:
if (field.Type == TType.I32)
{
EmployeeId = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 60:
if (field.Type == TType.Double)
{
RaiseRate = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 70:
if (field.Type == TType.String)
{
AddressLine1 = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 80:
if (field.Type == TType.String)
{
AddressLine2 = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 90:
if (field.Type == TType.String)
{
Icon = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 100:
if (field.Type == TType.String)
{
LargeIcon = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_AoKID = false;
bool isset_Labels = false;
bool isset_Value = false;
bool isset_SystemLevelType = false;
bool isset_AbstractionLevel = 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.String)
{
Neo4jID = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
AoKID = iprot.ReadString();
isset_AoKID = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Set)
{
{
Labels = new THashSet <string>();
TSet _set16 = iprot.ReadSetBegin();
for (int _i17 = 0; _i17 < _set16.Count; ++_i17)
{
string _elem18;
_elem18 = iprot.ReadString();
Labels.Add(_elem18);
}
iprot.ReadSetEnd();
}
isset_Labels = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
Value = iprot.ReadString();
isset_Value = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32)
{
SystemLevelType = (TESystemLevelType)iprot.ReadI32();
isset_SystemLevelType = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I32)
{
AbstractionLevel = (TEAbstractionLevel)iprot.ReadI32();
isset_AbstractionLevel = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
Tag = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
Validity = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.String)
{
ProcessingTag = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Set)
{
{
Domains = new THashSet <string>();
TSet _set19 = iprot.ReadSetBegin();
for (int _i20 = 0; _i20 < _set19.Count; ++_i20)
{
string _elem21;
_elem21 = iprot.ReadString();
Domains.Add(_elem21);
}
iprot.ReadSetEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Map)
{
{
TruthValue = new Dictionary <string, double>();
TMap _map22 = iprot.ReadMapBegin();
for (int _i23 = 0; _i23 < _map22.Count; ++_i23)
{
string _key24;
double _val25;
_key24 = iprot.ReadString();
_val25 = iprot.ReadDouble();
TruthValue[_key24] = _val25;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Double)
{
Evaluation = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.String)
{
DateTimeStamp = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.I64)
{
AgeInMilliseconds = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.Double)
{
AttentionLevel = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_AoKID)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field AoKID not set");
}
if (!isset_Labels)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Labels not set");
}
if (!isset_Value)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Value not set");
}
if (!isset_SystemLevelType)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field SystemLevelType not set");
}
if (!isset_AbstractionLevel)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field AbstractionLevel not set");
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
Keyspace = iprot.ReadString();
}
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)
{
Column_type = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
Comparator_type = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
Subcomparator_type = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
Comment = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Double)
{
Read_repair_chance = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
Column_metadata = new List <ColumnDef>();
TList _list46 = iprot.ReadListBegin();
for (int _i47 = 0; _i47 < _list46.Count; ++_i47)
{
ColumnDef _elem48 = new ColumnDef();
_elem48 = new ColumnDef();
_elem48.Read(iprot);
Column_metadata.Add(_elem48);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.I32)
{
Gc_grace_seconds = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.String)
{
Default_validation_class = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.I32)
{
Id = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.I32)
{
Min_compaction_threshold = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.I32)
{
Max_compaction_threshold = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 24:
if (field.Type == TType.Bool)
{
Replicate_on_write = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 26:
if (field.Type == TType.String)
{
Key_validation_class = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 28:
if (field.Type == TType.String)
{
Key_alias = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 29:
if (field.Type == TType.String)
{
Compaction_strategy = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 30:
if (field.Type == TType.Map)
{
{
Compaction_strategy_options = new Dictionary <string, string>();
TMap _map49 = iprot.ReadMapBegin();
for (int _i50 = 0; _i50 < _map49.Count; ++_i50)
{
string _key51;
string _val52;
_key51 = iprot.ReadString();
_val52 = iprot.ReadString();
Compaction_strategy_options[_key51] = _val52;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 32:
if (field.Type == TType.Map)
{
{
Compression_options = new Dictionary <string, string>();
TMap _map53 = iprot.ReadMapBegin();
for (int _i54 = 0; _i54 < _map53.Count; ++_i54)
{
string _key55;
string _val56;
_key55 = iprot.ReadString();
_val56 = iprot.ReadString();
Compression_options[_key55] = _val56;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 33:
if (field.Type == TType.Double)
{
Bloom_filter_fp_chance = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 34:
if (field.Type == TType.String)
{
Caching = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 37:
if (field.Type == TType.Double)
{
Dclocal_read_repair_chance = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Double)
{
Row_cache_size = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Double)
{
Key_cache_size = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.I32)
{
Row_cache_save_period_in_seconds = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 20:
if (field.Type == TType.I32)
{
Key_cache_save_period_in_seconds = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 21:
if (field.Type == TType.I32)
{
Memtable_flush_after_mins = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 22:
if (field.Type == TType.I32)
{
Memtable_throughput_in_mb = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 23:
if (field.Type == TType.Double)
{
Memtable_operations_in_millions = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 25:
if (field.Type == TType.Double)
{
Merge_shards_chance = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 27:
if (field.Type == TType.String)
{
Row_cache_provider = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 31:
if (field.Type == TType.I32)
{
Row_cache_keys_to_save = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
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.String)
{
Id = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
ParentId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I16)
{
OrderIndex = iprot.ReadI16();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I16)
{
TypeId = iprot.ReadI16();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
TypeName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I16)
{
DiffType = iprot.ReadI16();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Double)
{
Diff = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
QuesBody = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.String)
{
QuesAnswer = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
QuesParse = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.String)
{
KPoints = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.String)
{
CPoints = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Struct)
{
QuesOption = new QuesOption();
QuesOption.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)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Double)
{
X = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Double)
{
Y = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32)
{
HandState = (HandState)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32)
{
TrackingState = (TrackingState)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Double)
{
CameraSpaceX = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Double)
{
CameraSpaceY = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Double)
{
CameraSpaceZ = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
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.I32)
{
Begin_in_both = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
Newint = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Byte)
{
Newbyte = iprot.ReadByte();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I16)
{
Newshort = iprot.ReadI16();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I64)
{
Newlong = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Double)
{
Newdouble = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
Newstruct = new Bonk();
Newstruct.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
Newlist = new List <int>();
TList _list49 = iprot.ReadListBegin();
for (int _i50 = 0; _i50 < _list49.Count; ++_i50)
{
int _elem51;
_elem51 = iprot.ReadI32();
Newlist.Add(_elem51);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Set)
{
{
Newset = new THashSet <int>();
TSet _set52 = iprot.ReadSetBegin();
for (int _i53 = 0; _i53 < _set52.Count; ++_i53)
{
int _elem54;
_elem54 = iprot.ReadI32();
Newset.Add(_elem54);
}
iprot.ReadSetEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Map)
{
{
Newmap = new Dictionary <int, int>();
TMap _map55 = iprot.ReadMapBegin();
for (int _i56 = 0; _i56 < _map55.Count; ++_i56)
{
int _key57;
int _val58;
_key57 = iprot.ReadI32();
_val58 = iprot.ReadI32();
Newmap[_key57] = _val58;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.String)
{
Newstring = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I32)
{
End_in_both = 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.String)
{
DeviceId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
UserId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I64)
{
Timestamp = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Double)
{
Scale = 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.Double)
{
Latitude = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Double)
{
Longitude = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
DisplayAddress = 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
{
bool isset_PolygonPoints = 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.List)
{
{
PolygonPoints = new List <MGeometryConstraint>();
TList _list5 = iprot.ReadListBegin();
for (int _i6 = 0; _i6 < _list5.Count; ++_i6)
{
MGeometryConstraint _elem7;
_elem7 = new MGeometryConstraint();
_elem7.Read(iprot);
PolygonPoints.Add(_elem7);
}
iprot.ReadListEnd();
}
isset_PolygonPoints = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Double)
{
WeightingFactor = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_PolygonPoints)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field PolygonPoints not set");
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 10:
if (field.Type == TType.String)
{
InstanceId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 20:
if (field.Type == TType.Double)
{
Time = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 30:
if (field.Type == TType.Double)
{
High = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 40:
if (field.Type == TType.I32)
{
TargetType = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_Mass = false;
bool isset_CenterOfMass = 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.Double)
{
Mass = iprot.ReadDouble();
isset_Mass = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
CenterOfMass = new List <double>();
TList _list8 = iprot.ReadListBegin();
for (int _i9 = 0; _i9 < _list8.Count; ++_i9)
{
double _elem10;
_elem10 = iprot.ReadDouble();
CenterOfMass.Add(_elem10);
}
iprot.ReadListEnd();
}
isset_CenterOfMass = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.List)
{
{
Inertia = new List <double>();
TList _list11 = iprot.ReadListBegin();
for (int _i12 = 0; _i12 < _list11.Count; ++_i12)
{
double _elem13;
_elem13 = iprot.ReadDouble();
Inertia.Add(_elem13);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List)
{
{
Velocity = new List <double>();
TList _list14 = iprot.ReadListBegin();
for (int _i15 = 0; _i15 < _list14.Count; ++_i15)
{
double _elem16;
_elem16 = iprot.ReadDouble();
Velocity.Add(_elem16);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
AngularVelocity = new List <double>();
TList _list17 = iprot.ReadListBegin();
for (int _i18 = 0; _i18 < _list17.Count; ++_i18)
{
double _elem19;
_elem19 = iprot.ReadDouble();
AngularVelocity.Add(_elem19);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
NetForce = new List <double>();
TList _list20 = iprot.ReadListBegin();
for (int _i21 = 0; _i21 < _list20.Count; ++_i21)
{
double _elem22;
_elem22 = iprot.ReadDouble();
NetForce.Add(_elem22);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.List)
{
{
NetTorque = new List <double>();
TList _list23 = iprot.ReadListBegin();
for (int _i24 = 0; _i24 < _list23.Count; ++_i24)
{
double _elem25;
_elem25 = iprot.ReadDouble();
NetTorque.Add(_elem25);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.Double)
{
Mu1 = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Double)
{
Mu2 = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Double)
{
Bounciness = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Double)
{
MuTorsion = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Double)
{
TorsionSurfaceRadius = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_Mass)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Mass not set");
}
if (!isset_CenterOfMass)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field CenterOfMass not set");
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public static void Skip(TProtocol prot, TType type)
{
switch (type)
{
case TType.Bool:
prot.ReadBool();
break;
case TType.Byte:
prot.ReadByte();
break;
case TType.I16:
prot.ReadI16();
break;
case TType.I32:
prot.ReadI32();
break;
case TType.I64:
prot.ReadI64();
break;
case TType.Double:
prot.ReadDouble();
break;
case TType.String:
// Don't try to decode the string, just skip it.
prot.ReadBinary();
break;
case TType.Struct:
prot.ReadStructBegin();
while (true)
{
TField field = prot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
Skip(prot, field.Type);
prot.ReadFieldEnd();
}
prot.ReadStructEnd();
break;
case TType.Map:
TMap map = prot.ReadMapBegin();
for (int i = 0; i < map.Count; i++)
{
Skip(prot, map.KeyType);
Skip(prot, map.ValueType);
}
prot.ReadMapEnd();
break;
case TType.Set:
TSet set = prot.ReadSetBegin();
for (int i = 0; i < set.Count; i++)
{
Skip(prot, set.ElementType);
}
prot.ReadSetEnd();
break;
case TType.List:
TList list = prot.ReadListBegin();
for (int i = 0; i < list.Count; i++)
{
Skip(prot, list.ElementType);
}
prot.ReadListEnd();
break;
}
}
public void Read(TProtocol iprot)
{
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)
{
EntityId = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Text = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Double)
{
Value = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I64)
{
Count = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I64)
{
Timestamp = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
