public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
ProductID = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
TransactionID = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I64)
{
PurchaseDate = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I64)
{
Quantity = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I64)
{
IsValid = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public async Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
{
oprot.IncrementRecursionDepth();
try
{
var struc = new TStruct("PaidCallMetadataResult");
await oprot.WriteStructBeginAsync(struc, cancellationToken);
var field = new TField();
if (CurrencyExchangeRates != null && __isset.currencyExchangeRates)
{
field.Name = "currencyExchangeRates";
field.Type = TType.List;
field.ID = 1;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
{
await oprot.WriteListBeginAsync(new TList(TType.Struct, CurrencyExchangeRates.Count), cancellationToken);
foreach (PaidCallCurrencyExchangeRate _iter29 in CurrencyExchangeRates)
{
await _iter29.WriteAsync(oprot, cancellationToken);
}
await oprot.WriteListEndAsync(cancellationToken);
}
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (RecommendedCountryCodes != null && __isset.recommendedCountryCodes)
{
field.Name = "recommendedCountryCodes";
field.Type = TType.List;
field.ID = 2;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
{
await oprot.WriteListBeginAsync(new TList(TType.String, RecommendedCountryCodes.Count), cancellationToken);
foreach (string _iter30 in RecommendedCountryCodes)
{
await oprot.WriteStringAsync(_iter30, cancellationToken);
}
await oprot.WriteListEndAsync(cancellationToken);
}
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (AdCountries != null && __isset.adCountries)
{
field.Name = "adCountries";
field.Type = TType.List;
field.ID = 3;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
{
await oprot.WriteListBeginAsync(new TList(TType.Struct, AdCountries.Count), cancellationToken);
foreach (PaidCallAdCountry _iter31 in AdCountries)
{
await _iter31.WriteAsync(oprot, cancellationToken);
}
await oprot.WriteListEndAsync(cancellationToken);
}
await oprot.WriteFieldEndAsync(cancellationToken);
}
await oprot.WriteFieldStopAsync(cancellationToken);
await oprot.WriteStructEndAsync(cancellationToken);
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("CoinHistoryCondition");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (__isset.start)
{
field.Name = "start";
field.Type = TType.I64;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteI64(Start);
oprot.WriteFieldEnd();
}
if (__isset.size)
{
field.Name = "size";
field.Type = TType.I32;
field.ID = 2;
oprot.WriteFieldBegin(field);
oprot.WriteI32(Size);
oprot.WriteFieldEnd();
}
if (Language != null && __isset.language)
{
field.Name = "language";
field.Type = TType.String;
field.ID = 3;
oprot.WriteFieldBegin(field);
oprot.WriteString(Language);
oprot.WriteFieldEnd();
}
if (Eddt != null && __isset.eddt)
{
field.Name = "eddt";
field.Type = TType.String;
field.ID = 4;
oprot.WriteFieldBegin(field);
oprot.WriteString(Eddt);
oprot.WriteFieldEnd();
}
if (__isset.appStoreCode)
{
field.Name = "appStoreCode";
field.Type = TType.I32;
field.ID = 5;
oprot.WriteFieldBegin(field);
oprot.WriteI32((int)AppStoreCode);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public async Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
{
oprot.IncrementRecursionDepth();
try
{
var struc = new TStruct("Group");
await oprot.WriteStructBeginAsync(struc, cancellationToken);
var field = new TField();
if (Id != null && __isset.id)
{
field.Name = "id";
field.Type = TType.String;
field.ID = 1;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await oprot.WriteStringAsync(Id, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (__isset.createdTime)
{
field.Name = "createdTime";
field.Type = TType.I64;
field.ID = 2;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await oprot.WriteI64Async(CreatedTime, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (Name != null && __isset.name)
{
field.Name = "name";
field.Type = TType.String;
field.ID = 10;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await oprot.WriteStringAsync(Name, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (PictureStatus != null && __isset.pictureStatus)
{
field.Name = "pictureStatus";
field.Type = TType.String;
field.ID = 11;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await oprot.WriteStringAsync(PictureStatus, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (__isset.preventedJoinByTicket)
{
field.Name = "preventedJoinByTicket";
field.Type = TType.Bool;
field.ID = 12;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await oprot.WriteBoolAsync(PreventedJoinByTicket, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (GroupPreference != null && __isset.groupPreference)
{
field.Name = "groupPreference";
field.Type = TType.Struct;
field.ID = 13;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await GroupPreference.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (Members != null && __isset.members)
{
field.Name = "members";
field.Type = TType.List;
field.ID = 20;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
{
await oprot.WriteListBeginAsync(new TList(TType.Struct, Members.Count), cancellationToken);
foreach (Contact _iter147 in Members)
{
await _iter147.WriteAsync(oprot, cancellationToken);
}
await oprot.WriteListEndAsync(cancellationToken);
}
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (Creator != null && __isset.creator)
{
field.Name = "creator";
field.Type = TType.Struct;
field.ID = 21;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await Creator.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (Invitee != null && __isset.invitee)
{
field.Name = "invitee";
field.Type = TType.List;
field.ID = 22;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
{
await oprot.WriteListBeginAsync(new TList(TType.Struct, Invitee.Count), cancellationToken);
foreach (Contact _iter148 in Invitee)
{
await _iter148.WriteAsync(oprot, cancellationToken);
}
await oprot.WriteListEndAsync(cancellationToken);
}
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (__isset.notificationDisabled)
{
field.Name = "notificationDisabled";
field.Type = TType.Bool;
field.ID = 31;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await oprot.WriteBoolAsync(NotificationDisabled, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
await oprot.WriteFieldStopAsync(cancellationToken);
await oprot.WriteStructEndAsync(cancellationToken);
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public async Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
{
oprot.IncrementRecursionDepth();
try
{
var struc = new TStruct("PerOperationSamplingStrategies");
await oprot.WriteStructBeginAsync(struc, cancellationToken);
var field = new TField();
field.Name = "defaultSamplingProbability";
field.Type = TType.Double;
field.ID = 1;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await oprot.WriteDoubleAsync(DefaultSamplingProbability, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
field.Name = "defaultLowerBoundTracesPerSecond";
field.Type = TType.Double;
field.ID = 2;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await oprot.WriteDoubleAsync(DefaultLowerBoundTracesPerSecond, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
field.Name = "perOperationStrategies";
field.Type = TType.List;
field.ID = 3;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
{
await oprot.WriteListBeginAsync(new TList(TType.Struct, PerOperationStrategies.Count), cancellationToken);
foreach (OperationSamplingStrategy _iter3 in PerOperationStrategies)
{
await _iter3.WriteAsync(oprot, cancellationToken);
}
await oprot.WriteListEndAsync(cancellationToken);
}
await oprot.WriteFieldEndAsync(cancellationToken);
if (__isset.defaultUpperBoundTracesPerSecond)
{
field.Name = "defaultUpperBoundTracesPerSecond";
field.Type = TType.Double;
field.ID = 4;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await oprot.WriteDoubleAsync(DefaultUpperBoundTracesPerSecond, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
await oprot.WriteFieldStopAsync(cancellationToken);
await oprot.WriteStructEndAsync(cancellationToken);
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.List)
{
{
SettingCategories = new List <Ruyi.SDK.CommonType.SettingCategory>();
TList _list18 = iprot.ReadListBegin();
for (int _i19 = 0; _i19 < _list18.Count; ++_i19)
{
Ruyi.SDK.CommonType.SettingCategory _elem20;
_elem20 = new Ruyi.SDK.CommonType.SettingCategory();
_elem20.Read(iprot);
SettingCategories.Add(_elem20);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
SettingItems = new List <Ruyi.SDK.CommonType.SettingItem>();
TList _list21 = iprot.ReadListBegin();
for (int _i22 = 0; _i22 < _list21.Count; ++_i22)
{
Ruyi.SDK.CommonType.SettingItem _elem23;
_elem23 = new Ruyi.SDK.CommonType.SettingItem();
_elem23.Read(iprot);
SettingItems.Add(_elem23);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("TDDIArgumentReasoning");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (Gid != null && __isset.Gid)
{
field.Name = "Gid";
field.Type = TType.String;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteString(Gid);
oprot.WriteFieldEnd();
}
if (__isset.IsCitation)
{
field.Name = "IsCitation";
field.Type = TType.Bool;
field.ID = 2;
oprot.WriteFieldBegin(field);
oprot.WriteBool(IsCitation);
oprot.WriteFieldEnd();
}
if (__isset.IsAbstract)
{
field.Name = "IsAbstract";
field.Type = TType.Bool;
field.ID = 3;
oprot.WriteFieldBegin(field);
oprot.WriteBool(IsAbstract);
oprot.WriteFieldEnd();
}
if (CitedElement != null && __isset.CitedElement)
{
field.Name = "CitedElement";
field.Type = TType.Struct;
field.ID = 4;
oprot.WriteFieldBegin(field);
CitedElement.Write(oprot);
oprot.WriteFieldEnd();
}
if (AbstractForm != null && __isset.AbstractForm)
{
field.Name = "AbstractForm";
field.Type = TType.Struct;
field.ID = 5;
oprot.WriteFieldBegin(field);
AbstractForm.Write(oprot);
oprot.WriteFieldEnd();
}
if (Name != null && __isset.Name)
{
field.Name = "Name";
field.Type = TType.Struct;
field.ID = 6;
oprot.WriteFieldBegin(field);
Name.Write(oprot);
oprot.WriteFieldEnd();
}
if (Description != null && __isset.Description)
{
field.Name = "Description";
field.Type = TType.Struct;
field.ID = 7;
oprot.WriteFieldBegin(field);
Description.Write(oprot);
oprot.WriteFieldEnd();
}
if (ImplementationConstraint != null && __isset.ImplementationConstraint)
{
field.Name = "ImplementationConstraint";
field.Type = TType.List;
field.ID = 8;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, ImplementationConstraint.Count));
foreach (TDDIImplementationConstraintRef _iter809 in ImplementationConstraint)
{
_iter809.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
if (Note != null && __isset.Note)
{
field.Name = "Note";
field.Type = TType.List;
field.ID = 9;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, Note.Count));
foreach (TDDINoteRef _iter810 in Note)
{
_iter810.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
if (TaggedValue != null && __isset.TaggedValue)
{
field.Name = "TaggedValue";
field.Type = TType.List;
field.ID = 10;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, TaggedValue.Count));
foreach (TDDITaggedValueRef _iter811 in TaggedValue)
{
_iter811.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
if (Structure != null && __isset.Structure)
{
field.Name = "Structure";
field.Type = TType.Struct;
field.ID = 11;
oprot.WriteFieldBegin(field);
Structure.Write(oprot);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
Token = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Code = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Sender = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
Receiver = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
Amount = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
Initiator = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
Transaction = new TransactionId();
Transaction.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.I64)
{
Time = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
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 _list16 = await iprot.ReadListBeginAsync(cancellationToken);
Historys = new List <PaidCallHistory>(_list16.Count);
for (int _i17 = 0; _i17 < _list16.Count; ++_i17)
{
PaidCallHistory _elem18;
_elem18 = new PaidCallHistory();
await _elem18.ReadAsync(iprot, cancellationToken);
Historys.Add(_elem18);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Bool)
{
HasNext = 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 void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
Gid = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractSACMElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Struct)
{
AbstractForm = new TDDIAbstractSACMElement();
AbstractForm.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct)
{
Name = new TDDIAbstractLangString();
Name.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
Description = new TDDIDescription();
Description.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
ImplementationConstraint = new List <TDDIImplementationConstraintRef>();
TList _list800 = iprot.ReadListBegin();
for (int _i801 = 0; _i801 < _list800.Count; ++_i801)
{
TDDIImplementationConstraintRef _elem802;
_elem802 = new TDDIImplementationConstraintRef();
_elem802.Read(iprot);
ImplementationConstraint.Add(_elem802);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Note = new List <TDDINoteRef>();
TList _list803 = iprot.ReadListBegin();
for (int _i804 = 0; _i804 < _list803.Count; ++_i804)
{
TDDINoteRef _elem805;
_elem805 = new TDDINoteRef();
_elem805.Read(iprot);
Note.Add(_elem805);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.List)
{
{
TaggedValue = new List <TDDITaggedValueRef>();
TList _list806 = iprot.ReadListBegin();
for (int _i807 = 0; _i807 < _list806.Count; ++_i807)
{
TDDITaggedValueRef _elem808;
_elem808 = new TDDITaggedValueRef();
_elem808.Read(iprot);
TaggedValue.Add(_elem808);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
Structure = new TDDIAbstractArgumentPackage();
Structure.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_Address = false;
bool isset_Port = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
Address = iprot.ReadString();
isset_Address = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
Port = iprot.ReadI32();
isset_Port = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_Address)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Address not set");
}
if (!isset_Port)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Port not set");
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("TDDIFailState");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (__isset.Id)
{
field.Name = "Id";
field.Type = TType.I64;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteI64(Id);
oprot.WriteFieldEnd();
}
if (Name != null && __isset.Name)
{
field.Name = "Name";
field.Type = TType.String;
field.ID = 2;
oprot.WriteFieldBegin(field);
oprot.WriteString(Name);
oprot.WriteFieldEnd();
}
if (Description != null && __isset.Description)
{
field.Name = "Description";
field.Type = TType.String;
field.ID = 3;
oprot.WriteFieldBegin(field);
oprot.WriteString(Description);
oprot.WriteFieldEnd();
}
if (__isset.IsCitation)
{
field.Name = "IsCitation";
field.Type = TType.Bool;
field.ID = 4;
oprot.WriteFieldBegin(field);
oprot.WriteBool(IsCitation);
oprot.WriteFieldEnd();
}
if (__isset.IsAbstract)
{
field.Name = "IsAbstract";
field.Type = TType.Bool;
field.ID = 5;
oprot.WriteFieldBegin(field);
oprot.WriteBool(IsAbstract);
oprot.WriteFieldEnd();
}
if (KeyValueMaps != null && __isset.KeyValueMaps)
{
field.Name = "KeyValueMaps";
field.Type = TType.List;
field.ID = 6;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, KeyValueMaps.Count));
foreach (TDDIKeyValueMapRef _iter822 in KeyValueMaps)
{
_iter822.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
if (CitedElement != null && __isset.CitedElement)
{
field.Name = "CitedElement";
field.Type = TType.Struct;
field.ID = 7;
oprot.WriteFieldBegin(field);
CitedElement.Write(oprot);
oprot.WriteFieldEnd();
}
if (__isset.FailureRate)
{
field.Name = "FailureRate";
field.Type = TType.Double;
field.ID = 8;
oprot.WriteFieldBegin(field);
oprot.WriteDouble(FailureRate);
oprot.WriteFieldEnd();
}
if (FailureMode != null && __isset.FailureMode)
{
field.Name = "FailureMode";
field.Type = TType.Struct;
field.ID = 9;
oprot.WriteFieldBegin(field);
FailureMode.Write(oprot);
oprot.WriteFieldEnd();
}
if (ProbabilityDistribution != null && __isset.ProbabilityDistribution)
{
field.Name = "ProbabilityDistribution";
field.Type = TType.Struct;
field.ID = 10;
oprot.WriteFieldBegin(field);
ProbabilityDistribution.Write(oprot);
oprot.WriteFieldEnd();
}
if (OutputFailure != null && __isset.OutputFailure)
{
field.Name = "OutputFailure";
field.Type = TType.Struct;
field.ID = 11;
oprot.WriteFieldBegin(field);
OutputFailure.Write(oprot);
oprot.WriteFieldEnd();
}
if (AssociatedStates != null && __isset.AssociatedStates)
{
field.Name = "AssociatedStates";
field.Type = TType.List;
field.ID = 12;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, AssociatedStates.Count));
foreach (TDDIState _iter823 in AssociatedStates)
{
_iter823.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list816 = iprot.ReadListBegin();
for (int _i817 = 0; _i817 < _list816.Count; ++_i817)
{
TDDIKeyValueMapRef _elem818;
_elem818 = new TDDIKeyValueMapRef();
_elem818.Read(iprot);
KeyValueMaps.Add(_elem818);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.Double)
{
FailureRate = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
FailureMode = new TDDIFailureMode();
FailureMode.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Struct)
{
ProbabilityDistribution = new TDDIProbabilityDistribution();
ProbabilityDistribution.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
OutputFailure = new TDDIOutputFailure();
OutputFailure.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
AssociatedStates = new List <TDDIState>();
TList _list819 = iprot.ReadListBegin();
for (int _i820 = 0; _i820 < _list819.Count; ++_i820)
{
TDDIState _elem821;
_elem821 = new TDDIState();
_elem821.Read(iprot);
AssociatedStates.Add(_elem821);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
{
oprot.IncrementRecursionDepth();
try
{
var tmp399 = new TStruct("FCells");
await oprot.WriteStructBeginAsync(tmp399, cancellationToken);
var tmp400 = new TField();
if ((F != null) && __isset.f)
{
tmp400.Name = "f";
tmp400.Type = TType.Map;
tmp400.ID = 1;
await oprot.WriteFieldBeginAsync(tmp400, cancellationToken);
{
await oprot.WriteMapBeginAsync(new TMap(TType.String, TType.Struct, F.Count), cancellationToken);
foreach (byte[] _iter401 in F.Keys)
{
await oprot.WriteBinaryAsync(_iter401, cancellationToken);
await F[_iter401].WriteAsync(oprot, cancellationToken);
}
await oprot.WriteMapEndAsync(cancellationToken);
}
await oprot.WriteFieldEndAsync(cancellationToken);
}
if ((Cells != null) && __isset.cells)
{
tmp400.Name = "cells";
tmp400.Type = TType.List;
tmp400.ID = 2;
await oprot.WriteFieldBeginAsync(tmp400, cancellationToken);
{
await oprot.WriteListBeginAsync(new TList(TType.Struct, Cells.Count), cancellationToken);
foreach (FCell _iter402 in Cells)
{
await _iter402.WriteAsync(oprot, cancellationToken);
}
await oprot.WriteListEndAsync(cancellationToken);
}
await oprot.WriteFieldEndAsync(cancellationToken);
}
if ((Serial_cells != null) && __isset.serial_cells)
{
tmp400.Name = "serial_cells";
tmp400.Type = TType.List;
tmp400.ID = 3;
await oprot.WriteFieldBeginAsync(tmp400, cancellationToken);
{
await oprot.WriteListBeginAsync(new TList(TType.Struct, Serial_cells.Count), cancellationToken);
foreach (FCellSerial _iter403 in Serial_cells)
{
await _iter403.WriteAsync(oprot, cancellationToken);
}
await oprot.WriteListEndAsync(cancellationToken);
}
await oprot.WriteFieldEndAsync(cancellationToken);
}
await oprot.WriteFieldStopAsync(cancellationToken);
await oprot.WriteStructEndAsync(cancellationToken);
}
finally
{
oprot.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)
{
SquareChatMid = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.List)
{
{
TList _list341 = await iprot.ReadListBeginAsync(cancellationToken);
Kickees = new List <SquareMember>(_list341.Count);
for (int _i342 = 0; _i342 < _list341.Count; ++_i342)
{
SquareMember _elem343;
_elem343 = new SquareMember();
await _elem343.ReadAsync(iprot, cancellationToken);
Kickees.Add(_elem343);
}
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
{
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 _list35 = await iprot.ReadListBeginAsync(cancellationToken);
Values = new List <short>(_list35.Count);
for (int _i36 = 0; _i36 < _list35.Count; ++_i36)
{
short _elem37;
_elem37 = await iprot.ReadI16Async(cancellationToken);
Values.Add(_elem37);
}
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 void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Id = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Description = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
IsCitation = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsAbstract = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List)
{
{
KeyValueMaps = new List <TDDIKeyValueMapRef>();
TList _list364 = iprot.ReadListBegin();
for (int _i365 = 0; _i365 < _list364.Count; ++_i365)
{
TDDIKeyValueMapRef _elem366;
_elem366 = new TDDIKeyValueMapRef();
_elem366.Read(iprot);
KeyValueMaps.Add(_elem366);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
CitedElement = new TDDIAbstractBaseElement();
CitedElement.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("TokenTransfer");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (Token != null && __isset.token)
{
field.Name = "token";
field.Type = TType.String;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteBinary(Token);
oprot.WriteFieldEnd();
}
if (Code != null && __isset.code)
{
field.Name = "code";
field.Type = TType.String;
field.ID = 2;
oprot.WriteFieldBegin(field);
oprot.WriteString(Code);
oprot.WriteFieldEnd();
}
if (Sender != null && __isset.sender)
{
field.Name = "sender";
field.Type = TType.String;
field.ID = 3;
oprot.WriteFieldBegin(field);
oprot.WriteBinary(Sender);
oprot.WriteFieldEnd();
}
if (Receiver != null && __isset.receiver)
{
field.Name = "receiver";
field.Type = TType.String;
field.ID = 4;
oprot.WriteFieldBegin(field);
oprot.WriteBinary(Receiver);
oprot.WriteFieldEnd();
}
if (Amount != null && __isset.amount)
{
field.Name = "amount";
field.Type = TType.String;
field.ID = 5;
oprot.WriteFieldBegin(field);
oprot.WriteString(Amount);
oprot.WriteFieldEnd();
}
if (Initiator != null && __isset.initiator)
{
field.Name = "initiator";
field.Type = TType.String;
field.ID = 6;
oprot.WriteFieldBegin(field);
oprot.WriteBinary(Initiator);
oprot.WriteFieldEnd();
}
if (Transaction != null && __isset.transaction)
{
field.Name = "transaction";
field.Type = TType.Struct;
field.ID = 7;
oprot.WriteFieldBegin(field);
Transaction.Write(oprot);
oprot.WriteFieldEnd();
}
if (__isset.time)
{
field.Name = "time";
field.Type = TType.I64;
field.ID = 8;
oprot.WriteFieldBegin(field);
oprot.WriteI64(Time);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("TDDIMeasureType");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (__isset.Id)
{
field.Name = "Id";
field.Type = TType.I64;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteI64(Id);
oprot.WriteFieldEnd();
}
if (Name != null && __isset.Name)
{
field.Name = "Name";
field.Type = TType.String;
field.ID = 2;
oprot.WriteFieldBegin(field);
oprot.WriteString(Name);
oprot.WriteFieldEnd();
}
if (Description != null && __isset.Description)
{
field.Name = "Description";
field.Type = TType.String;
field.ID = 3;
oprot.WriteFieldBegin(field);
oprot.WriteString(Description);
oprot.WriteFieldEnd();
}
if (__isset.IsCitation)
{
field.Name = "IsCitation";
field.Type = TType.Bool;
field.ID = 4;
oprot.WriteFieldBegin(field);
oprot.WriteBool(IsCitation);
oprot.WriteFieldEnd();
}
if (__isset.IsAbstract)
{
field.Name = "IsAbstract";
field.Type = TType.Bool;
field.ID = 5;
oprot.WriteFieldBegin(field);
oprot.WriteBool(IsAbstract);
oprot.WriteFieldEnd();
}
if (KeyValueMaps != null && __isset.KeyValueMaps)
{
field.Name = "KeyValueMaps";
field.Type = TType.List;
field.ID = 6;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, KeyValueMaps.Count));
foreach (TDDIKeyValueMapRef _iter367 in KeyValueMaps)
{
_iter367.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
if (CitedElement != null && __isset.CitedElement)
{
field.Name = "CitedElement";
field.Type = TType.Struct;
field.ID = 7;
oprot.WriteFieldBegin(field);
CitedElement.Write(oprot);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public async 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)
{
{
PerOperationStrategies = new List <OperationSamplingStrategy>();
TList _list0 = await iprot.ReadListBeginAsync(cancellationToken);
for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
{
OperationSamplingStrategy _elem2;
_elem2 = new OperationSamplingStrategy();
await _elem2.ReadAsync(iprot, cancellationToken);
PerOperationStrategies.Add(_elem2);
}
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 void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I32)
{
Tyear = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
Tmonth = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32)
{
Tday = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32)
{
Thour = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32)
{
Tminute = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I32)
{
Tsecond = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64)
{
Start = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
Size = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Language = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
Eddt = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32)
{
AppStoreCode = (PaymentType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("TimeData");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (__isset.tyear)
{
field.Name = "tyear";
field.Type = TType.I32;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteI32(Tyear);
oprot.WriteFieldEnd();
}
if (__isset.tmonth)
{
field.Name = "tmonth";
field.Type = TType.I32;
field.ID = 2;
oprot.WriteFieldBegin(field);
oprot.WriteI32(Tmonth);
oprot.WriteFieldEnd();
}
if (__isset.tday)
{
field.Name = "tday";
field.Type = TType.I32;
field.ID = 3;
oprot.WriteFieldBegin(field);
oprot.WriteI32(Tday);
oprot.WriteFieldEnd();
}
if (__isset.thour)
{
field.Name = "thour";
field.Type = TType.I32;
field.ID = 4;
oprot.WriteFieldBegin(field);
oprot.WriteI32(Thour);
oprot.WriteFieldEnd();
}
if (__isset.tminute)
{
field.Name = "tminute";
field.Type = TType.I32;
field.ID = 5;
oprot.WriteFieldBegin(field);
oprot.WriteI32(Tminute);
oprot.WriteFieldEnd();
}
if (__isset.tsecond)
{
field.Name = "tsecond";
field.Type = TType.I32;
field.ID = 6;
oprot.WriteFieldBegin(field);
oprot.WriteI32(Tsecond);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.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.I64)
{
CreatedTime = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 10:
if (field.Type == TType.String)
{
Name = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 11:
if (field.Type == TType.String)
{
PictureStatus = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 12:
if (field.Type == TType.Bool)
{
PreventedJoinByTicket = await iprot.ReadBoolAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 13:
if (field.Type == TType.Struct)
{
GroupPreference = new GroupPreference();
await GroupPreference.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 20:
if (field.Type == TType.List)
{
{
TList _list141 = await iprot.ReadListBeginAsync(cancellationToken);
Members = new List <Contact>(_list141.Count);
for (int _i142 = 0; _i142 < _list141.Count; ++_i142)
{
Contact _elem143;
_elem143 = new Contact();
await _elem143.ReadAsync(iprot, cancellationToken);
Members.Add(_elem143);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 21:
if (field.Type == TType.Struct)
{
Creator = new Contact();
await Creator.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 22:
if (field.Type == TType.List)
{
{
TList _list144 = await iprot.ReadListBeginAsync(cancellationToken);
Invitee = new List <Contact>(_list144.Count);
for (int _i145 = 0; _i145 < _list144.Count; ++_i145)
{
Contact _elem146;
_elem146 = new Contact();
await _elem146.ReadAsync(iprot, cancellationToken);
Invitee.Add(_elem146);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 31:
if (field.Type == TType.Bool)
{
NotificationDisabled = 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 void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
ApplicationType = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
ApplicationVersion = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Locale = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_column_idx = false;
bool isset_descending = false;
bool isset_nulls_first = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I32)
{
Column_idx = iprot.ReadI32();
isset_column_idx = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Bool)
{
Descending = iprot.ReadBool();
isset_descending = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Bool)
{
Nulls_first = iprot.ReadBool();
isset_nulls_first = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_column_idx)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_descending)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_nulls_first)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
DeviceId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
UserId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I64)
{
Timestamp = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Struct)
{
Trigger = new Ruyi.SDK.CommonType.ActionTrigger();
Trigger.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Bool)
{
ByAutoTrigger = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("THReceiptItem");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (ProductID != null && __isset.productID)
{
field.Name = "productID";
field.Type = TType.String;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteString(ProductID);
oprot.WriteFieldEnd();
}
if (TransactionID != null && __isset.transactionID)
{
field.Name = "transactionID";
field.Type = TType.String;
field.ID = 2;
oprot.WriteFieldBegin(field);
oprot.WriteString(TransactionID);
oprot.WriteFieldEnd();
}
if (__isset.purchaseDate)
{
field.Name = "purchaseDate";
field.Type = TType.I64;
field.ID = 3;
oprot.WriteFieldBegin(field);
oprot.WriteI64(PurchaseDate);
oprot.WriteFieldEnd();
}
if (__isset.quantity)
{
field.Name = "quantity";
field.Type = TType.I64;
field.ID = 4;
oprot.WriteFieldBegin(field);
oprot.WriteI64(Quantity);
oprot.WriteFieldEnd();
}
if (__isset.isValid)
{
field.Name = "isValid";
field.Type = TType.I64;
field.ID = 5;
oprot.WriteFieldBegin(field);
oprot.WriteI64(IsValid);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("InputActionTriggered");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (DeviceId != null && __isset.deviceId)
{
field.Name = "deviceId";
field.Type = TType.String;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteString(DeviceId);
oprot.WriteFieldEnd();
}
if (UserId != null && __isset.userId)
{
field.Name = "userId";
field.Type = TType.String;
field.ID = 2;
oprot.WriteFieldBegin(field);
oprot.WriteString(UserId);
oprot.WriteFieldEnd();
}
if (Name != null && __isset.name)
{
field.Name = "name";
field.Type = TType.String;
field.ID = 3;
oprot.WriteFieldBegin(field);
oprot.WriteString(Name);
oprot.WriteFieldEnd();
}
if (__isset.timestamp)
{
field.Name = "timestamp";
field.Type = TType.I64;
field.ID = 4;
oprot.WriteFieldBegin(field);
oprot.WriteI64(Timestamp);
oprot.WriteFieldEnd();
}
if (Trigger != null && __isset.trigger)
{
field.Name = "trigger";
field.Type = TType.Struct;
field.ID = 5;
oprot.WriteFieldBegin(field);
Trigger.Write(oprot);
oprot.WriteFieldEnd();
}
if (__isset.byAutoTrigger)
{
field.Name = "byAutoTrigger";
field.Type = TType.Bool;
field.ID = 6;
oprot.WriteFieldBegin(field);
oprot.WriteBool(ByAutoTrigger);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.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 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.Map)
{
{
TMap _map389 = await iprot.ReadMapBeginAsync(cancellationToken);
F = new Dictionary <byte[], FCells>(_map389.Count);
for (int _i390 = 0; _i390 < _map389.Count; ++_i390)
{
byte[] _key391;
FCells _val392;
_key391 = await iprot.ReadBinaryAsync(cancellationToken);
_val392 = new FCells();
await _val392.ReadAsync(iprot, cancellationToken);
F[_key391] = _val392;
}
await iprot.ReadMapEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.List)
{
{
TList _list393 = await iprot.ReadListBeginAsync(cancellationToken);
Cells = new List <FCell>(_list393.Count);
for (int _i394 = 0; _i394 < _list393.Count; ++_i394)
{
FCell _elem395;
_elem395 = new FCell();
await _elem395.ReadAsync(iprot, cancellationToken);
Cells.Add(_elem395);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.List)
{
{
TList _list396 = await iprot.ReadListBeginAsync(cancellationToken);
Serial_cells = new List <FCellSerial>(_list396.Count);
for (int _i397 = 0; _i397 < _list396.Count; ++_i397)
{
FCellSerial _elem398;
_elem398 = new FCellSerial();
await _elem398.ReadAsync(iprot, cancellationToken);
Serial_cells.Add(_elem398);
}
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();
}
}
