public SpecIntervalUpdateSerial DeepCopy()
{
var tmp88 = new SpecIntervalUpdateSerial();
if (__isset.ts)
{
tmp88.Ts = this.Ts;
}
tmp88.__isset.ts = this.__isset.ts;
if ((V != null) && __isset.v)
{
tmp88.V = this.V.DeepCopy();
}
tmp88.__isset.v = this.__isset.v;
if (__isset.encoder)
{
tmp88.Encoder = this.Encoder;
}
tmp88.__isset.encoder = this.__isset.encoder;
return(tmp88);
}
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();
}
}
