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)
{
Status = new APIResponse();
Status.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
Stats = new List <PeriodStats>();
TList _list21 = iprot.ReadListBegin();
for (int _i22 = 0; _i22 < _list21.Count; ++_i22)
{
PeriodStats _elem23;
_elem23 = new PeriodStats();
_elem23.Read(iprot);
Stats.Add(_elem23);
}
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_posture = 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.Struct)
{
Posture = new MMIStandard.MAvatarPostureValues();
Posture.Read(iprot);
isset_posture = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
JointConstraints = new List <MJointConstraint>();
TList _list9 = iprot.ReadListBegin();
for (int _i10 = 0; _i10 < _list9.Count; ++_i10)
{
MJointConstraint _elem11;
_elem11 = new MJointConstraint();
_elem11.Read(iprot);
JointConstraints.Add(_elem11);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_posture)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Posture not set");
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public override TList ReadListBegin()
{
return(WrappedProtocol.ReadListBegin());
}
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 _list604 = iprot.ReadListBegin();
for (int _i605 = 0; _i605 < _list604.Count; ++_i605)
{
TDDIKeyValueMapRef _elem606;
_elem606 = new TDDIKeyValueMapRef();
_elem606.Read(iprot);
KeyValueMaps.Add(_elem606);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
FailureAnalysisArtifacts = new List <TDDIAbstractFailureAnalysisArtifactRef>();
TList _list607 = iprot.ReadListBegin();
for (int _i608 = 0; _i608 < _list607.Count; ++_i608)
{
TDDIAbstractFailureAnalysisArtifactRef _elem609;
_elem609 = new TDDIAbstractFailureAnalysisArtifactRef();
_elem609.Read(iprot);
FailureAnalysisArtifacts.Add(_elem609);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
FTAArtifacts = new List <TDDIAbstractFTAArtifact>();
TList _list610 = iprot.ReadListBegin();
for (int _i611 = 0; _i611 < _list610.Count; ++_i611)
{
TDDIAbstractFTAArtifact _elem612;
_elem612 = new TDDIAbstractFTAArtifact();
_elem612.Read(iprot);
FTAArtifacts.Add(_elem612);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
BasicEvents = new List <TDDIBasicEvent>();
TList _list613 = iprot.ReadListBegin();
for (int _i614 = 0; _i614 < _list613.Count; ++_i614)
{
TDDIBasicEvent _elem615;
_elem615 = new TDDIBasicEvent();
_elem615.Read(iprot);
BasicEvents.Add(_elem615);
}
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 _list1464 = iprot.ReadListBegin();
for (int _i1465 = 0; _i1465 < _list1464.Count; ++_i1465)
{
TDDIKeyValueMap _elem1466;
_elem1466 = new TDDIKeyValueMap();
_elem1466.Read(iprot);
KeyValueMaps.Add(_elem1466);
}
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.List)
{
{
Attacks = new List <TDDIAbstractAttack>();
TList _list1467 = iprot.ReadListBegin();
for (int _i1468 = 0; _i1468 < _list1467.Count; ++_i1468)
{
TDDIAbstractAttack _elem1469;
_elem1469 = new TDDIAbstractAttack();
_elem1469.Read(iprot);
Attacks.Add(_elem1469);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.List)
{
{
AddressedBy = new List <TDDISecurityCapability>();
TList _list1470 = iprot.ReadListBegin();
for (int _i1471 = 0; _i1471 < _list1470.Count; ++_i1471)
{
TDDISecurityCapability _elem1472;
_elem1472 = new TDDISecurityCapability();
_elem1472.Read(iprot);
AddressedBy.Add(_elem1472);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
AttackedItems = new List <TDDIVulnerableItemRef>();
TList _list1473 = iprot.ReadListBegin();
for (int _i1474 = 0; _i1474 < _list1473.Count; ++_i1474)
{
TDDIVulnerableItemRef _elem1475;
_elem1475 = new TDDIVulnerableItemRef();
_elem1475.Read(iprot);
AttackedItems.Add(_elem1475);
}
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 _list1412 = iprot.ReadListBegin();
for (int _i1413 = 0; _i1413 < _list1412.Count; ++_i1413)
{
TDDIKeyValueMap _elem1414;
_elem1414 = new TDDIKeyValueMap();
_elem1414.Read(iprot);
KeyValueMaps.Add(_elem1414);
}
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.I32)
{
Type = (TDDISecurityApplicationType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.List)
{
{
ImplementedBy = new List <TDDISecurityControlRef>();
TList _list1415 = iprot.ReadListBegin();
for (int _i1416 = 0; _i1416 < _list1415.Count; ++_i1416)
{
TDDISecurityControlRef _elem1417;
_elem1417 = new TDDISecurityControlRef();
_elem1417.Read(iprot);
ImplementedBy.Add(_elem1417);
}
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.Struct)
{
MessageMetadata = new MNMessagesSyncMessageMetadata();
MessageMetadata.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Body = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I64)
{
StickerId = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List)
{
{
Attachments = new List <string>();
TList _list26 = iprot.ReadListBegin();
for (int _i27 = 0; _i27 < _list26.Count; ++_i27)
{
string _elem28;
_elem28 = iprot.ReadString();
Attachments.Add(_elem28);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32)
{
Ttl = 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
{
bool isset_Vertices = false;
bool isset_Triangles = 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)
{
{
Vertices = new List <MMIStandard.MVector3>();
TList _list57 = iprot.ReadListBegin();
for (int _i58 = 0; _i58 < _list57.Count; ++_i58)
{
MMIStandard.MVector3 _elem59;
_elem59 = new MMIStandard.MVector3();
_elem59.Read(iprot);
Vertices.Add(_elem59);
}
iprot.ReadListEnd();
}
isset_Vertices = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
Triangles = new List <int>();
TList _list60 = iprot.ReadListBegin();
for (int _i61 = 0; _i61 < _list60.Count; ++_i61)
{
int _elem62;
_elem62 = iprot.ReadI32();
Triangles.Add(_elem62);
}
iprot.ReadListEnd();
}
isset_Triangles = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
Properties = new Dictionary <string, string>();
TMap _map63 = iprot.ReadMapBegin();
for (int _i64 = 0; _i64 < _map63.Count; ++_i64)
{
string _key65;
string _val66;
_key65 = iprot.ReadString();
_val66 = iprot.ReadString();
Properties[_key65] = _val66;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_Vertices)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Vertices not set");
}
if (!isset_Triangles)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Triangles not set");
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_Initial = false;
bool isset_Current = 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.Struct)
{
Initial = new MMIStandard.MAvatarPostureValues();
Initial.Read(iprot);
isset_Initial = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct)
{
Current = new MMIStandard.MAvatarPostureValues();
Current.Read(iprot);
isset_Current = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.List)
{
{
Constraints = new List <MMIStandard.MConstraint>();
TList _list0 = iprot.ReadListBegin();
for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
{
MMIStandard.MConstraint _elem2;
_elem2 = new MMIStandard.MConstraint();
_elem2.Read(iprot);
Constraints.Add(_elem2);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List)
{
{
SceneManipulations = new List <MMIStandard.MSceneManipulation>();
TList _list3 = iprot.ReadListBegin();
for (int _i4 = 0; _i4 < _list3.Count; ++_i4)
{
MMIStandard.MSceneManipulation _elem5;
_elem5 = new MMIStandard.MSceneManipulation();
_elem5.Read(iprot);
SceneManipulations.Add(_elem5);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
Events = new List <MSimulationEvent>();
TList _list6 = iprot.ReadListBegin();
for (int _i7 = 0; _i7 < _list6.Count; ++_i7)
{
MSimulationEvent _elem8;
_elem8 = new MSimulationEvent();
_elem8.Read(iprot);
Events.Add(_elem8);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_Initial)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Initial not set");
}
if (!isset_Current)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Current not set");
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
bool isset_id = false;
bool isset_database = false;
bool isset_source = false;
bool isset_journal = false;
bool isset_issue = false;
bool isset_volume = false;
bool isset_title = false;
bool isset_pagination = false;
bool isset_language = false;
bool isset_pubDate = 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)
{
Id = iprot.ReadString();
isset_id = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
Database = (com.imd.doc.thrift.Language)iprot.ReadI32();
isset_database = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32)
{
Source = (com.imd.doc.thrift.Source)iprot.ReadI32();
isset_source = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
WFID = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
WPID = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
ZWID = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
PMID = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
PMCID = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.String)
{
DOI = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
Journal = iprot.ReadString();
isset_journal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.String)
{
Issue = iprot.ReadString();
isset_issue = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.String)
{
Volume = iprot.ReadString();
isset_volume = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.String)
{
Title = iprot.ReadString();
isset_title = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.String)
{
Pagination = iprot.ReadString();
isset_pagination = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.String)
{
Text = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.List)
{
{
AuthorList = new List <string>();
TList _list0 = iprot.ReadListBegin();
for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
{
string _elem2 = null;
_elem2 = iprot.ReadString();
AuthorList.Add(_elem2);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.List)
{
{
AffiliationList = new List <string>();
TList _list3 = iprot.ReadListBegin();
for (int _i4 = 0; _i4 < _list3.Count; ++_i4)
{
string _elem5 = null;
_elem5 = iprot.ReadString();
AffiliationList.Add(_elem5);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.String)
{
Language = iprot.ReadString();
isset_language = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.I64)
{
PubDate = iprot.ReadI64();
isset_pubDate = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 20:
if (field.Type == TType.List)
{
{
GrantList = new List <string>();
TList _list6 = iprot.ReadListBegin();
for (int _i7 = 0; _i7 < _list6.Count; ++_i7)
{
string _elem8 = null;
_elem8 = iprot.ReadString();
GrantList.Add(_elem8);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 21:
if (field.Type == TType.String)
{
ISSN = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 22:
if (field.Type == TType.List)
{
{
KeywordList = new List <string>();
TList _list9 = iprot.ReadListBegin();
for (int _i10 = 0; _i10 < _list9.Count; ++_i10)
{
string _elem11 = null;
_elem11 = iprot.ReadString();
KeywordList.Add(_elem11);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_id)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_database)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_source)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_journal)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_issue)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_volume)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_title)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_pagination)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_language)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_pubDate)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
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)
{
Row = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
Columns = new List <TColumnIncrement>();
TList _list16 = iprot.ReadListBegin();
for (int _i17 = 0; _i17 < _list16.Count; ++_i17)
{
TColumnIncrement _elem18 = new TColumnIncrement();
_elem18 = new TColumnIncrement();
_elem18.Read(iprot);
Columns.Add(_elem18);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Bool)
{
WriteToWal = 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.List)
{
{
this.column_names = new List <byte[]>();
TList _list17 = iprot.ReadListBegin();
for (int _i18 = 0; _i18 < _list17.Count; ++_i18)
{
byte[] _elem19 = null;
_elem19 = iprot.ReadBinary();
this.column_names.Add(_elem19);
}
iprot.ReadListEnd();
}
this.__isset.column_names = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
this.rows = new List <Row>();
TList _list20 = iprot.ReadListBegin();
for (int _i21 = 0; _i21 < _list20.Count; ++_i21)
{
Row _elem22 = new Row();
_elem22 = new Row();
_elem22.Read(iprot);
this.rows.Add(_elem22);
}
iprot.ReadListEnd();
}
this.__isset.rows = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
bool isset_component = false;
bool isset_user = false;
bool isset_hostname = 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)
{
{
Component = new List <LockComponent>();
TList _list209 = iprot.ReadListBegin();
for (int _i210 = 0; _i210 < _list209.Count; ++_i210)
{
LockComponent _elem211 = new LockComponent();
_elem211 = new LockComponent();
_elem211.Read(iprot);
Component.Add(_elem211);
}
iprot.ReadListEnd();
}
isset_component = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I64)
{
Txnid = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
User = iprot.ReadString();
isset_user = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
Hostname = iprot.ReadString();
isset_hostname = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_component)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_user)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_hostname)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
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)
{
TableName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
DbName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Owner = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32)
{
CreateTime = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32)
{
LastAccessTime = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I32)
{
Retention = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
Sd = new StorageDescriptor();
Sd.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
PartitionKeys = new List <FieldSchema>();
TList _list66 = iprot.ReadListBegin();
for (int _i67 = 0; _i67 < _list66.Count; ++_i67)
{
FieldSchema _elem68 = new FieldSchema();
_elem68 = new FieldSchema();
_elem68.Read(iprot);
PartitionKeys.Add(_elem68);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Map)
{
{
Parameters = new Dictionary <string, string>();
TMap _map69 = iprot.ReadMapBegin();
for (int _i70 = 0; _i70 < _map69.Count; ++_i70)
{
string _key71;
string _val72;
_key71 = iprot.ReadString();
_val72 = iprot.ReadString();
Parameters[_key71] = _val72;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
ViewOriginalText = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.String)
{
ViewExpandedText = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.String)
{
TableType = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Struct)
{
Privileges = new PrincipalPrivilegeSet();
Privileges.Read(iprot);
}
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 _list704 = iprot.ReadListBegin();
for (int _i705 = 0; _i705 < _list704.Count; ++_i705)
{
TDDIKeyValueMap _elem706;
_elem706 = new TDDIKeyValueMap();
_elem706.Read(iprot);
KeyValueMaps.Add(_elem706);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
RequirementSources = new List <TDDIAbstractRequirementSource>();
TList _list707 = iprot.ReadListBegin();
for (int _i708 = 0; _i708 < _list707.Count; ++_i708)
{
TDDIAbstractRequirementSource _elem709;
_elem709 = new TDDIAbstractRequirementSource();
_elem709.Read(iprot);
RequirementSources.Add(_elem709);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
DependabilityRequirements = new List <TDDIAbstractDependabilityRequirement>();
TList _list710 = iprot.ReadListBegin();
for (int _i711 = 0; _i711 < _list710.Count; ++_i711)
{
TDDIAbstractDependabilityRequirement _elem712;
_elem712 = new TDDIAbstractDependabilityRequirement();
_elem712.Read(iprot);
DependabilityRequirements.Add(_elem712);
}
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)
{
Action = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
AvailableFields = new List <THAvailableField>();
TList _list15 = iprot.ReadListBegin();
for (int _i16 = 0; _i16 < _list15.Count; ++_i16)
{
THAvailableField _elem17;
_elem17 = (THAvailableField)iprot.ReadI32();
AvailableFields.Add(_elem17);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
ContentType = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
ClassName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
Data = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
PackageName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
Uti = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
UrlScheme = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.String)
{
ImageExtension = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Map)
{
{
Annotations = new Dictionary <string, string>();
TMap _map18 = iprot.ReadMapBegin();
for (int _i19 = 0; _i19 < _map18.Count; ++_i19)
{
string _key20;
string _val21;
_key20 = iprot.ReadString();
_val21 = iprot.ReadString();
Annotations[_key20] = _val21;
}
iprot.ReadMapEnd();
}
}
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.List)
{
{
Column_names = new List <byte[]>();
TList _list8 = iprot.ReadListBegin();
for (int _i9 = 0; _i9 < _list8.Count; ++_i9)
{
byte[] _elem10;
_elem10 = iprot.ReadBinary();
Column_names.Add(_elem10);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct)
{
Slice_range = new SliceRange();
Slice_range.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)
{
var isset_values = false;
var isset_nulls = 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)
{
{
Values = new List <Int64>();
var _list43 = iprot.ReadListBegin();
for (var _i44 = 0; _i44 < _list43.Count; ++_i44)
{
Int64 _elem45 = 0;
_elem45 = iprot.ReadI64();
Values.Add(_elem45);
}
iprot.ReadListEnd();
}
isset_values = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Nulls = iprot.ReadBinary();
isset_nulls = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_values)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_nulls)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_columns = false;
bool isset_total_byte_size = false;
bool isset_num_rows = 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)
{
{
Columns = new List <ColumnChunk>();
TList _list20 = iprot.ReadListBegin();
for (int _i21 = 0; _i21 < _list20.Count; ++_i21)
{
ColumnChunk _elem22;
_elem22 = new ColumnChunk();
_elem22.Read(iprot);
Columns.Add(_elem22);
}
iprot.ReadListEnd();
}
isset_columns = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I64)
{
Total_byte_size = iprot.ReadI64();
isset_total_byte_size = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I64)
{
Num_rows = iprot.ReadI64();
isset_num_rows = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List)
{
{
Sorting_columns = new List <SortingColumn>();
TList _list23 = iprot.ReadListBegin();
for (int _i24 = 0; _i24 < _list23.Count; ++_i24)
{
SortingColumn _elem25;
_elem25 = new SortingColumn();
_elem25.Read(iprot);
Sorting_columns.Add(_elem25);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I64)
{
File_offset = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I64)
{
Total_compressed_size = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.I16)
{
Ordinal = iprot.ReadI16();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_columns)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_total_byte_size)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_num_rows)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
bool isset_status = 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.I32)
{
Status = (com.imd.doc.thrift.Status)iprot.ReadI32();
isset_status = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Message = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.List)
{
{
Users = new List <com.imd.user.thrift.User>();
TList _list0 = iprot.ReadListBegin();
for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
{
com.imd.user.thrift.User _elem2 = new com.imd.user.thrift.User();
_elem2 = new com.imd.user.thrift.User();
_elem2.Read(iprot);
Users.Add(_elem2);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_status)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
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.List)
{
{
Folders = new List <int>();
TList _list95 = iprot.ReadListBegin();
for (int _i96 = 0; _i96 < _list95.Count; ++_i96)
{
int _elem97;
_elem97 = iprot.ReadI32();
Folders.Add(_elem97);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
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();
}
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)
{
SquareChatMid = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
Kickees = new List <SquareMember>();
TList _list429 = iprot.ReadListBegin();
for (int _i430 = 0; _i430 < _list429.Count; ++_i430)
{
SquareMember _elem431;
_elem431 = new SquareMember();
_elem431.Read(iprot);
Kickees.Add(_elem431);
}
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 _list376 = iprot.ReadListBegin();
for (int _i377 = 0; _i377 < _list376.Count; ++_i377)
{
TDDIKeyValueMap _elem378;
_elem378 = new TDDIKeyValueMap();
_elem378.Read(iprot);
KeyValueMaps.Add(_elem378);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
AssuranceLevels = new List <TDDIAssuranceLevelRef>();
TList _list379 = iprot.ReadListBegin();
for (int _i380 = 0; _i380 < _list379.Count; ++_i380)
{
TDDIAssuranceLevelRef _elem381;
_elem381 = new TDDIAssuranceLevelRef();
_elem381.Read(iprot);
AssuranceLevels.Add(_elem381);
}
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)
{
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)
{
DtNascimento = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
NumCartaoSus = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
NumProntuario = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
Gestante = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
NecessidadesEspeciais = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I64)
{
LocalAtendimento = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.I64)
{
TipoAtendimento = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
TiposEncamOdonto = new List <long>();
TList _list0 = iprot.ReadListBegin();
for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
{
long _elem2;
_elem2 = iprot.ReadI64();
TiposEncamOdonto.Add(_elem2);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
TiposFornecimOdonto = new List <long>();
TList _list3 = iprot.ReadListBegin();
for (int _i4 = 0; _i4 < _list3.Count; ++_i4)
{
long _elem5;
_elem5 = iprot.ReadI64();
TiposFornecimOdonto.Add(_elem5);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
TiposVigilanciaSaudeBucal = new List <long>();
TList _list6 = iprot.ReadListBegin();
for (int _i7 = 0; _i7 < _list6.Count; ++_i7)
{
long _elem8;
_elem8 = iprot.ReadI64();
TiposVigilanciaSaudeBucal.Add(_elem8);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.List)
{
{
TiposConsultaOdonto = new List <long>();
TList _list9 = iprot.ReadListBegin();
for (int _i10 = 0; _i10 < _list9.Count; ++_i10)
{
long _elem11;
_elem11 = iprot.ReadI64();
TiposConsultaOdonto.Add(_elem11);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
ProcedimentosRealizados = new List <ProcedimentoQuantidadeThrift>();
TList _list12 = iprot.ReadListBegin();
for (int _i13 = 0; _i13 < _list12.Count; ++_i13)
{
ProcedimentoQuantidadeThrift _elem14;
_elem14 = new ProcedimentoQuantidadeThrift();
_elem14.Read(iprot);
ProcedimentosRealizados.Add(_elem14);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
OutrosSiaProcedimentos = new List <ProcedimentoQuantidadeThrift>();
TList _list15 = iprot.ReadListBegin();
for (int _i16 = 0; _i16 < _list15.Count; ++_i16)
{
ProcedimentoQuantidadeThrift _elem17;
_elem17 = new ProcedimentoQuantidadeThrift();
_elem17.Read(iprot);
OutrosSiaProcedimentos.Add(_elem17);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.I64)
{
Sexo = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.I64)
{
Turno = iprot.ReadI64();
}
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 _list428 = iprot.ReadListBegin();
for (int _i429 = 0; _i429 < _list428.Count; ++_i429)
{
TDDIKeyValueMapRef _elem430;
_elem430 = new TDDIKeyValueMapRef();
_elem430.Read(iprot);
KeyValueMaps.Add(_elem430);
}
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)
{
Value = 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.String)
{
ID = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Channel = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I64)
{
Time = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
Channelname = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
Capimg = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
Senceimg = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.List)
{
{
Ft = new List <CmpFaceObjDS>();
TList _list40 = iprot.ReadListBegin();
for (int _i41 = 0; _i41 < _list40.Count; ++_i41)
{
CmpFaceObjDS _elem42;
_elem42 = new CmpFaceObjDS();
_elem42.Read(iprot);
Ft.Add(_elem42);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
Address = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.I32)
{
Channel_type = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
Typestr = 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_uuidFicha = 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)
{
UuidFicha = iprot.ReadString();
isset_uuidFicha = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
OutraLocalidade = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.I64)
{
Inep = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.I32)
{
NumParticipantes = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I32)
{
NumAvaliacoesAlteradas = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List)
{
{
Profissionais = new List <ProfissionalCboRowItemThrift>();
TList _list0 = iprot.ReadListBegin();
for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
{
ProfissionalCboRowItemThrift _elem2;
_elem2 = new ProfissionalCboRowItemThrift();
_elem2.Read(iprot);
Profissionais.Add(_elem2);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.I64)
{
AtividadeTipo = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
TemasParaReuniao = new List <long>();
TList _list3 = iprot.ReadListBegin();
for (int _i4 = 0; _i4 < _list3.Count; ++_i4)
{
long _elem5;
_elem5 = iprot.ReadI64();
TemasParaReuniao.Add(_elem5);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.List)
{
{
PublicoAlvo = new List <long>();
TList _list6 = iprot.ReadListBegin();
for (int _i7 = 0; _i7 < _list6.Count; ++_i7)
{
long _elem8;
_elem8 = iprot.ReadI64();
PublicoAlvo.Add(_elem8);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.List)
{
{
Participantes = new List <ParticipanteRowItemThrift>();
TList _list9 = iprot.ReadListBegin();
for (int _i10 = 0; _i10 < _list9.Count; ++_i10)
{
ParticipanteRowItemThrift _elem11;
_elem11 = new ParticipanteRowItemThrift();
_elem11.Read(iprot);
Participantes.Add(_elem11);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.I32)
{
TbCdsOrigem = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 21:
if (field.Type == TType.String)
{
CnesLocalAtividade = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 22:
if (field.Type == TType.String)
{
Procedimento = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 23:
if (field.Type == TType.I64)
{
Turno = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 24:
if (field.Type == TType.Struct)
{
HeaderTransport = new br.gov.saude.esusab.ras.common.UnicaLotacaoHeaderThrift();
HeaderTransport.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 25:
if (field.Type == TType.List)
{
{
TemasParaSaude = new List <long>();
TList _list12 = iprot.ReadListBegin();
for (int _i13 = 0; _i13 < _list12.Count; ++_i13)
{
long _elem14;
_elem14 = iprot.ReadI64();
TemasParaSaude.Add(_elem14);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 26:
if (field.Type == TType.List)
{
{
PraticasEmSaude = new List <long>();
TList _list15 = iprot.ReadListBegin();
for (int _i16 = 0; _i16 < _list15.Count; ++_i16)
{
long _elem17;
_elem17 = iprot.ReadI64();
PraticasEmSaude.Add(_elem17);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 27:
if (field.Type == TType.Bool)
{
PseEducacao = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 28:
if (field.Type == TType.Bool)
{
PseSaude = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_uuidFicha)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
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.Struct)
{
Status = new APIResponse();
Status.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
Transactions = new List <SealedTransaction>();
TList _list37 = iprot.ReadListBegin();
for (int _i38 = 0; _i38 < _list37.Count; ++_i38)
{
SealedTransaction _elem39;
_elem39 = new SealedTransaction();
_elem39.Read(iprot);
Transactions.Add(_elem39);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
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)
{
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)
{
RequestId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
State = (BuddyResultState)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
MessageStoreRequestId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List)
{
{
MessageIds = new List <string>();
TList _list0 = iprot.ReadListBegin();
for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
{
string _elem2;
_elem2 = iprot.ReadString();
MessageIds.Add(_elem2);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.I64)
{
ReceiverCount = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I64)
{
SuccessCount = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.I64)
{
FailCount = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.I64)
{
BlockCount = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.I64)
{
UnregisteredCount = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.I64)
{
UnrelatedCount = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 21:
if (field.Type == TType.String)
{
ErrorDescription = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}