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.Double)
{
Longitude = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Double)
{
Latitude = await iprot.ReadDoubleAsync(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_samplingRate = 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.Double)
{
SamplingRate = await iprot.ReadDoubleAsync(cancellationToken);
isset_samplingRate = 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_samplingRate)
{
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)
{
Int_val = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Double)
{
Real_val = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.String)
{
Str_val = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.List)
{
{
TList _list0 = await iprot.ReadListBeginAsync(cancellationToken);
Arr_val = new List <TDatum>(_list0.Count);
for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
{
TDatum _elem2;
_elem2 = new TDatum();
await _elem2.ReadAsync(iprot, cancellationToken);
Arr_val.Add(_elem2);
}
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 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)
{
Field_id = await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.I64)
{
V_int64 = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Double)
{
V_double = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.String)
{
V_bytes = await iprot.ReadBinaryAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.List)
{
{
TList _list244 = await iprot.ReadListBeginAsync(cancellationToken);
V_key = new List <byte[]>(_list244.Count);
for (int _i245 = 0; _i245 < _list244.Count; ++_i245)
{
byte[] _elem246;
_elem246 = await iprot.ReadBinaryAsync(cancellationToken);
V_key.Add(_elem246);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.List)
{
{
TList _list247 = await iprot.ReadListBeginAsync(cancellationToken);
V_li = new List <long>(_list247.Count);
for (int _i248 = 0; _i248 < _list247.Count; ++_i248)
{
long _elem249;
_elem249 = await iprot.ReadI64Async(cancellationToken);
V_li.Add(_elem249);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
if (field.Type == TType.List)
{
{
TList _list250 = await iprot.ReadListBeginAsync(cancellationToken);
V_lb = new List <byte[]>(_list250.Count);
for (int _i251 = 0; _i251 < _list250.Count; ++_i251)
{
byte[] _elem252;
_elem252 = await iprot.ReadBinaryAsync(cancellationToken);
V_lb.Add(_elem252);
}
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 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 Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_operationId = false;
bool isset_operationType = false;
bool isset_hasResultSet = 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)
{
OperationId = new THandleIdentifier();
await OperationId.ReadAsync(iprot, cancellationToken);
isset_operationId = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.I32)
{
OperationType = (TOperationType)await iprot.ReadI32Async(cancellationToken);
isset_operationType = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Bool)
{
HasResultSet = await iprot.ReadBoolAsync(cancellationToken);
isset_hasResultSet = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Double)
{
ModifiedRowCount = await iprot.ReadDoubleAsync(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_operationId)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_operationType)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_hasResultSet)
{
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)
{
Bigint = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.I32)
{
Integer = await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.I16)
{
Smallint = await iprot.ReadI16Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Double)
{
Real = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.Bool)
{
Bval = await iprot.ReadBoolAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.String)
{
Text = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
if (field.Type == TType.Bool)
{
Isnull = await iprot.ReadBoolAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 8:
if (field.Type == TType.String)
{
Blob = await iprot.ReadBinaryAsync(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 1:
if (field.Type == TType.String)
{
Name = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.String)
{
Appearance = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Double)
{
AtomicMass = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Double)
{
Boil = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.String)
{
Category = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.Double)
{
Density = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
if (field.Type == TType.String)
{
DiscoveredBy = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 8:
if (field.Type == TType.Double)
{
Melt = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 9:
if (field.Type == TType.Double)
{
MolarHeat = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 10:
if (field.Type == TType.String)
{
NamedBy = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 11:
if (field.Type == TType.I16)
{
Number = await iprot.ReadI16Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 12:
if (field.Type == TType.I16)
{
Period = await iprot.ReadI16Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 13:
if (field.Type == TType.String)
{
Phase = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 14:
if (field.Type == TType.String)
{
Source = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 15:
if (field.Type == TType.String)
{
Summary = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 16:
if (field.Type == TType.String)
{
Symbol = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 17:
if (field.Type == TType.List)
{
{
TList _list1 = await iprot.ReadListBeginAsync(cancellationToken);
IonizationEnergies = new List <double>(_list1.Count);
for (int _i2 = 0; _i2 < _list1.Count; ++_i2)
{
double _elem3;
_elem3 = await iprot.ReadDoubleAsync(cancellationToken);
IonizationEnergies.Add(_elem3);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 18:
if (field.Type == TType.Double)
{
ElectronAffinity = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 19:
if (field.Type == TType.String)
{
ElectronConfiguration = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 20:
if (field.Type == TType.Double)
{
ElectronegativityPaulimg = await iprot.ReadDoubleAsync(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 _list8 = await iprot.ReadListBeginAsync(cancellationToken);
Int_col = new List <long>(_list8.Count);
for (int _i9 = 0; _i9 < _list8.Count; ++_i9)
{
long _elem10;
_elem10 = await iprot.ReadI64Async(cancellationToken);
Int_col.Add(_elem10);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.List)
{
{
TList _list11 = await iprot.ReadListBeginAsync(cancellationToken);
Real_col = new List <double>(_list11.Count);
for (int _i12 = 0; _i12 < _list11.Count; ++_i12)
{
double _elem13;
_elem13 = await iprot.ReadDoubleAsync(cancellationToken);
Real_col.Add(_elem13);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.List)
{
{
TList _list14 = await iprot.ReadListBeginAsync(cancellationToken);
Str_col = new List <string>(_list14.Count);
for (int _i15 = 0; _i15 < _list14.Count; ++_i15)
{
string _elem16;
_elem16 = await iprot.ReadStringAsync(cancellationToken);
Str_col.Add(_elem16);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.List)
{
{
TList _list17 = await iprot.ReadListBeginAsync(cancellationToken);
Arr_col = new List <TColumn>(_list17.Count);
for (int _i18 = 0; _i18 < _list17.Count; ++_i18)
{
TColumn _elem19;
_elem19 = new TColumn();
await _elem19.ReadAsync(iprot, cancellationToken);
Arr_col.Add(_elem19);
}
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 global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_key = false;
bool isset_vType = 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)
{
Key = await iprot.ReadStringAsync(cancellationToken);
isset_key = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.I32)
{
VType = (global::Jaeger.Thrift.TagType) await iprot.ReadI32Async(cancellationToken);
isset_vType = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.String)
{
VStr = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Double)
{
VDouble = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.Bool)
{
VBool = await iprot.ReadBoolAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.I64)
{
VLong = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
if (field.Type == TType.String)
{
VBinary = await iprot.ReadBinaryAsync(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_key)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_vType)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
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();
}
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_idTrack = 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.I16)
{
IdTrack = await iprot.ReadI16Async(cancellationToken);
isset_idTrack = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.I16)
{
TrackNumber = await iprot.ReadI16Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Double)
{
DurationSeconds = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.String)
{
StoragePath = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.String)
{
Title = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.I32)
{
Gender = (MusicGender)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);
if (!isset_idTrack)
{
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.String)
{
DeviceId = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.String)
{
UserId = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.String)
{
Name = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
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.Double)
{
Scale = await iprot.ReadDoubleAsync(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_headerNames = false;
bool isset_rows = false;
bool isset_progressedPercentage = false;
bool isset_status = false;
bool isset_footerSummary = false;
bool isset_startTime = 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.List)
{
{
TList _list90 = await iprot.ReadListBeginAsync(cancellationToken);
HeaderNames = new List <string>(_list90.Count);
for (int _i91 = 0; _i91 < _list90.Count; ++_i91)
{
string _elem92;
_elem92 = await iprot.ReadStringAsync(cancellationToken);
HeaderNames.Add(_elem92);
}
await iprot.ReadListEndAsync(cancellationToken);
}
isset_headerNames = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.List)
{
{
TList _list93 = await iprot.ReadListBeginAsync(cancellationToken);
Rows = new List <List <string> >(_list93.Count);
for (int _i94 = 0; _i94 < _list93.Count; ++_i94)
{
List <string> _elem95;
{
TList _list96 = await iprot.ReadListBeginAsync(cancellationToken);
_elem95 = new List <string>(_list96.Count);
for (int _i97 = 0; _i97 < _list96.Count; ++_i97)
{
string _elem98;
_elem98 = await iprot.ReadStringAsync(cancellationToken);
_elem95.Add(_elem98);
}
await iprot.ReadListEndAsync(cancellationToken);
}
Rows.Add(_elem95);
}
await iprot.ReadListEndAsync(cancellationToken);
}
isset_rows = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Double)
{
ProgressedPercentage = await iprot.ReadDoubleAsync(cancellationToken);
isset_progressedPercentage = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.I32)
{
Status = (TJobExecutionStatus)await iprot.ReadI32Async(cancellationToken);
isset_status = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.String)
{
FooterSummary = await iprot.ReadStringAsync(cancellationToken);
isset_footerSummary = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.I64)
{
StartTime = await iprot.ReadI64Async(cancellationToken);
isset_startTime = 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_headerNames)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_rows)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_progressedPercentage)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_status)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_footerSummary)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_startTime)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_maxOperations = false;
bool isset_creditsPerSecond = false;
bool isset_maxBalance = 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.I32)
{
MaxOperations = await iprot.ReadI32Async(cancellationToken);
isset_maxOperations = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Double)
{
CreditsPerSecond = await iprot.ReadDoubleAsync(cancellationToken);
isset_creditsPerSecond = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Double)
{
MaxBalance = await iprot.ReadDoubleAsync(cancellationToken);
isset_maxBalance = 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_maxOperations)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_creditsPerSecond)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_maxBalance)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_values = false;
bool isset_nulls = 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.List)
{
{
TList _list47 = await iprot.ReadListBeginAsync(cancellationToken);
Values = new List <double>(_list47.Count);
for (int _i48 = 0; _i48 < _list47.Count; ++_i48)
{
double _elem49;
_elem49 = await iprot.ReadDoubleAsync(cancellationToken);
Values.Add(_elem49);
}
await iprot.ReadListEndAsync(cancellationToken);
}
isset_values = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.String)
{
Nulls = await iprot.ReadBinaryAsync(cancellationToken);
isset_nulls = 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_values)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_nulls)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_defaultSamplingProbability = false;
bool isset_defaultLowerBoundTracesPerSecond = false;
bool isset_perOperationStrategies = 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.Double)
{
DefaultSamplingProbability = await iprot.ReadDoubleAsync(cancellationToken);
isset_defaultSamplingProbability = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Double)
{
DefaultLowerBoundTracesPerSecond = await iprot.ReadDoubleAsync(cancellationToken);
isset_defaultLowerBoundTracesPerSecond = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.List)
{
{
TList _list7 = await iprot.ReadListBeginAsync(cancellationToken);
PerOperationStrategies = new List <global::Jaeger.Thrift.Agent.OperationSamplingStrategy>(_list7.Count);
for (int _i8 = 0; _i8 < _list7.Count; ++_i8)
{
global::Jaeger.Thrift.Agent.OperationSamplingStrategy _elem9;
_elem9 = new global::Jaeger.Thrift.Agent.OperationSamplingStrategy();
await _elem9.ReadAsync(iprot, cancellationToken);
PerOperationStrategies.Add(_elem9);
}
await iprot.ReadListEndAsync(cancellationToken);
}
isset_perOperationStrategies = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Double)
{
DefaultUpperBoundTracesPerSecond = await iprot.ReadDoubleAsync(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_defaultSamplingProbability)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_defaultLowerBoundTracesPerSecond)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_perOperationStrategies)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
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.I32)
{
Type = (TExpressionRangeType)await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.I32)
{
Col_id = await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.I32)
{
Table_id = await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Bool)
{
Has_nulls = await iprot.ReadBoolAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.I64)
{
Int_min = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.I64)
{
Int_max = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
if (field.Type == TType.I64)
{
Bucket = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 8:
if (field.Type == TType.Double)
{
Fp_min = await iprot.ReadDoubleAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 9:
if (field.Type == TType.Double)
{
Fp_max = await iprot.ReadDoubleAsync(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();
}
}
