public SpecFlags DeepCopy()
{
var tmp50 = new SpecFlags();
if (__isset.limit)
{
tmp50.Limit = this.Limit;
}
tmp50.__isset.limit = this.__isset.limit;
if (__isset.offset)
{
tmp50.Offset = this.Offset;
}
tmp50.__isset.offset = this.__isset.offset;
if (__isset.max_versions)
{
tmp50.Max_versions = this.Max_versions;
}
tmp50.__isset.max_versions = this.__isset.max_versions;
if (__isset.max_buffer)
{
tmp50.Max_buffer = this.Max_buffer;
}
tmp50.__isset.max_buffer = this.__isset.max_buffer;
if (__isset.options)
{
tmp50.Options = this.Options;
}
tmp50.__isset.options = this.__isset.options;
return(tmp50);
}
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.List)
{
{
TList _list188 = await iprot.ReadListBeginAsync(cancellationToken);
Range_begin = new List <byte[]>(_list188.Count);
for (int _i189 = 0; _i189 < _list188.Count; ++_i189)
{
byte[] _elem190;
_elem190 = await iprot.ReadBinaryAsync(cancellationToken);
Range_begin.Add(_elem190);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.List)
{
{
TList _list191 = await iprot.ReadListBeginAsync(cancellationToken);
Range_end = new List <byte[]>(_list191.Count);
for (int _i192 = 0; _i192 < _list191.Count; ++_i192)
{
byte[] _elem193;
_elem193 = await iprot.ReadBinaryAsync(cancellationToken);
Range_end.Add(_elem193);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.List)
{
{
TList _list194 = await iprot.ReadListBeginAsync(cancellationToken);
Offset_key = new List <byte[]>(_list194.Count);
for (int _i195 = 0; _i195 < _list194.Count; ++_i195)
{
byte[] _elem196;
_elem196 = await iprot.ReadBinaryAsync(cancellationToken);
Offset_key.Add(_elem196);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.I64)
{
Offset_rev = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.List)
{
{
TList _list197 = await iprot.ReadListBeginAsync(cancellationToken);
Key_intervals = new List <SpecKeyInterval>(_list197.Count);
for (int _i198 = 0; _i198 < _list197.Count; ++_i198)
{
SpecKeyInterval _elem199;
_elem199 = new SpecKeyInterval();
await _elem199.ReadAsync(iprot, cancellationToken);
Key_intervals.Add(_elem199);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.List)
{
{
TList _list200 = await iprot.ReadListBeginAsync(cancellationToken);
Values = new List <SpecValueSerial>(_list200.Count);
for (int _i201 = 0; _i201 < _list200.Count; ++_i201)
{
SpecValueSerial _elem202;
_elem202 = new SpecValueSerial();
await _elem202.ReadAsync(iprot, cancellationToken);
Values.Add(_elem202);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
if (field.Type == TType.Struct)
{
Ts_start = new SpecTimestamp();
await Ts_start.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 8:
if (field.Type == TType.Struct)
{
Ts_finish = new SpecTimestamp();
await Ts_finish.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 9:
if (field.Type == TType.Struct)
{
Flags = new SpecFlags();
await Flags.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 10:
if (field.Type == TType.I32)
{
Options = (SpecIntervalOptions)await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 11:
if (field.Type == TType.Struct)
{
Updating = new SpecIntervalUpdateSerial();
await Updating.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public 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.List)
{
{
TList _list222 = await iprot.ReadListBeginAsync(cancellationToken);
Columns = new List <SpecColumn>(_list222.Count);
for (int _i223 = 0; _i223 < _list222.Count; ++_i223)
{
SpecColumn _elem224;
_elem224 = new SpecColumn();
await _elem224.ReadAsync(iprot, cancellationToken);
Columns.Add(_elem224);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.List)
{
{
TList _list225 = await iprot.ReadListBeginAsync(cancellationToken);
Columns_serial = new List <SpecColumnSerial>(_list225.Count);
for (int _i226 = 0; _i226 < _list225.Count; ++_i226)
{
SpecColumnSerial _elem227;
_elem227 = new SpecColumnSerial();
await _elem227.ReadAsync(iprot, cancellationToken);
Columns_serial.Add(_elem227);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Struct)
{
Flags = new SpecFlags();
await Flags.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
}
finally
{
iprot.DecrementRecursionDepth();
}
}
