public async Task ReadAsync(TProtocol protocol, CancellationToken cancellationToken)
{
bool isset_qualifiers = false;
TField field;
await protocol.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await protocol.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Map)
{
Qualifiers = new Dictionary <string, TypeQualifierValue>();
TMap map = await protocol.ReadMapBeginAsync(cancellationToken);
for (int i = 0; i < map.Count; ++i)
{
string key;
TypeQualifierValue val;
key = await protocol.ReadStringAsync(cancellationToken);
val = new TypeQualifierValue();
await val.ReadAsync(protocol, cancellationToken);
Qualifiers[key] = val;
}
await protocol.ReadMapEndAsync(cancellationToken);
isset_qualifiers = true;
}
else
{
await TProtocolUtil.SkipAsync(protocol, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(protocol, field.Type, cancellationToken);
break;
}
await protocol.ReadFieldEndAsync(cancellationToken);
}
await protocol.ReadStructEndAsync(cancellationToken);
if (!isset_qualifiers)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
public async Task ReadAsync(TProtocol protocol, CancellationToken cancellationToken)
{
bool isset_nameToTypePtr = false;
TField field;
await protocol.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await protocol.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Map)
{
NameToTypePtr = new Dictionary <string, int>();
TMap map = await protocol.ReadMapBeginAsync(cancellationToken);
for (int i = 0; i < map.Count; ++i)
{
var key = await protocol.ReadStringAsync(cancellationToken);
var val = await protocol.ReadI32Async(cancellationToken);
NameToTypePtr[key] = val;
}
await protocol.ReadMapEndAsync(cancellationToken);
isset_nameToTypePtr = true;
}
else
{
await TProtocolUtil.SkipAsync(protocol, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(protocol, field.Type, cancellationToken);
break;
}
await protocol.ReadFieldEndAsync(cancellationToken);
}
await protocol.ReadStructEndAsync(cancellationToken);
if (!isset_nameToTypePtr)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
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.String)
{
_from = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.String)
{
To = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.I32)
{
ToType = (MIDType)await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.String)
{
Id = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.I64)
{
CreatedTime = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.I64)
{
DeliveredTime = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 10:
if (field.Type == TType.String)
{
Text = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 11:
if (field.Type == TType.Struct)
{
Location = new Location();
await Location.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 14:
if (field.Type == TType.Bool)
{
HasContent = await iprot.ReadBoolAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 15:
if (field.Type == TType.I32)
{
ContentType = (ContentType)await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 17:
if (field.Type == TType.String)
{
ContentPreview = await iprot.ReadBinaryAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 18:
if (field.Type == TType.Map)
{
{
TMap _map157 = await iprot.ReadMapBeginAsync(cancellationToken);
ContentMetadata = new Dictionary <string, string>(_map157.Count);
for (int _i158 = 0; _i158 < _map157.Count; ++_i158)
{
string _key159;
string _val160;
_key159 = await iprot.ReadStringAsync(cancellationToken);
_val160 = await iprot.ReadStringAsync(cancellationToken);
ContentMetadata[_key159] = _val160;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 19:
if (field.Type == TType.Byte)
{
SessionId = await iprot.ReadByteAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 20:
if (field.Type == TType.List)
{
{
TList _list161 = await iprot.ReadListBeginAsync(cancellationToken);
Chunks = new List <byte[]>(_list161.Count);
for (int _i162 = 0; _i162 < _list161.Count; ++_i162)
{
byte[] _elem163;
_elem163 = await iprot.ReadBinaryAsync(cancellationToken);
Chunks.Add(_elem163);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 21:
if (field.Type == TType.String)
{
RelatedMessageId = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 22:
if (field.Type == TType.I32)
{
MessageRelationType = (MessageRelationType)await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 23:
if (field.Type == TType.I64)
{
ReadCount = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 24:
if (field.Type == TType.I32)
{
RelatedMessageServiceCode = (ServiceCode)await iprot.ReadI32Async(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 async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_row = 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 <TColumn>();
TList _list8 = await iprot.ReadListBeginAsync(cancellationToken);
for (int _i9 = 0; _i9 < _list8.Count; ++_i9)
{
TColumn _elem10;
_elem10 = new TColumn();
await _elem10.ReadAsync(iprot, cancellationToken);
Columns.Add(_elem10);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.I64)
{
Timestamp = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Struct)
{
TimeRange = new TTimeRange();
await TimeRange.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.I32)
{
MaxVersions = await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.String)
{
FilterString = await iprot.ReadBinaryAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
if (field.Type == TType.Map)
{
{
Attributes = new Dictionary <byte[], byte[]>();
TMap _map11 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i12 = 0; _i12 < _map11.Count; ++_i12)
{
byte[] _key13;
byte[] _val14;
_key13 = await iprot.ReadBinaryAsync(cancellationToken);
_val14 = await iprot.ReadBinaryAsync(cancellationToken);
Attributes[_key13] = _val14;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 8:
if (field.Type == TType.Struct)
{
Authorizations = new TAuthorization();
await Authorizations.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);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
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)
{
{
TList _list503 = await iprot.ReadListBeginAsync(cancellationToken);
Chats = new List <SquareChat>(_list503.Count);
for (int _i504 = 0; _i504 < _list503.Count; ++_i504)
{
SquareChat _elem505;
_elem505 = new SquareChat();
await _elem505.ReadAsync(iprot, cancellationToken);
Chats.Add(_elem505);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
TMap _map506 = await iprot.ReadMapBeginAsync(cancellationToken);
ChatMembers = new Dictionary <string, SquareChatMember>(_map506.Count);
for (int _i507 = 0; _i507 < _map506.Count; ++_i507)
{
string _key508;
SquareChatMember _val509;
_key508 = await iprot.ReadStringAsync(cancellationToken);
_val509 = new SquareChatMember();
await _val509.ReadAsync(iprot, cancellationToken);
ChatMembers[_key508] = _val509;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
TMap _map510 = await iprot.ReadMapBeginAsync(cancellationToken);
Statuses = new Dictionary <string, SquareChatStatus>(_map510.Count);
for (int _i511 = 0; _i511 < _map510.Count; ++_i511)
{
string _key512;
SquareChatStatus _val513;
_key512 = await iprot.ReadStringAsync(cancellationToken);
_val513 = new SquareChatStatus();
await _val513.ReadAsync(iprot, cancellationToken);
Statuses[_key512] = _val513;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
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 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 7:
if (field.Type == TType.Map)
{
{
TMap _map101 = await iprot.ReadMapBeginAsync(cancellationToken);
Map_field = new Dictionary <string, string>(_map101.Count);
for (int _i102 = 0; _i102 < _map101.Count; ++_i102)
{
string _key103;
string _val104;
_key103 = await iprot.ReadStringAsync(cancellationToken);
_val104 = await iprot.ReadStringAsync(cancellationToken);
Map_field[_key103] = _val104;
}
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 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.Set)
{
{
UpdatedAttrs = new THashSet <SquareMemberAttribute>();
TSet _set441 = await iprot.ReadSetBeginAsync(cancellationToken);
for (int _i442 = 0; _i442 < _set441.Count; ++_i442)
{
SquareMemberAttribute _elem443;
_elem443 = (SquareMemberAttribute)await iprot.ReadI32Async(cancellationToken);
UpdatedAttrs.Add(_elem443);
}
await iprot.ReadSetEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Struct)
{
Editor = new SquareMember();
await Editor.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
Members = new Dictionary <string, SquareMember>();
TMap _map444 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i445 = 0; _i445 < _map444.Count; ++_i445)
{
string _key446;
SquareMember _val447;
_key446 = await iprot.ReadStringAsync(cancellationToken);
_val447 = new SquareMember();
await _val447.ReadAsync(iprot, cancellationToken);
Members[_key446] = _val447;
}
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 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.Struct)
{
CateNode = new CategoryNode();
await CateNode.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
SettingCategories = new Dictionary <string, Ruyi.SDK.CommonType.SettingCategory>();
TMap _map8 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i9 = 0; _i9 < _map8.Count; ++_i9)
{
string _key10;
Ruyi.SDK.CommonType.SettingCategory _val11;
_key10 = await iprot.ReadStringAsync(cancellationToken);
_val11 = new Ruyi.SDK.CommonType.SettingCategory();
await _val11.ReadAsync(iprot, cancellationToken);
SettingCategories[_key10] = _val11;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
SettingItems = new Dictionary <string, Ruyi.SDK.CommonType.SettingItem>();
TMap _map12 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i13 = 0; _i13 < _map12.Count; ++_i13)
{
string _key14;
Ruyi.SDK.CommonType.SettingItem _val15;
_key14 = await iprot.ReadStringAsync(cancellationToken);
_val15 = new Ruyi.SDK.CommonType.SettingItem();
await _val15.ReadAsync(iprot, cancellationToken);
SettingItems[_key14] = _val15;
}
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 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.I32)
{
Code = (PointErrorCode)await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.String)
{
Reason = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
Extra = new Dictionary <string, string>();
TMap _map522 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i523 = 0; _i523 < _map522.Count; ++_i523)
{
string _key524;
string _val525;
_key524 = await iprot.ReadStringAsync(cancellationToken);
_val525 = await iprot.ReadStringAsync(cancellationToken);
Extra[_key524] = _val525;
}
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 async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_status = 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 TSStatus();
await Status.ReadAsync(iprot, cancellationToken);
isset_status = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.I64)
{
QueryId = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.List)
{
{
TList _list4 = await iprot.ReadListBeginAsync(cancellationToken);
Columns = new List <string>(_list4.Count);
for (int _i5 = 0; _i5 < _list4.Count; ++_i5)
{
string _elem6;
_elem6 = await iprot.ReadStringAsync(cancellationToken);
Columns.Add(_elem6);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.String)
{
OperationType = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IgnoreTimeStamp = await iprot.ReadBoolAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.List)
{
{
TList _list7 = await iprot.ReadListBeginAsync(cancellationToken);
DataTypeList = new List <string>(_list7.Count);
for (int _i8 = 0; _i8 < _list7.Count; ++_i8)
{
string _elem9;
_elem9 = await iprot.ReadStringAsync(cancellationToken);
DataTypeList.Add(_elem9);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
if (field.Type == TType.Struct)
{
QueryDataSet = new TSQueryDataSet();
await QueryDataSet.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 8:
if (field.Type == TType.Struct)
{
NonAlignQueryDataSet = new TSQueryNonAlignDataSet();
await NonAlignQueryDataSet.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 9:
if (field.Type == TType.Map)
{
{
TMap _map10 = await iprot.ReadMapBeginAsync(cancellationToken);
ColumnNameIndexMap = new Dictionary <string, int>(_map10.Count);
for (int _i11 = 0; _i11 < _map10.Count; ++_i11)
{
string _key12;
int _val13;
_key12 = await iprot.ReadStringAsync(cancellationToken);
_val13 = await iprot.ReadI32Async(cancellationToken);
ColumnNameIndexMap[_key12] = _val13;
}
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);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
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)
{
TtlMillis = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
SubscriptionStates = new Dictionary <long, SubscriptionState>();
TMap _map466 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i467 = 0; _i467 < _map466.Count; ++_i467)
{
long _key468;
SubscriptionState _val469;
_key468 = await iprot.ReadI64Async(cancellationToken);
_val469 = new SubscriptionState();
await _val469.ReadAsync(iprot, cancellationToken);
SubscriptionStates[_key468] = _val469;
}
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 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.String)
{
StartRow = await iprot.ReadBinaryAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.String)
{
StopRow = await iprot.ReadBinaryAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.List)
{
{
Columns = new List <TColumn>();
TList _list53 = await iprot.ReadListBeginAsync(cancellationToken);
for (int _i54 = 0; _i54 < _list53.Count; ++_i54)
{
TColumn _elem55;
_elem55 = new TColumn();
await _elem55.ReadAsync(iprot, cancellationToken);
Columns.Add(_elem55);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.I32)
{
Caching = await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.I32)
{
MaxVersions = await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.Struct)
{
TimeRange = new TTimeRange();
await TimeRange.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
if (field.Type == TType.String)
{
FilterString = await iprot.ReadBinaryAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 8:
if (field.Type == TType.I32)
{
BatchSize = await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 9:
if (field.Type == TType.Map)
{
{
Attributes = new Dictionary <byte[], byte[]>();
TMap _map56 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i57 = 0; _i57 < _map56.Count; ++_i57)
{
byte[] _key58;
byte[] _val59;
_key58 = await iprot.ReadBinaryAsync(cancellationToken);
_val59 = await iprot.ReadBinaryAsync(cancellationToken);
Attributes[_key58] = _val59;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 10:
if (field.Type == TType.Struct)
{
Authorizations = new TAuthorization();
await Authorizations.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 11:
if (field.Type == TType.Bool)
{
Reversed = await iprot.ReadBoolAsync(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 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.String)
{
Id = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.String)
{
Display = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.String)
{
Summary = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.String)
{
Description = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.String)
{
Icon = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.I32)
{
SortingPriority = await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
if (field.Type == TType.Bool)
{
IsSystemCategory = await iprot.ReadBoolAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 8:
if (field.Type == TType.Map)
{
{
Items = new Dictionary <string, int>();
TMap _map24 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i25 = 0; _i25 < _map24.Count; ++_i25)
{
string _key26;
int _val27;
_key26 = await iprot.ReadStringAsync(cancellationToken);
_val27 = await iprot.ReadI32Async(cancellationToken);
Items[_key26] = _val27;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 9:
if (field.Type == TType.Bool)
{
Enable = await iprot.ReadBoolAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 10:
if (field.Type == TType.Bool)
{
ShowInUI = await iprot.ReadBoolAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 11:
if (field.Type == TType.String)
{
Script = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 12:
if (field.Type == TType.List)
{
{
Tags = new List <string>();
TList _list28 = await iprot.ReadListBeginAsync(cancellationToken);
for (int _i29 = 0; _i29 < _list28.Count; ++_i29)
{
string _elem30;
_elem30 = await iprot.ReadStringAsync(cancellationToken);
Tags.Add(_elem30);
}
await iprot.ReadListEndAsync(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 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.String)
{
ChatId = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
TMap _map267 = await iprot.ReadMapBeginAsync(cancellationToken);
Ranges = new Dictionary <string, List <TMessageReadRangeEntry> >(_map267.Count);
for (int _i268 = 0; _i268 < _map267.Count; ++_i268)
{
string _key269;
List <TMessageReadRangeEntry> _val270;
_key269 = await iprot.ReadStringAsync(cancellationToken);
{
TList _list271 = await iprot.ReadListBeginAsync(cancellationToken);
_val270 = new List <TMessageReadRangeEntry>(_list271.Count);
for (int _i272 = 0; _i272 < _list271.Count; ++_i272)
{
TMessageReadRangeEntry _elem273;
_elem273 = new TMessageReadRangeEntry();
await _elem273.ReadAsync(iprot, cancellationToken);
_val270.Add(_elem273);
}
await iprot.ReadListEndAsync(cancellationToken);
}
Ranges[_key269] = _val270;
}
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 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)
{
{
TList _list369 = await iprot.ReadListBeginAsync(cancellationToken);
SquareMembers = new List <SquareMember>(_list369.Count);
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)
{
{
TMap _map372 = await iprot.ReadMapBeginAsync(cancellationToken);
Relations = new Dictionary <string, SquareMemberRelation>(_map372.Count);
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 static async Task <SomeUnion> ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
SomeUnion retval;
await iprot.ReadStructBeginAsync(cancellationToken);
TField field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
await iprot.ReadFieldEndAsync(cancellationToken);
retval = new ___undefined();
}
else
{
switch (field.ID)
{
case 1:
if (field.Type == TType.Map)
{
Dictionary <global::ThriftTest.Numberz, long> temp;
{
TMap _map59 = await iprot.ReadMapBeginAsync(cancellationToken);
temp = new Dictionary <global::ThriftTest.Numberz, long>(_map59.Count);
for (int _i60 = 0; _i60 < _map59.Count; ++_i60)
{
global::ThriftTest.Numberz _key61;
long _val62;
_key61 = (global::ThriftTest.Numberz) await iprot.ReadI32Async(cancellationToken);
_val62 = await iprot.ReadI64Async(cancellationToken);
temp[_key61] = _val62;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
retval = new map_thing(temp);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
retval = new ___undefined();
}
break;
case 2:
if (field.Type == TType.String)
{
string temp;
temp = await iprot.ReadStringAsync(cancellationToken);
retval = new string_thing(temp);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
retval = new ___undefined();
}
break;
case 3:
if (field.Type == TType.I32)
{
int temp;
temp = await iprot.ReadI32Async(cancellationToken);
retval = new i32_thing(temp);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
retval = new ___undefined();
}
break;
case 4:
if (field.Type == TType.Struct)
{
global::ThriftTest.Xtruct3 temp;
temp = new global::ThriftTest.Xtruct3();
await temp.ReadAsync(iprot, cancellationToken);
retval = new xtruct_thing(temp);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
retval = new ___undefined();
}
break;
case 5:
if (field.Type == TType.Struct)
{
global::ThriftTest.Insanity temp;
temp = new global::ThriftTest.Insanity();
await temp.ReadAsync(iprot, cancellationToken);
retval = new insanity_thing(temp);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
retval = new ___undefined();
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
retval = new ___undefined();
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
if ((await iprot.ReadFieldBeginAsync(cancellationToken)).Type != TType.Stop)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
await iprot.ReadStructEndAsync(cancellationToken);
return(retval);
}
finally
{
iprot.DecrementRecursionDepth();
}
}
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)
{
{
TList _list390 = await iprot.ReadListBeginAsync(cancellationToken);
Squares = new List <Square>(_list390.Count);
for (int _i391 = 0; _i391 < _list390.Count; ++_i391)
{
Square _elem392;
_elem392 = new Square();
await _elem392.ReadAsync(iprot, cancellationToken);
Squares.Add(_elem392);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
TMap _map393 = await iprot.ReadMapBeginAsync(cancellationToken);
SquareStatuses = new Dictionary <string, SquareStatus>(_map393.Count);
for (int _i394 = 0; _i394 < _map393.Count; ++_i394)
{
string _key395;
SquareStatus _val396;
_key395 = await iprot.ReadStringAsync(cancellationToken);
_val396 = new SquareStatus();
await _val396.ReadAsync(iprot, cancellationToken);
SquareStatuses[_key395] = _val396;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
TMap _map397 = await iprot.ReadMapBeginAsync(cancellationToken);
MyMemberships = new Dictionary <string, SquareMember>(_map397.Count);
for (int _i398 = 0; _i398 < _map397.Count; ++_i398)
{
string _key399;
SquareMember _val400;
_key399 = await iprot.ReadStringAsync(cancellationToken);
_val400 = new SquareMember();
await _val400.ReadAsync(iprot, cancellationToken);
MyMemberships[_key399] = _val400;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.String)
{
ContinuationToken = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.Map)
{
{
TMap _map401 = await iprot.ReadMapBeginAsync(cancellationToken);
NoteStatuses = new Dictionary <string, NoteStatus>(_map401.Count);
for (int _i402 = 0; _i402 < _map401.Count; ++_i402)
{
string _key403;
NoteStatus _val404;
_key403 = await iprot.ReadStringAsync(cancellationToken);
_val404 = new NoteStatus();
await _val404.ReadAsync(iprot, cancellationToken);
NoteStatuses[_key403] = _val404;
}
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 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.Map)
{
{
TMap _map69 = await iprot.ReadMapBeginAsync(cancellationToken);
Hls = new Dictionary <string, string>(_map69.Count);
for (int _i70 = 0; _i70 < _map69.Count; ++_i70)
{
string _key71;
string _val72;
_key71 = await iprot.ReadStringAsync(cancellationToken);
_val72 = await iprot.ReadStringAsync(cancellationToken);
Hls[_key71] = _val72;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
TMap _map73 = await iprot.ReadMapBeginAsync(cancellationToken);
SmoothStreaming = new Dictionary <string, string>(_map73.Count);
for (int _i74 = 0; _i74 < _map73.Count; ++_i74)
{
string _key75;
string _val76;
_key75 = await iprot.ReadStringAsync(cancellationToken);
_val76 = await iprot.ReadStringAsync(cancellationToken);
SmoothStreaming[_key75] = _val76;
}
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 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.String)
{
Row = await iprot.ReadBinaryAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
Columns = new Dictionary <byte[], TCell>();
TMap _map4 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i5 = 0; _i5 < _map4.Count; ++_i5)
{
byte[] _key6;
TCell _val7;
_key6 = await iprot.ReadBinaryAsync(cancellationToken);
_val7 = new TCell();
await _val7.ReadAsync(iprot, cancellationToken);
Columns[_key6] = _val7;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.List)
{
{
SortedColumns = new List <TColumn>();
TList _list8 = await iprot.ReadListBeginAsync(cancellationToken);
for (int _i9 = 0; _i9 < _list8.Count; ++_i9)
{
TColumn _elem10;
_elem10 = new TColumn();
await _elem10.ReadAsync(iprot, cancellationToken);
SortedColumns.Add(_elem10);
}
await iprot.ReadListEndAsync(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 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.I32)
{
Code = (ChannelErrorCode)await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.String)
{
Reason = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
TMap _map527 = await iprot.ReadMapBeginAsync(cancellationToken);
ParameterMap = new Dictionary <string, string>(_map527.Count);
for (int _i528 = 0; _i528 < _map527.Count; ++_i528)
{
string _key529;
string _val530;
_key529 = await iprot.ReadStringAsync(cancellationToken);
_val530 = await iprot.ReadStringAsync(cancellationToken);
ParameterMap[_key529] = _val530;
}
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 async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_row = false;
bool isset_columnValues = 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)
{
{
ColumnValues = new List <TColumnValue>();
TList _list17 = await iprot.ReadListBeginAsync(cancellationToken);
for (int _i18 = 0; _i18 < _list17.Count; ++_i18)
{
TColumnValue _elem19;
_elem19 = new TColumnValue();
await _elem19.ReadAsync(iprot, cancellationToken);
ColumnValues.Add(_elem19);
}
await iprot.ReadListEndAsync(cancellationToken);
}
isset_columnValues = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.I64)
{
Timestamp = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.Map)
{
{
Attributes = new Dictionary <byte[], byte[]>();
TMap _map20 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i21 = 0; _i21 < _map20.Count; ++_i21)
{
byte[] _key22;
byte[] _val23;
_key22 = await iprot.ReadBinaryAsync(cancellationToken);
_val23 = await iprot.ReadBinaryAsync(cancellationToken);
Attributes[_key22] = _val23;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.I32)
{
Durability = (TDurability)await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
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_columnValues)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_qualifiers = 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.Map)
{
{
TMap _map0 = await iprot.ReadMapBeginAsync(cancellationToken);
Qualifiers = new Dictionary <string, TTypeQualifierValue>(_map0.Count);
for (int _i1 = 0; _i1 < _map0.Count; ++_i1)
{
string _key2;
TTypeQualifierValue _val3;
_key2 = await iprot.ReadStringAsync(cancellationToken);
_val3 = new TTypeQualifierValue();
await _val3.ReadAsync(iprot, cancellationToken);
Qualifiers[_key2] = _val3;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
isset_qualifiers = true;
}
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_qualifiers)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
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.I32)
{
Begin_in_both = await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.I32)
{
Newint = await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Byte)
{
Newbyte = await iprot.ReadByteAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.I16)
{
Newshort = await iprot.ReadI16Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.I64)
{
Newlong = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.Double)
{
Newdouble = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
if (field.Type == TType.Struct)
{
Newstruct = new global::ThriftTest.Bonk();
await Newstruct.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 8:
if (field.Type == TType.List)
{
{
TList _list74 = await iprot.ReadListBeginAsync(cancellationToken);
Newlist = new List <int>(_list74.Count);
for (int _i75 = 0; _i75 < _list74.Count; ++_i75)
{
int _elem76;
_elem76 = await iprot.ReadI32Async(cancellationToken);
Newlist.Add(_elem76);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 9:
if (field.Type == TType.Set)
{
{
TSet _set77 = await iprot.ReadSetBeginAsync(cancellationToken);
Newset = new THashSet <int>(_set77.Count);
for (int _i78 = 0; _i78 < _set77.Count; ++_i78)
{
int _elem79;
_elem79 = await iprot.ReadI32Async(cancellationToken);
Newset.Add(_elem79);
}
await iprot.ReadSetEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 10:
if (field.Type == TType.Map)
{
{
TMap _map80 = await iprot.ReadMapBeginAsync(cancellationToken);
Newmap = new Dictionary <int, int>(_map80.Count);
for (int _i81 = 0; _i81 < _map80.Count; ++_i81)
{
int _key82;
int _val83;
_key82 = await iprot.ReadI32Async(cancellationToken);
_val83 = await iprot.ReadI32Async(cancellationToken);
Newmap[_key82] = _val83;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 11:
if (field.Type == TType.String)
{
Newstring = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 12:
if (field.Type == TType.I32)
{
End_in_both = await iprot.ReadI32Async(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 async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_credentials = 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.Map)
{
{
TMap _map83 = await iprot.ReadMapBeginAsync(cancellationToken);
Credentials = new Dictionary <string, string>(_map83.Count);
for (int _i84 = 0; _i84 < _map83.Count; ++_i84)
{
string _key85;
string _val86;
_key85 = await iprot.ReadStringAsync(cancellationToken);
_val86 = await iprot.ReadStringAsync(cancellationToken);
Credentials[_key85] = _val86;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
isset_credentials = true;
}
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_credentials)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_sessionId = false;
bool isset_paths = false;
bool isset_dataTypes = false;
bool isset_encodings = false;
bool isset_compressors = 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.I64)
{
SessionId = await iprot.ReadI64Async(cancellationToken);
isset_sessionId = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.List)
{
{
TList _list150 = await iprot.ReadListBeginAsync(cancellationToken);
Paths = new List <string>(_list150.Count);
for (int _i151 = 0; _i151 < _list150.Count; ++_i151)
{
string _elem152;
_elem152 = await iprot.ReadStringAsync(cancellationToken);
Paths.Add(_elem152);
}
await iprot.ReadListEndAsync(cancellationToken);
}
isset_paths = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.List)
{
{
TList _list153 = await iprot.ReadListBeginAsync(cancellationToken);
DataTypes = new List <int>(_list153.Count);
for (int _i154 = 0; _i154 < _list153.Count; ++_i154)
{
int _elem155;
_elem155 = await iprot.ReadI32Async(cancellationToken);
DataTypes.Add(_elem155);
}
await iprot.ReadListEndAsync(cancellationToken);
}
isset_dataTypes = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.List)
{
{
TList _list156 = await iprot.ReadListBeginAsync(cancellationToken);
Encodings = new List <int>(_list156.Count);
for (int _i157 = 0; _i157 < _list156.Count; ++_i157)
{
int _elem158;
_elem158 = await iprot.ReadI32Async(cancellationToken);
Encodings.Add(_elem158);
}
await iprot.ReadListEndAsync(cancellationToken);
}
isset_encodings = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.List)
{
{
TList _list159 = await iprot.ReadListBeginAsync(cancellationToken);
Compressors = new List <int>(_list159.Count);
for (int _i160 = 0; _i160 < _list159.Count; ++_i160)
{
int _elem161;
_elem161 = await iprot.ReadI32Async(cancellationToken);
Compressors.Add(_elem161);
}
await iprot.ReadListEndAsync(cancellationToken);
}
isset_compressors = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.List)
{
{
TList _list162 = await iprot.ReadListBeginAsync(cancellationToken);
PropsList = new List <Dictionary <string, string> >(_list162.Count);
for (int _i163 = 0; _i163 < _list162.Count; ++_i163)
{
Dictionary <string, string> _elem164;
{
TMap _map165 = await iprot.ReadMapBeginAsync(cancellationToken);
_elem164 = new Dictionary <string, string>(_map165.Count);
for (int _i166 = 0; _i166 < _map165.Count; ++_i166)
{
string _key167;
string _val168;
_key167 = await iprot.ReadStringAsync(cancellationToken);
_val168 = await iprot.ReadStringAsync(cancellationToken);
_elem164[_key167] = _val168;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
PropsList.Add(_elem164);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
if (field.Type == TType.List)
{
{
TList _list169 = await iprot.ReadListBeginAsync(cancellationToken);
TagsList = new List <Dictionary <string, string> >(_list169.Count);
for (int _i170 = 0; _i170 < _list169.Count; ++_i170)
{
Dictionary <string, string> _elem171;
{
TMap _map172 = await iprot.ReadMapBeginAsync(cancellationToken);
_elem171 = new Dictionary <string, string>(_map172.Count);
for (int _i173 = 0; _i173 < _map172.Count; ++_i173)
{
string _key174;
string _val175;
_key174 = await iprot.ReadStringAsync(cancellationToken);
_val175 = await iprot.ReadStringAsync(cancellationToken);
_elem171[_key174] = _val175;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
TagsList.Add(_elem171);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 8:
if (field.Type == TType.List)
{
{
TList _list176 = await iprot.ReadListBeginAsync(cancellationToken);
AttributesList = new List <Dictionary <string, string> >(_list176.Count);
for (int _i177 = 0; _i177 < _list176.Count; ++_i177)
{
Dictionary <string, string> _elem178;
{
TMap _map179 = await iprot.ReadMapBeginAsync(cancellationToken);
_elem178 = new Dictionary <string, string>(_map179.Count);
for (int _i180 = 0; _i180 < _map179.Count; ++_i180)
{
string _key181;
string _val182;
_key181 = await iprot.ReadStringAsync(cancellationToken);
_val182 = await iprot.ReadStringAsync(cancellationToken);
_elem178[_key181] = _val182;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
AttributesList.Add(_elem178);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 9:
if (field.Type == TType.List)
{
{
TList _list183 = await iprot.ReadListBeginAsync(cancellationToken);
MeasurementAliasList = new List <string>(_list183.Count);
for (int _i184 = 0; _i184 < _list183.Count; ++_i184)
{
string _elem185;
_elem185 = await iprot.ReadStringAsync(cancellationToken);
MeasurementAliasList.Add(_elem185);
}
await iprot.ReadListEndAsync(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_sessionId)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_paths)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_dataTypes)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_encodings)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_compressors)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
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)
{
{
SquareChats = new List <SquareChat>();
TList _list320 = await iprot.ReadListBeginAsync(cancellationToken);
for (int _i321 = 0; _i321 < _list320.Count; ++_i321)
{
SquareChat _elem322;
_elem322 = new SquareChat();
await _elem322.ReadAsync(iprot, cancellationToken);
SquareChats.Add(_elem322);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.String)
{
ContinuationToken = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.I32)
{
TotalSquareChatCount = await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Map)
{
{
SquareChatStatuses = new Dictionary <string, SquareChatStatus>();
TMap _map323 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i324 = 0; _i324 < _map323.Count; ++_i324)
{
string _key325;
SquareChatStatus _val326;
_key325 = await iprot.ReadStringAsync(cancellationToken);
_val326 = new SquareChatStatus();
await _val326.ReadAsync(iprot, cancellationToken);
SquareChatStatuses[_key325] = _val326;
}
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 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.Map)
{
{
TMap _map12 = await iprot.ReadMapBeginAsync(cancellationToken);
SnapshotBytes = new Dictionary <int, byte[]>(_map12.Count);
for (int _i13 = 0; _i13 < _map12.Count; ++_i13)
{
int _key14;
byte[] _val15;
_key14 = await iprot.ReadI32Async(cancellationToken);
_val15 = await iprot.ReadBinaryAsync(cancellationToken);
SnapshotBytes[_key14] = _val15;
}
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 static async Task SkipAsync(TProtocol protocol, TType type, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
protocol.IncrementRecursionDepth();
try
{
switch (type)
{
case TType.Bool:
await protocol.ReadBoolAsync(cancellationToken);
break;
case TType.Byte:
await protocol.ReadByteAsync(cancellationToken);
break;
case TType.I16:
await protocol.ReadI16Async(cancellationToken);
break;
case TType.I32:
await protocol.ReadI32Async(cancellationToken);
break;
case TType.I64:
await protocol.ReadI64Async(cancellationToken);
break;
case TType.Double:
await protocol.ReadDoubleAsync(cancellationToken);
break;
case TType.String:
// Don't try to decode the string, just skip it.
await protocol.ReadBinaryAsync(cancellationToken);
break;
case TType.Struct:
await protocol.ReadStructBeginAsync(cancellationToken);
while (true)
{
var field = await protocol.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
await SkipAsync(protocol, field.Type, cancellationToken);
await protocol.ReadFieldEndAsync(cancellationToken);
}
await protocol.ReadStructEndAsync(cancellationToken);
break;
case TType.Map:
var map = await protocol.ReadMapBeginAsync(cancellationToken);
for (var i = 0; i < map.Count; i++)
{
await SkipAsync(protocol, map.KeyType, cancellationToken);
await SkipAsync(protocol, map.ValueType, cancellationToken);
}
await protocol.ReadMapEndAsync(cancellationToken);
break;
case TType.Set:
var set = await protocol.ReadSetBeginAsync(cancellationToken);
for (var i = 0; i < set.Count; i++)
{
await SkipAsync(protocol, set.ElementType, cancellationToken);
}
await protocol.ReadSetEndAsync(cancellationToken);
break;
case TType.List:
var list = await protocol.ReadListBeginAsync(cancellationToken);
for (var i = 0; i < list.Count; i++)
{
await SkipAsync(protocol, list.ElementType, cancellationToken);
}
await protocol.ReadListEndAsync(cancellationToken);
break;
default:
throw new TProtocolException(TProtocolException.INVALID_DATA, "Unknown data type " + type.ToString("d"));
}
}
finally
{
protocol.DecrementRecursionDepth();
}
}
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.Map)
{
{
TMap _map0 = await iprot.ReadMapBeginAsync(cancellationToken);
Input = new Dictionary <string, string>(_map0.Count);
for (int _i1 = 0; _i1 < _map0.Count; ++_i1)
{
string _key2;
string _val3;
_key2 = await iprot.ReadStringAsync(cancellationToken);
_val3 = await iprot.ReadStringAsync(cancellationToken);
Input[_key2] = _val3;
}
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 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.String)
{
OrderId = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.String)
{
ConfirmUrl = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
Extras = new Dictionary <string, string>();
TMap _map188 = await iprot.ReadMapBeginAsync(cancellationToken);
for (int _i189 = 0; _i189 < _map188.Count; ++_i189)
{
string _key190;
string _val191;
_key190 = await iprot.ReadStringAsync(cancellationToken);
_val191 = await iprot.ReadStringAsync(cancellationToken);
Extras[_key190] = _val191;
}
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 static async Task SkipAsync(TProtocol prot, TType type, CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
await Task.FromCanceled(cancellationToken);
}
prot.IncrementRecursionDepth();
try
{
switch (type)
{
case TType.Bool:
await prot.ReadBoolAsync(cancellationToken);
break;
case TType.Byte:
await prot.ReadByteAsync(cancellationToken);
break;
case TType.I16:
await prot.ReadI16Async(cancellationToken);
break;
case TType.I32:
await prot.ReadI32Async(cancellationToken);
break;
case TType.I64:
await prot.ReadI64Async(cancellationToken);
break;
case TType.Double:
await prot.ReadDoubleAsync(cancellationToken);
break;
case TType.String:
// Don't try to decode the string, just skip it.
await prot.ReadBinaryAsync(cancellationToken);
break;
case TType.Struct:
await prot.ReadStructBeginAsync(cancellationToken);
while (true)
{
var field = await prot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
await SkipAsync(prot, field.Type, cancellationToken);
await prot.ReadFieldEndAsync(cancellationToken);
}
await prot.ReadStructEndAsync(cancellationToken);
break;
case TType.Map:
var map = await prot.ReadMapBeginAsync(cancellationToken);
for (var i = 0; i < map.Count; i++)
{
await SkipAsync(prot, map.KeyType, cancellationToken);
await SkipAsync(prot, map.ValueType, cancellationToken);
}
await prot.ReadMapEndAsync(cancellationToken);
break;
case TType.Set:
var set = await prot.ReadSetBeginAsync(cancellationToken);
for (var i = 0; i < set.Count; i++)
{
await SkipAsync(prot, set.ElementType, cancellationToken);
}
await prot.ReadSetEndAsync(cancellationToken);
break;
case TType.List:
var list = await prot.ReadListBeginAsync(cancellationToken);
for (var i = 0; i < list.Count; i++)
{
await SkipAsync(prot, list.ElementType, cancellationToken);
}
await prot.ReadListEndAsync(cancellationToken);
break;
default:
throw new TProtocolException(TProtocolException.INVALID_DATA, "Unknown data type " + type.ToString("d"));
}
}
finally
{
prot.DecrementRecursionDepth();
}
}
