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(); } }