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)
{
SimpleValue = new Simple();
SimpleValue.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
ListValue = new List <Simple>();
TList _list12 = iprot.ReadListBegin();
for (int _i13 = 0; _i13 < _list12.Count; ++_i13)
{
Simple _elem14;
_elem14 = new Simple();
_elem14.Read(iprot);
ListValue.Add(_elem14);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Set)
{
{
SetValue = new THashSet <Simple>();
TSet _set15 = iprot.ReadSetBegin();
for (int _i16 = 0; _i16 < _set15.Count; ++_i16)
{
Simple _elem17;
_elem17 = new Simple();
_elem17.Read(iprot);
SetValue.Add(_elem17);
}
iprot.ReadSetEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Map)
{
{
MapValue = new Dictionary <string, Simple>();
TMap _map18 = iprot.ReadMapBegin();
for (int _i19 = 0; _i19 < _map18.Count; ++_i19)
{
string _key20;
Simple _val21;
_key20 = iprot.ReadString();
_val21 = new Simple();
_val21.Read(iprot);
MapValue[_key20] = _val21;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List)
{
{
ListSetMap = new List <THashSet <Dictionary <string, List <Simple> > > >();
TList _list22 = iprot.ReadListBegin();
for (int _i23 = 0; _i23 < _list22.Count; ++_i23)
{
THashSet <Dictionary <string, List <Simple> > > _elem24;
{
_elem24 = new THashSet <Dictionary <string, List <Simple> > >();
TSet _set25 = iprot.ReadSetBegin();
for (int _i26 = 0; _i26 < _set25.Count; ++_i26)
{
Dictionary <string, List <Simple> > _elem27;
{
_elem27 = new Dictionary <string, List <Simple> >();
TMap _map28 = iprot.ReadMapBegin();
for (int _i29 = 0; _i29 < _map28.Count; ++_i29)
{
string _key30;
List <Simple> _val31;
_key30 = iprot.ReadString();
{
_val31 = new List <Simple>();
TList _list32 = iprot.ReadListBegin();
for (int _i33 = 0; _i33 < _list32.Count; ++_i33)
{
Simple _elem34;
_elem34 = new Simple();
_elem34.Read(iprot);
_val31.Add(_elem34);
}
iprot.ReadListEnd();
}
_elem27[_key30] = _val31;
}
iprot.ReadMapEnd();
}
_elem24.Add(_elem27);
}
iprot.ReadSetEnd();
}
ListSetMap.Add(_elem24);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Map)
{
{
MapList = new Dictionary <string, List <Dictionary <string, Simple> > >();
TMap _map35 = iprot.ReadMapBegin();
for (int _i36 = 0; _i36 < _map35.Count; ++_i36)
{
string _key37;
List <Dictionary <string, Simple> > _val38;
_key37 = iprot.ReadString();
{
_val38 = new List <Dictionary <string, Simple> >();
TList _list39 = iprot.ReadListBegin();
for (int _i40 = 0; _i40 < _list39.Count; ++_i40)
{
Dictionary <string, Simple> _elem41;
{
_elem41 = new Dictionary <string, Simple>();
TMap _map42 = iprot.ReadMapBegin();
for (int _i43 = 0; _i43 < _map42.Count; ++_i43)
{
string _key44;
Simple _val45;
_key44 = iprot.ReadString();
_val45 = new Simple();
_val45.Read(iprot);
_elem41[_key44] = _val45;
}
iprot.ReadMapEnd();
}
_val38.Add(_elem41);
}
iprot.ReadListEnd();
}
MapList[_key37] = _val38;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.List)
{
{
ListOfList = new List <List <string> >();
TList _list46 = iprot.ReadListBegin();
for (int _i47 = 0; _i47 < _list46.Count; ++_i47)
{
List <string> _elem48;
{
_elem48 = new List <string>();
TList _list49 = iprot.ReadListBegin();
for (int _i50 = 0; _i50 < _list49.Count; ++_i50)
{
string _elem51;
_elem51 = iprot.ReadString();
_elem48.Add(_elem51);
}
iprot.ReadListEnd();
}
ListOfList.Add(_elem48);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
ListOfListOfList = new List <List <List <string> > >();
TList _list52 = iprot.ReadListBegin();
for (int _i53 = 0; _i53 < _list52.Count; ++_i53)
{
List <List <string> > _elem54;
{
_elem54 = new List <List <string> >();
TList _list55 = iprot.ReadListBegin();
for (int _i56 = 0; _i56 < _list55.Count; ++_i56)
{
List <string> _elem57;
{
_elem57 = new List <string>();
TList _list58 = iprot.ReadListBegin();
for (int _i59 = 0; _i59 < _list58.Count; ++_i59)
{
string _elem60;
_elem60 = iprot.ReadString();
_elem57.Add(_elem60);
}
iprot.ReadListEnd();
}
_elem54.Add(_elem57);
}
iprot.ReadListEnd();
}
ListOfListOfList.Add(_elem54);
}
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_Name = false;
bool isset_ID = false;
bool isset_Language = false;
bool isset_Addresses = 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)
{
Name = iprot.ReadString();
isset_Name = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
ID = iprot.ReadString();
isset_ID = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Language = iprot.ReadString();
isset_Language = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List)
{
{
Addresses = new List <MIPAddress>();
TList _list8 = iprot.ReadListBegin();
for (int _i9 = 0; _i9 < _list8.Count; ++_i9)
{
MIPAddress _elem10;
_elem10 = new MIPAddress();
_elem10.Read(iprot);
Addresses.Add(_elem10);
}
iprot.ReadListEnd();
}
isset_Addresses = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Map)
{
{
Properties = new Dictionary <string, string>();
TMap _map11 = iprot.ReadMapBegin();
for (int _i12 = 0; _i12 < _map11.Count; ++_i12)
{
string _key13;
string _val14;
_key13 = iprot.ReadString();
_val14 = iprot.ReadString();
Properties[_key13] = _val14;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
Parameters = new List <MParameter>();
TList _list15 = iprot.ReadListBegin();
for (int _i16 = 0; _i16 < _list15.Count; ++_i16)
{
MParameter _elem17;
_elem17 = new MParameter();
_elem17.Read(iprot);
Parameters.Add(_elem17);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_Name)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Name not set");
}
if (!isset_ID)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field ID not set");
}
if (!isset_Language)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Language not set");
}
if (!isset_Addresses)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Addresses not set");
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_row = false;
bool isset_columns = false;
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
Row = await iprot.ReadBinaryAsync(cancellationToken);
isset_row = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.List)
{
{
Columns = new List <TColumnIncrement>();
TList _list35 = await iprot.ReadListBeginAsync(cancellationToken);
for (int _i36 = 0; _i36 < _list35.Count; ++_i36)
{
TColumnIncrement _elem37;
_elem37 = new TColumnIncrement();
await _elem37.ReadAsync(iprot, cancellationToken);
Columns.Add(_elem37);
}
await iprot.ReadListEndAsync(cancellationToken);
}
isset_columns = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Map)
{
{
Attributes = new Dictionary <byte[], byte[]>();
TMap _map38 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i39 = 0; _i39 < _map38.Count; ++_i39)
{
byte[] _key40;
byte[] _val41;
_key40 = await iprot.ReadBinaryAsync(cancellationToken);
_val41 = await iprot.ReadBinaryAsync(cancellationToken);
Attributes[_key40] = _val41;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.I32)
{
Durability = (TDurability)await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.Struct)
{
CellVisibility = new TCellVisibility();
await CellVisibility.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
if (!isset_row)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_columns)
{
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.String)
{
Type = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
Data = new Dictionary <string, string>();
TMap _map0 = iprot.ReadMapBegin();
for (int _i1 = 0; _i1 < _map0.Count; ++_i1)
{
string _key2;
string _val3;
_key2 = iprot.ReadString();
_val3 = iprot.ReadString();
Data[_key2] = _val3;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public string Accept(TMap type, string x)
{
return($"{x} or {{}}");
}
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)
{
method = (Method)iprot.ReadI32();
__isset.method = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
uri = iprot.ReadString();
__isset.uri = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
parameters = new Dictionary <string, string>();
TMap _map0 = iprot.ReadMapBegin();
for (int _i1 = 0; _i1 < _map0.Count; ++_i1)
{
string _key2;
string _val3;
_key2 = iprot.ReadString();
_val3 = iprot.ReadString();
parameters[_key2] = _val3;
}
iprot.ReadMapEnd();
}
__isset.parameters = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Map)
{
{
headers = new Dictionary <string, string>();
TMap _map4 = iprot.ReadMapBegin();
for (int _i5 = 0; _i5 < _map4.Count; ++_i5)
{
string _key6;
string _val7;
_key6 = iprot.ReadString();
_val7 = iprot.ReadString();
headers[_key6] = _val7;
}
iprot.ReadMapEnd();
}
__isset.headers = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
body = iprot.ReadBinary();
__isset.body = true;
}
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.I32)
{
StageType = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.I32)
{
TerrainDataType = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 20:
if (field.Type == TType.Struct)
{
PlayerTransformInfo = new ThriftTransformData();
PlayerTransformInfo.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 30:
if (field.Type == TType.Bool)
{
IsResumeScene = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 40:
if (field.Type == TType.I32)
{
ActionId = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 50:
if (field.Type == TType.I32)
{
ExitSceneFuncId = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 51:
if (field.Type == TType.I32)
{
ExitSceneStep2FuncId = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 60:
if (field.Type == TType.Map)
{
{
NpcTransformInfoList = new Dictionary <int, ThriftTransformData>();
TMap _map12 = iprot.ReadMapBegin();
for (int _i13 = 0; _i13 < _map12.Count; ++_i13)
{
int _key14;
ThriftTransformData _val15;
_key14 = iprot.ReadI32();
_val15 = new ThriftTransformData();
_val15.Read(iprot);
NpcTransformInfoList[_key14] = _val15;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Accept(TMap type, HashSet <DefTypeBase> x)
{
type.KeyType.Apply(this, x);
type.ValueType.Apply(this, x);
}
public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct)
{
Cells = new Cells();
await Cells.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
TMap _map407 = await iprot.ReadMapBeginAsync(cancellationToken);
Ccells = new Dictionary <string, ColCells>(_map407.Count);
for (int _i408 = 0; _i408 < _map407.Count; ++_i408)
{
string _key409;
ColCells _val410;
_key409 = await iprot.ReadStringAsync(cancellationToken);
_val410 = new ColCells();
await _val410.ReadAsync(iprot, cancellationToken);
Ccells[_key409] = _val410;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.List)
{
{
TList _list411 = await iprot.ReadListBeginAsync(cancellationToken);
Kcells = new List <kCells>(_list411.Count);
for (int _i412 = 0; _i412 < _list411.Count; ++_i412)
{
kCells _elem413;
_elem413 = new kCells();
await _elem413.ReadAsync(iprot, cancellationToken);
Kcells.Add(_elem413);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Struct)
{
Fcells = new FCells();
await Fcells.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
}
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.Map)
{
{
Name_types = new Dictionary <byte[], string>();
TMap _map65 = iprot.ReadMapBegin();
for (int _i66 = 0; _i66 < _map65.Count; ++_i66)
{
byte[] _key67;
string _val68;
_key67 = iprot.ReadBinary();
_val68 = iprot.ReadString();
Name_types[_key67] = _val68;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
Value_types = new Dictionary <byte[], string>();
TMap _map69 = iprot.ReadMapBegin();
for (int _i70 = 0; _i70 < _map69.Count; ++_i70)
{
byte[] _key71;
string _val72;
_key71 = iprot.ReadBinary();
_val72 = iprot.ReadString();
Value_types[_key71] = _val72;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Default_name_type = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
Default_value_type = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.List)
{
{
SquareMembers = new List <SquareMember>();
TList _list369 = await iprot.ReadListBeginAsync(cancellationToken);
for (int _i370 = 0; _i370 < _list369.Count; ++_i370)
{
SquareMember _elem371;
_elem371 = new SquareMember();
await _elem371.ReadAsync(iprot, cancellationToken);
SquareMembers.Add(_elem371);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
Relations = new Dictionary <string, SquareMemberRelation>();
TMap _map372 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i373 = 0; _i373 < _map372.Count; ++_i373)
{
string _key374;
SquareMemberRelation _val375;
_key374 = await iprot.ReadStringAsync(cancellationToken);
_val375 = new SquareMemberRelation();
await _val375.ReadAsync(iprot, cancellationToken);
Relations[_key374] = _val375;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.String)
{
ContinuationToken = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
}
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.Map)
{
{
UserPrivileges = new Dictionary <string, List <PrivilegeGrantInfo> >();
TMap _map12 = iprot.ReadMapBegin();
for (int _i13 = 0; _i13 < _map12.Count; ++_i13)
{
string _key14;
List <PrivilegeGrantInfo> _val15;
_key14 = iprot.ReadString();
{
_val15 = new List <PrivilegeGrantInfo>();
TList _list16 = iprot.ReadListBegin();
for (int _i17 = 0; _i17 < _list16.Count; ++_i17)
{
PrivilegeGrantInfo _elem18 = new PrivilegeGrantInfo();
_elem18 = new PrivilegeGrantInfo();
_elem18.Read(iprot);
_val15.Add(_elem18);
}
iprot.ReadListEnd();
}
UserPrivileges[_key14] = _val15;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
GroupPrivileges = new Dictionary <string, List <PrivilegeGrantInfo> >();
TMap _map19 = iprot.ReadMapBegin();
for (int _i20 = 0; _i20 < _map19.Count; ++_i20)
{
string _key21;
List <PrivilegeGrantInfo> _val22;
_key21 = iprot.ReadString();
{
_val22 = new List <PrivilegeGrantInfo>();
TList _list23 = iprot.ReadListBegin();
for (int _i24 = 0; _i24 < _list23.Count; ++_i24)
{
PrivilegeGrantInfo _elem25 = new PrivilegeGrantInfo();
_elem25 = new PrivilegeGrantInfo();
_elem25.Read(iprot);
_val22.Add(_elem25);
}
iprot.ReadListEnd();
}
GroupPrivileges[_key21] = _val22;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
RolePrivileges = new Dictionary <string, List <PrivilegeGrantInfo> >();
TMap _map26 = iprot.ReadMapBegin();
for (int _i27 = 0; _i27 < _map26.Count; ++_i27)
{
string _key28;
List <PrivilegeGrantInfo> _val29;
_key28 = iprot.ReadString();
{
_val29 = new List <PrivilegeGrantInfo>();
TList _list30 = iprot.ReadListBegin();
for (int _i31 = 0; _i31 < _list30.Count; ++_i31)
{
PrivilegeGrantInfo _elem32 = new PrivilegeGrantInfo();
_elem32 = new PrivilegeGrantInfo();
_elem32.Read(iprot);
_val29.Add(_elem32);
}
iprot.ReadListEnd();
}
RolePrivileges[_key28] = _val29;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public string Accept(TMap type, string json, string field)
{
return("");
}
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)
{
SubjectDate = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Double)
{
Latitude = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Double)
{
Longitude = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Double)
{
Altitude = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.String)
{
Author = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.String)
{
Source = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.String)
{
SourceURL = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.String)
{
SourceApplication = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.I64)
{
ShareDate = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.I64)
{
ReminderOrder = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.I64)
{
ReminderDoneTime = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 20:
if (field.Type == TType.I64)
{
ReminderTime = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 21:
if (field.Type == TType.String)
{
PlaceName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 22:
if (field.Type == TType.String)
{
ContentClass = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 23:
if (field.Type == TType.Struct)
{
ApplicationData = new LazyMap();
ApplicationData.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 24:
if (field.Type == TType.String)
{
LastEditedBy = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 26:
if (field.Type == TType.Map)
{
{
Classifications = new Dictionary <string, string>();
TMap _map17 = iprot.ReadMapBegin();
for (int _i18 = 0; _i18 < _map17.Count; ++_i18)
{
string _key19;
string _val20;
_key19 = iprot.ReadString();
_val20 = iprot.ReadString();
Classifications[_key19] = _val20;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 27:
if (field.Type == TType.I32)
{
CreatorId = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 28:
if (field.Type == TType.I32)
{
LastEditorId = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 29:
if (field.Type == TType.Bool)
{
SharedWithBusiness = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 30:
if (field.Type == TType.String)
{
ConflictSourceNoteGuid = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 31:
if (field.Type == TType.I32)
{
NoteTitleQuality = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public DType Accept(TMap type, string x)
{
throw new NotImplementedException();
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
CreateTime = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.String)
{
RegionCode = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
TMap _map174 = await iprot.ReadMapBeginAsync(cancellationToken);
Identities = new Dictionary <RegistrationType, string>(_map174.Count);
for (int _i175 = 0; _i175 < _map174.Count; ++_i175)
{
RegistrationType _key176;
string _val177;
_key176 = (RegistrationType)await iprot.ReadI32Async(cancellationToken);
_val177 = await iprot.ReadStringAsync(cancellationToken);
Identities[_key176] = _val177;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
}
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)
{
DisplayName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
AvatarUrl = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List)
{
{
Identities = new List <THIdentity>();
TList _list24 = iprot.ReadListBegin();
for (int _i25 = 0; _i25 < _list24.Count; ++_i25)
{
THIdentity _elem26;
_elem26 = new THIdentity();
_elem26.Read(iprot);
Identities.Add(_elem26);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Map)
{
{
PublicProperties = new Dictionary <string, string>();
TMap _map27 = iprot.ReadMapBegin();
for (int _i28 = 0; _i28 < _map27.Count; ++_i28)
{
string _key29;
string _val30;
_key29 = iprot.ReadString();
_val30 = iprot.ReadString();
PublicProperties[_key29] = _val30;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Map)
{
{
InternalPublicProperties = new Dictionary <string, string>();
TMap _map31 = iprot.ReadMapBegin();
for (int _i32 = 0; _i32 < _map31.Count; ++_i32)
{
string _key33;
string _val34;
_key33 = iprot.ReadString();
_val34 = iprot.ReadString();
InternalPublicProperties[_key33] = _val34;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
InstallDate = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
InstallProvider = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.I32)
{
InstallPlatform = (THDeviceOs)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Bool)
{
Reinstall = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Bool)
{
InstallSuspicious = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.String)
{
InstallPlatformStr = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public override async Task WriteMapBeginAsync(TMap map, CancellationToken cancellationToken)
{
await _wrappedProtocol.WriteMapBeginAsync(map, cancellationToken);
}
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)
{
{
Cols = new List <FieldSchema>();
TList _list78 = iprot.ReadListBegin();
for (int _i79 = 0; _i79 < _list78.Count; ++_i79)
{
FieldSchema _elem80 = new FieldSchema();
_elem80 = new FieldSchema();
_elem80.Read(iprot);
Cols.Add(_elem80);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Location = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
InputFormat = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
OutputFormat = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
Compressed = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I32)
{
NumBuckets = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
SerdeInfo = new SerDeInfo();
SerdeInfo.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
BucketCols = new List <string>();
TList _list81 = iprot.ReadListBegin();
for (int _i82 = 0; _i82 < _list81.Count; ++_i82)
{
string _elem83 = null;
_elem83 = iprot.ReadString();
BucketCols.Add(_elem83);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
SortCols = new List <Order>();
TList _list84 = iprot.ReadListBegin();
for (int _i85 = 0; _i85 < _list84.Count; ++_i85)
{
Order _elem86 = new Order();
_elem86 = new Order();
_elem86.Read(iprot);
SortCols.Add(_elem86);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Map)
{
{
Parameters = new Dictionary <string, string>();
TMap _map87 = iprot.ReadMapBegin();
for (int _i88 = 0; _i88 < _map87.Count; ++_i88)
{
string _key89;
string _val90;
_key89 = iprot.ReadString();
_val90 = iprot.ReadString();
Parameters[_key89] = _val90;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
SkewedInfo = new SkewedInfo();
SkewedInfo.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Bool)
{
StoredAsSubDirectories = 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.Struct)
{
Tid = new Tid();
Tid.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Nickname = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Remarkname = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
Brithday = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I16)
{
Gender = iprot.ReadI16();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
Headurl = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
Area = new TimArea();
Area.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
Headbyte = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
PhotoBytes = new List <byte[]>();
TList _list36 = iprot.ReadListBegin();
for (int _i37 = 0; _i37 < _list36.Count; ++_i37)
{
byte[] _elem38;
_elem38 = iprot.ReadBinary();
PhotoBytes.Add(_elem38);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
ExtraList = new List <TimNode>();
TList _list39 = iprot.ReadListBegin();
for (int _i40 = 0; _i40 < _list39.Count; ++_i40)
{
TimNode _elem41;
_elem41 = new TimNode();
_elem41.Read(iprot);
ExtraList.Add(_elem41);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Map)
{
{
ExtraMap = new Dictionary <string, string>();
TMap _map42 = iprot.ReadMapBegin();
for (int _i43 = 0; _i43 < _map42.Count; ++_i43)
{
string _key44;
string _val45;
_key44 = iprot.ReadString();
_val45 = iprot.ReadString();
ExtraMap[_key44] = _val45;
}
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.I32)
{
Status = (Status)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
Columns = new List <Dictionary <string, ValueType> >();
TList _list5 = iprot.ReadListBegin();
for (int _i6 = 0; _i6 < _list5.Count; ++_i6)
{
Dictionary <string, ValueType> _elem7;
{
_elem7 = new Dictionary <string, ValueType>();
TMap _map8 = iprot.ReadMapBegin();
for (int _i9 = 0; _i9 < _map8.Count; ++_i9)
{
string _key10;
ValueType _val11;
_key10 = iprot.ReadString();
_val11 = (ValueType)iprot.ReadI32();
_elem7[_key10] = _val11;
}
iprot.ReadMapEnd();
}
Columns.Add(_elem7);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.List)
{
{
Rows = new List <List <Field> >();
TList _list12 = iprot.ReadListBegin();
for (int _i13 = 0; _i13 < _list12.Count; ++_i13)
{
List <Field> _elem14;
{
_elem14 = new List <Field>();
TList _list15 = iprot.ReadListBegin();
for (int _i16 = 0; _i16 < _list15.Count; ++_i16)
{
Field _elem17;
_elem17 = new Field();
_elem17.Read(iprot);
_elem14.Add(_elem17);
}
iprot.ReadListEnd();
}
Rows.Add(_elem14);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
Error = 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)
{
ThreadId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct)
{
Error = new TimError();
Error.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.List)
{
{
ExtraList = new List <TimNode>();
TList _list108 = iprot.ReadListBegin();
for (int _i109 = 0; _i109 < _list108.Count; ++_i109)
{
TimNode _elem110;
_elem110 = new TimNode();
_elem110.Read(iprot);
ExtraList.Add(_elem110);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Map)
{
{
ExtraMap = new Dictionary <string, string>();
TMap _map111 = iprot.ReadMapBegin();
for (int _i112 = 0; _i112 < _map111.Count; ++_i112)
{
string _key113;
string _val114;
_key113 = iprot.ReadString();
_val114 = iprot.ReadString();
ExtraMap[_key113] = _val114;
}
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.String)
{
To = iprot.ReadString();
}
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)
{
OfflineThreadingID = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Struct)
{
Coordinates = new Coordinates();
Coordinates.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Map)
{
{
ClientTags = new Dictionary <string, string>();
TMap _map0 = iprot.ReadMapBegin();
for (int _i1 = 0; _i1 < _map0.Count; ++_i1)
{
string _key2;
string _val3;
_key2 = iprot.ReadString();
_val3 = iprot.ReadString();
ClientTags[_key2] = _val3;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
ObjectAttachement = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
CopyMessageID = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
CopyAttachementID = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
MediaAttachementsID = new List <string>();
TList _list4 = iprot.ReadListBegin();
for (int _i5 = 0; _i5 < _list4.Count; ++_i5)
{
string _elem6;
_elem6 = iprot.ReadString();
MediaAttachementsID.Add(_elem6);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
FBTraceMeta = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.I32)
{
ImageType = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.I64)
{
SenderFBID = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Map)
{
{
BroadcastRecipients = new Dictionary <string, string>();
TMap _map7 = iprot.ReadMapBegin();
for (int _i8 = 0; _i8 < _map7.Count; ++_i8)
{
string _key9;
string _val10;
_key9 = iprot.ReadString();
_val10 = iprot.ReadString();
BroadcastRecipients[_key9] = _val10;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.I64)
{
AtributionAppID = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.String)
{
IOSBundleID = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.String)
{
AndroidKeyHash = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.Struct)
{
LocationAttachement = new LocationAttachement();
LocationAttachement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_AvatarID = false;
bool isset_ZeroPosture = 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)
{
AvatarID = iprot.ReadString();
isset_AvatarID = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct)
{
ZeroPosture = new MAvatarPosture();
ZeroPosture.Read(iprot);
isset_ZeroPosture = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
Properties = new Dictionary <string, string>();
TMap _map25 = iprot.ReadMapBegin();
for (int _i26 = 0; _i26 < _map25.Count; ++_i26)
{
string _key27;
string _val28;
_key27 = iprot.ReadString();
_val28 = iprot.ReadString();
Properties[_key27] = _val28;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_AvatarID)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field AvatarID not set");
}
if (!isset_ZeroPosture)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field ZeroPosture not set");
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_status = false;
bool isset_serverProtocolVersion = false;
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct)
{
Status = new TStatus();
await Status.ReadAsync(iprot, cancellationToken);
isset_status = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.I32)
{
ServerProtocolVersion = (TProtocolVersion)await iprot.ReadI32Async(cancellationToken);
isset_serverProtocolVersion = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Struct)
{
SessionHandle = new TSessionHandle();
await SessionHandle.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Map)
{
{
TMap _map76 = await iprot.ReadMapBeginAsync(cancellationToken);
Configuration = new Dictionary <string, string>(_map76.Count);
for (int _i77 = 0; _i77 < _map76.Count; ++_i77)
{
string _key78;
string _val79;
_key78 = await iprot.ReadStringAsync(cancellationToken);
_val79 = await iprot.ReadStringAsync(cancellationToken);
Configuration[_key78] = _val79;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
if (!isset_status)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_serverProtocolVersion)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
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)
{
TaskId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
TaskType = (TaskType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
TaskAttributes = new Dictionary <string, string>();
TMap _map22 = iprot.ReadMapBegin();
for (int _i23 = 0; _i23 < _map22.Count; ++_i23)
{
string _key24;
string _val25;
_key24 = iprot.ReadString();
_val25 = iprot.ReadString();
TaskAttributes[_key24] = _val25;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Map)
{
{
TaskCounters = new Dictionary <string, long>();
TMap _map26 = iprot.ReadMapBegin();
for (int _i27 = 0; _i27 < _map26.Count; ++_i27)
{
string _key28;
long _val29;
_key28 = iprot.ReadString();
_val29 = iprot.ReadI64();
TaskCounters[_key28] = _val29;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Struct)
{
OperatorGraph = new Graph();
OperatorGraph.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
OperatorList = new List <Operator>();
TList _list30 = iprot.ReadListBegin();
for (int _i31 = 0; _i31 < _list30.Count; ++_i31)
{
Operator _elem32 = new Operator();
_elem32 = new Operator();
_elem32.Read(iprot);
OperatorList.Add(_elem32);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Bool)
{
Done = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.Bool)
{
Started = 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.Map) {
{
Window_to_emitted = new Dictionary<string, long>();
TMap _map176 = iprot.ReadMapBegin();
for( int _i177 = 0; _i177 < _map176.Count; ++_i177)
{
string _key178;
long _val179;
_key178 = iprot.ReadString();
_val179 = iprot.ReadI64();
Window_to_emitted[_key178] = _val179;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map) {
{
Window_to_transferred = new Dictionary<string, long>();
TMap _map180 = iprot.ReadMapBegin();
for( int _i181 = 0; _i181 < _map180.Count; ++_i181)
{
string _key182;
long _val183;
_key182 = iprot.ReadString();
_val183 = iprot.ReadI64();
Window_to_transferred[_key182] = _val183;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map) {
{
Window_to_complete_latencies_ms = new Dictionary<string, double>();
TMap _map184 = iprot.ReadMapBegin();
for( int _i185 = 0; _i185 < _map184.Count; ++_i185)
{
string _key186;
double _val187;
_key186 = iprot.ReadString();
_val187 = iprot.ReadDouble();
Window_to_complete_latencies_ms[_key186] = _val187;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Map) {
{
Window_to_acked = new Dictionary<string, long>();
TMap _map188 = iprot.ReadMapBegin();
for( int _i189 = 0; _i189 < _map188.Count; ++_i189)
{
string _key190;
long _val191;
_key190 = iprot.ReadString();
_val191 = iprot.ReadI64();
Window_to_acked[_key190] = _val191;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Map) {
{
Window_to_failed = new Dictionary<string, long>();
TMap _map192 = iprot.ReadMapBegin();
for( int _i193 = 0; _i193 < _map192.Count; ++_i193)
{
string _key194;
long _val195;
_key194 = iprot.ReadString();
_val195 = iprot.ReadI64();
Window_to_failed[_key194] = _val195;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public string Accept(TMap type, string bufName, string fieldName)
{
return($"{fieldName}.Serialize({bufName});");
}
