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)
{
{
ChannelDomains_ = new List <ChannelDomain>();
TList _list79 = await iprot.ReadListBeginAsync(cancellationToken);
for (int _i80 = 0; _i80 < _list79.Count; ++_i80)
{
ChannelDomain _elem81;
_elem81 = new ChannelDomain();
await _elem81.ReadAsync(iprot, cancellationToken);
ChannelDomains_.Add(_elem81);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.I64)
{
Revision = await iprot.ReadI64Async(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.List)
{
{
ChannelDomains_ = new List <ChannelDomain>();
TList _list159 = iprot.ReadListBegin();
for (int _i160 = 0; _i160 < _list159.Count; ++_i160)
{
ChannelDomain _elem161;
_elem161 = new ChannelDomain();
_elem161.Read(iprot);
ChannelDomains_.Add(_elem161);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I64)
{
Revision = iprot.ReadI64();
}
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.List)
{
{
ChannelInfos = new List <ChannelInfo>();
TList _list167 = iprot.ReadListBegin();
for (int _i168 = 0; _i168 < _list167.Count; ++_i168)
{
ChannelInfo _elem169;
_elem169 = new ChannelInfo();
_elem169.Read(iprot);
ChannelInfos.Add(_elem169);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
ChannelDomains = new List <ChannelDomain>();
TList _list170 = iprot.ReadListBegin();
for (int _i171 = 0; _i171 < _list170.Count; ++_i171)
{
ChannelDomain _elem172;
_elem172 = new ChannelDomain();
_elem172.Read(iprot);
ChannelDomains.Add(_elem172);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I64)
{
Revision = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I64)
{
Expires = 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.String)
{
ChannelId = 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.String)
{
EntryPageUrl = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.String)
{
DescriptionText = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.Struct)
{
Provider = new ChannelProvider();
await Provider.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 7:
if (field.Type == TType.I32)
{
PublicType = (PublicType)await iprot.ReadI32Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 8:
if (field.Type == TType.String)
{
IconImage = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 9:
if (field.Type == TType.List)
{
{
TList _list36 = await iprot.ReadListBeginAsync(cancellationToken);
Permissions = new List <string>(_list36.Count);
for (int _i37 = 0; _i37 < _list36.Count; ++_i37)
{
string _elem38;
_elem38 = await iprot.ReadStringAsync(cancellationToken);
Permissions.Add(_elem38);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 11:
if (field.Type == TType.String)
{
IconThumbnailImage = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 12:
if (field.Type == TType.List)
{
{
TList _list39 = await iprot.ReadListBeginAsync(cancellationToken);
ChannelConfigurations = new List <ChannelConfiguration>(_list39.Count);
for (int _i40 = 0; _i40 < _list39.Count; ++_i40)
{
ChannelConfiguration _elem41;
_elem41 = (ChannelConfiguration)await iprot.ReadI32Async(cancellationToken);
ChannelConfigurations.Add(_elem41);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 13:
if (field.Type == TType.Bool)
{
LcsAllApiUsable = await iprot.ReadBoolAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 14:
if (field.Type == TType.Set)
{
{
TSet _set42 = await iprot.ReadSetBeginAsync(cancellationToken);
AllowedPermissions = new THashSet <ChannelPermission>(_set42.Count);
for (int _i43 = 0; _i43 < _set42.Count; ++_i43)
{
ChannelPermission _elem44;
_elem44 = (ChannelPermission)await iprot.ReadI32Async(cancellationToken);
AllowedPermissions.Add(_elem44);
}
await iprot.ReadSetEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 15:
if (field.Type == TType.List)
{
{
TList _list45 = await iprot.ReadListBeginAsync(cancellationToken);
ChannelDomains = new List <ChannelDomain>(_list45.Count);
for (int _i46 = 0; _i46 < _list45.Count; ++_i46)
{
ChannelDomain _elem47;
_elem47 = new ChannelDomain();
await _elem47.ReadAsync(iprot, cancellationToken);
ChannelDomains.Add(_elem47);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 16:
if (field.Type == TType.I64)
{
UpdatedTimestamp = await iprot.ReadI64Async(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 _list87 = await iprot.ReadListBeginAsync(cancellationToken);
ChannelInfos = new List <ChannelInfo>(_list87.Count);
for (int _i88 = 0; _i88 < _list87.Count; ++_i88)
{
ChannelInfo _elem89;
_elem89 = new ChannelInfo();
await _elem89.ReadAsync(iprot, cancellationToken);
ChannelInfos.Add(_elem89);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.List)
{
{
TList _list90 = await iprot.ReadListBeginAsync(cancellationToken);
ChannelDomains = new List <ChannelDomain>(_list90.Count);
for (int _i91 = 0; _i91 < _list90.Count; ++_i91)
{
ChannelDomain _elem92;
_elem92 = new ChannelDomain();
await _elem92.ReadAsync(iprot, cancellationToken);
ChannelDomains.Add(_elem92);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.I64)
{
Revision = await iprot.ReadI64Async(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.I64)
{
Expires = await iprot.ReadI64Async(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.List)
{
{
ChannelInfos = new List <ChannelInfo>();
TList _list48 = iprot.ReadListBegin();
for (int _i49 = 0; _i49 < _list48.Count; ++_i49)
{
ChannelInfo _elem50;
_elem50 = new ChannelInfo();
_elem50.Read(iprot);
ChannelInfos.Add(_elem50);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
ChannelDomains = new List <ChannelDomain>();
TList _list51 = iprot.ReadListBegin();
for (int _i52 = 0; _i52 < _list51.Count; ++_i52)
{
ChannelDomain _elem53;
_elem53 = new ChannelDomain();
_elem53.Read(iprot);
ChannelDomains.Add(_elem53);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I64)
{
Revision = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I64)
{
Expires = iprot.ReadI64();
}
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.String)
{
ChannelId = 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.String)
{
EntryPageUrl = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
DescriptionText = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct)
{
Provider = new ChannelProvider();
Provider.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.I32)
{
PublicType = (PublicType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
IconImage = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Permissions = new List <string>();
TList _list111 = iprot.ReadListBegin();
for (int _i112 = 0; _i112 < _list111.Count; ++_i112)
{
string _elem113;
_elem113 = iprot.ReadString();
Permissions.Add(_elem113);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.String)
{
IconThumbnailImage = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
ChannelConfigurations = new List <ChannelConfiguration>();
TList _list114 = iprot.ReadListBegin();
for (int _i115 = 0; _i115 < _list114.Count; ++_i115)
{
ChannelConfiguration _elem116;
_elem116 = (ChannelConfiguration)iprot.ReadI32();
ChannelConfigurations.Add(_elem116);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Bool)
{
LcsAllApiUsable = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.Set)
{
{
AllowedPermissions = new THashSet <ChannelPermission>();
TSet _set117 = iprot.ReadSetBegin();
for (int _i118 = 0; _i118 < _set117.Count; ++_i118)
{
ChannelPermission _elem119;
_elem119 = (ChannelPermission)iprot.ReadI32();
AllowedPermissions.Add(_elem119);
}
iprot.ReadSetEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
ChannelDomains = new List <ChannelDomain>();
TList _list120 = iprot.ReadListBegin();
for (int _i121 = 0; _i121 < _list120.Count; ++_i121)
{
ChannelDomain _elem122;
_elem122 = new ChannelDomain();
_elem122.Read(iprot);
ChannelDomains.Add(_elem122);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.I64)
{
UpdatedTimestamp = iprot.ReadI64();
}
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.String)
{
ChannelId = 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.String)
{
EntryPageUrl = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
DescriptionText = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct)
{
Provider = new ChannelProvider();
Provider.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.I32)
{
PublicType = (PublicType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String)
{
IconImage = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
Permissions = new List <string>();
TList _list36 = iprot.ReadListBegin();
for (int _i37 = 0; _i37 < _list36.Count; ++_i37)
{
string _elem38;
_elem38 = iprot.ReadString();
Permissions.Add(_elem38);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.String)
{
IconThumbnailImage = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.List)
{
{
ChannelConfigurations = new List <ChannelConfiguration>();
TList _list39 = iprot.ReadListBegin();
for (int _i40 = 0; _i40 < _list39.Count; ++_i40)
{
ChannelConfiguration _elem41;
_elem41 = (ChannelConfiguration)iprot.ReadI32();
ChannelConfigurations.Add(_elem41);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Bool)
{
LcsAllApiUsable = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.Set)
{
{
AllowedPermissions = new THashSet <ChannelPermission>();
TSet _set42 = iprot.ReadSetBegin();
for (int _i43 = 0; _i43 < _set42.Count; ++_i43)
{
ChannelPermission _elem44;
_elem44 = (ChannelPermission)iprot.ReadI32();
AllowedPermissions.Add(_elem44);
}
iprot.ReadSetEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.List)
{
{
ChannelDomains = new List <ChannelDomain>();
TList _list45 = iprot.ReadListBegin();
for (int _i46 = 0; _i46 < _list45.Count; ++_i46)
{
ChannelDomain _elem47;
_elem47 = new ChannelDomain();
_elem47.Read(iprot);
ChannelDomains.Add(_elem47);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.I64)
{
UpdatedTimestamp = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
