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)
{
Name = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
Arguments = new Dictionary <string, string>();
TMap _map21 = iprot.ReadMapBegin();
for (int _i22 = 0; _i22 < _map21.Count; ++_i22)
{
string _key23;
string _val24;
_key23 = iprot.ReadString();
_val24 = iprot.ReadString();
Arguments[_key23] = _val24;
}
iprot.ReadMapEnd();
}
}
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)
{
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)
{
OrderId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
ConfirmUrl = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
Extras = new Dictionary <string, string>();
TMap _map29 = iprot.ReadMapBegin();
for (int _i30 = 0; _i30 < _map29.Count; ++_i30)
{
string _key31;
string _val32;
_key31 = iprot.ReadString();
_val32 = iprot.ReadString();
Extras[_key31] = _val32;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
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)
{
Row = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
Columns = new Dictionary <byte[], TCell>();
TMap _map4 = iprot.ReadMapBegin();
for (int _i5 = 0; _i5 < _map4.Count; ++_i5)
{
byte[] _key6;
TCell _val7;
_key6 = iprot.ReadBinary();
_val7 = new TCell();
_val7.Read(iprot);
Columns[_key6] = _val7;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.List)
{
{
SortedColumns = new List <TColumn>();
TList _list8 = iprot.ReadListBegin();
for (int _i9 = 0; _i9 < _list8.Count; ++_i9)
{
TColumn _elem10;
_elem10 = new TColumn();
_elem10.Read(iprot);
SortedColumns.Add(_elem10);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
bool isset_Headers = 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.Map)
{
{
Headers = new Dictionary <string, string>();
TMap _map0 = iprot.ReadMapBegin();
for (int _i1 = 0; _i1 < _map0.Count; ++_i1)
{
string _key2;
string _val3;
_key2 = iprot.ReadString();
_val3 = iprot.ReadString();
Headers[_key2] = _val3;
}
iprot.ReadMapEnd();
}
isset_Headers = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct)
{
Result = new ThriftSResult();
Result.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_Headers)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
public static void Skip(TProtocol prot, TType type)
{
switch (type)
{
case TType.Bool:
prot.ReadBool();
break;
case TType.Byte:
prot.ReadByte();
break;
case TType.I16:
prot.ReadI16();
break;
case TType.I32:
prot.ReadI32();
break;
case TType.I64:
prot.ReadI64();
break;
case TType.Double:
prot.ReadDouble();
break;
case TType.String:
// Don't try to decode the string, just skip it.
prot.ReadBinary();
break;
case TType.Struct:
prot.ReadStructBegin();
while (true)
{
TField field = prot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
Skip(prot, field.Type);
prot.ReadFieldEnd();
}
prot.ReadStructEnd();
break;
case TType.Map:
TMap map = prot.ReadMapBegin();
for (int i = 0; i < map.Count; i++)
{
Skip(prot, map.KeyType);
Skip(prot, map.ValueType);
}
prot.ReadMapEnd();
break;
case TType.Set:
TSet set = prot.ReadSetBegin();
for (int i = 0; i < set.Count; i++)
{
Skip(prot, set.ElementType);
}
prot.ReadSetEnd();
break;
case TType.List:
TList list = prot.ReadListBegin();
for (int i = 0; i < list.Count; i++)
{
Skip(prot, list.ElementType);
}
prot.ReadListEnd();
break;
}
}
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.Bool) {
V_bool = iprot.ReadBool();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Byte) {
V_i8 = iprot.ReadByte();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I16) {
V_i16 = iprot.ReadI16();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32) {
V_i32 = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I64) {
V_i64 = iprot.ReadI64();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Double) {
V_double = iprot.ReadDouble();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String) {
V_string = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List) {
{
V_list = new List<Variant>();
TList _list0 = iprot.ReadListBegin();
for( int _i1 = 0; _i1 < _list0.Count; ++_i1)
{
Variant _elem2;
_elem2 = new Variant();
_elem2.Read(iprot);
V_list.Add(_elem2);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Set) {
{
V_set = new THashSet<Variant>();
TSet _set3 = iprot.ReadSetBegin();
for( int _i4 = 0; _i4 < _set3.Count; ++_i4)
{
Variant _elem5;
_elem5 = new Variant();
_elem5.Read(iprot);
V_set.Add(_elem5);
}
iprot.ReadSetEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Map) {
{
V_map = new Dictionary<Variant, Variant>();
TMap _map6 = iprot.ReadMapBegin();
for( int _i7 = 0; _i7 < _map6.Count; ++_i7)
{
Variant _key8;
Variant _val9;
_key8 = new Variant();
_key8.Read(iprot);
_val9 = new Variant();
_val9.Read(iprot);
V_map[_key8] = _val9;
}
iprot.ReadMapEnd();
}
} 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)
{
Limit = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
PublicProperties = new Dictionary <string, string>();
TMap _map4 = iprot.ReadMapBegin();
for (int _i5 = 0; _i5 < _map4.Count; ++_i5)
{
string _key6;
string _val7;
_key6 = iprot.ReadString();
_val7 = iprot.ReadString();
PublicProperties[_key6] = _val7;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
PrivateProperties = new Dictionary <string, string>();
TMap _map8 = iprot.ReadMapBegin();
for (int _i9 = 0; _i9 < _map8.Count; ++_i9)
{
string _key10;
string _val11;
_key10 = iprot.ReadString();
_val11 = iprot.ReadString();
PrivateProperties[_key10] = _val11;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
TemplateName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
WhEventName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Map)
{
{
WhCustomData = new Dictionary <string, string>();
TMap _map12 = iprot.ReadMapBegin();
for (int _i13 = 0; _i13 < _map12.Count; ++_i13)
{
string _key14;
string _val15;
_key14 = iprot.ReadString();
_val15 = iprot.ReadString();
WhCustomData[_key14] = _val15;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.I64)
{
Count = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.String)
{
ReferrerEvent = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.I64)
{
BanPeriod = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.String)
{
BanReason = 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
{
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)
{
Code = (ChannelErrorCode)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Reason = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
ParameterMap = new Dictionary <string, string>();
TMap _map615 = iprot.ReadMapBegin();
for (int _i616 = 0; _i616 < _map615.Count; ++_i616)
{
string _key617;
string _val618;
_key617 = iprot.ReadString();
_val618 = iprot.ReadString();
ParameterMap[_key617] = _val618;
}
iprot.ReadMapEnd();
}
}
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)
{
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)
{
{
Cols = new List <FieldSchema>();
TList _list78 = iprot.ReadListBegin();
for (int _i79 = 0; _i79 < _list78.Count; ++_i79)
{
FieldSchema _elem80 = new FieldSchema();
_elem80 = new FieldSchema();
_elem80.Read(iprot);
Cols.Add(_elem80);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Location = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
InputFormat = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
OutputFormat = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
Compressed = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I32)
{
NumBuckets = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
SerdeInfo = new SerDeInfo();
SerdeInfo.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
BucketCols = new List <string>();
TList _list81 = iprot.ReadListBegin();
for (int _i82 = 0; _i82 < _list81.Count; ++_i82)
{
string _elem83 = null;
_elem83 = iprot.ReadString();
BucketCols.Add(_elem83);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.List)
{
{
SortCols = new List <Order>();
TList _list84 = iprot.ReadListBegin();
for (int _i85 = 0; _i85 < _list84.Count; ++_i85)
{
Order _elem86 = new Order();
_elem86 = new Order();
_elem86.Read(iprot);
SortCols.Add(_elem86);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Map)
{
{
Parameters = new Dictionary <string, string>();
TMap _map87 = iprot.ReadMapBegin();
for (int _i88 = 0; _i88 < _map87.Count; ++_i88)
{
string _key89;
string _val90;
_key89 = iprot.ReadString();
_val90 = iprot.ReadString();
Parameters[_key89] = _val90;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
SkewedInfo = new SkewedInfo();
SkewedInfo.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Bool)
{
StoredAsSubDirectories = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
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)
{
status = (Status)iprot.ReadI32();
__isset.status = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
headers = new Dictionary <string, string>();
TMap _map10 = iprot.ReadMapBegin();
for (int _i11 = 0; _i11 < _map10.Count; ++_i11)
{
string _key12;
string _val13;
_key12 = iprot.ReadString();
_val13 = iprot.ReadString();
headers[_key12] = _val13;
}
iprot.ReadMapEnd();
}
__isset.headers = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
body = iprot.ReadBinary();
__isset.body = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
var isset_sessionHandle = false;
var isset_statement = 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.Struct)
{
SessionHandle = new TSessionHandle();
SessionHandle.Read(iprot);
isset_sessionHandle = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Statement = iprot.ReadString();
isset_statement = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
ConfOverlay = new Dictionary <String, String>();
var _map81 = iprot.ReadMapBegin();
for (var _i82 = 0; _i82 < _map81.Count; ++_i82)
{
String _key83;
String _val84;
_key83 = iprot.ReadString();
_val84 = iprot.ReadString();
ConfOverlay[_key83] = _val84;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
RunAsync = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_sessionHandle)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_statement)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
public void Read(TProtocol iprot)
{
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)
{
Code = (ErrorCode)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Reason = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
ParameterMap = new Dictionary <string, string>();
TMap _map64 = iprot.ReadMapBegin();
for (int _i65 = 0; _i65 < _map64.Count; ++_i65)
{
string _key66;
string _val67;
_key66 = iprot.ReadString();
_val67 = iprot.ReadString();
ParameterMap[_key66] = _val67;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
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)
{
this.code = (ErrorCode)iprot.ReadI32();
this.__isset.code = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct)
{
this.leader = new nebula.HostAddr();
this.leader.Read(iprot);
this.__isset.leader = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
this.users = new Dictionary <byte[], byte[]>();
TMap _map132 = iprot.ReadMapBegin();
for (int _i133 = 0; _i133 < _map132.Count; ++_i133)
{
byte[] _key134;
byte[] _val135;
_key134 = iprot.ReadBinary();
_val135 = iprot.ReadBinary();
this.users[_key134] = _val135;
}
iprot.ReadMapEnd();
}
this.__isset.users = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
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)
{
ReferrerUserId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Token = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Provider = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
FirstMatch = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Map)
{
{
LinkParams = new Dictionary <string, string>();
TMap _map42 = iprot.ReadMapBegin();
for (int _i43 = 0; _i43 < _map42.Count; ++_i43)
{
string _key44;
string _val45;
_key44 = iprot.ReadString();
_val45 = iprot.ReadString();
LinkParams[_key44] = _val45;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Map)
{
{
InternalData = new Dictionary <string, string>();
TMap _map46 = iprot.ReadMapBegin();
for (int _i47 = 0; _i47 < _map46.Count; ++_i47)
{
string _key48;
string _val49;
_key48 = iprot.ReadString();
_val49 = iprot.ReadString();
InternalData[_key48] = _val49;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Bool)
{
GuaranteedMatch = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.Map)
{
{
OriginalData = new Dictionary <string, string>();
TMap _map50 = iprot.ReadMapBegin();
for (int _i51 = 0; _i51 < _map50.Count; ++_i51)
{
string _key52;
string _val53;
_key52 = iprot.ReadString();
_val53 = iprot.ReadString();
OriginalData[_key52] = _val53;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.String)
{
Debug = 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
{
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)
{
{
Squares = new List <Square>();
TList _list390 = iprot.ReadListBegin();
for (int _i391 = 0; _i391 < _list390.Count; ++_i391)
{
Square _elem392;
_elem392 = new Square();
_elem392.Read(iprot);
Squares.Add(_elem392);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
SquareStatuses = new Dictionary <string, SquareStatus>();
TMap _map393 = iprot.ReadMapBegin();
for (int _i394 = 0; _i394 < _map393.Count; ++_i394)
{
string _key395;
SquareStatus _val396;
_key395 = iprot.ReadString();
_val396 = new SquareStatus();
_val396.Read(iprot);
SquareStatuses[_key395] = _val396;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
MyMemberships = new Dictionary <string, SquareMember>();
TMap _map397 = iprot.ReadMapBegin();
for (int _i398 = 0; _i398 < _map397.Count; ++_i398)
{
string _key399;
SquareMember _val400;
_key399 = iprot.ReadString();
_val400 = new SquareMember();
_val400.Read(iprot);
MyMemberships[_key399] = _val400;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
ContinuationToken = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Map)
{
{
NoteStatuses = new Dictionary <string, NoteStatus>();
TMap _map401 = iprot.ReadMapBegin();
for (int _i402 = 0; _i402 < _map401.Count; ++_i402)
{
string _key403;
NoteStatus _val404;
_key403 = iprot.ReadString();
_val404 = new NoteStatus();
_val404.Read(iprot);
NoteStatuses[_key403] = _val404;
}
iprot.ReadMapEnd();
}
}
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.I32)
{
Code = (UniversalNotificationServiceErrorCode)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Reason = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
ParameterMap = new Dictionary <string, string>();
TMap _map620 = iprot.ReadMapBegin();
for (int _i621 = 0; _i621 < _map620.Count; ++_i621)
{
string _key622;
string _val623;
_key622 = iprot.ReadString();
_val623 = iprot.ReadString();
ParameterMap[_key622] = _val623;
}
iprot.ReadMapEnd();
}
}
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)
{
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)
{
Wait_secs = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
Num_workers = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
Num_executors = new Dictionary <string, int>();
TMap _map234 = iprot.ReadMapBegin();
for (int _i235 = 0; _i235 < _map234.Count; ++_i235)
{
string _key236;
int _val237;
_key236 = iprot.ReadString();
_val237 = iprot.ReadI32();
Num_executors[_key236] = _val237;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
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.Struct)
{
Id = new SGEntity();
Id.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
Title = new Dictionary <string, string>();
TMap _map48 = iprot.ReadMapBegin();
for (int _i49 = 0; _i49 < _map48.Count; ++_i49)
{
string _key50;
string _val51;
_key50 = iprot.ReadString();
_val51 = iprot.ReadString();
Title[_key50] = _val51;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
AvatarUrl = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32)
{
FollowersCount = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
IsFollower = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Map)
{
{
AllowedActions = new Dictionary <int, bool>();
TMap _map52 = iprot.ReadMapBegin();
for (int _i53 = 0; _i53 < _map52.Count; ++_i53)
{
int _key54;
bool _val55;
_key54 = iprot.ReadI32();
_val55 = iprot.ReadBool();
AllowedActions[_key54] = _val55;
}
iprot.ReadMapEnd();
}
}
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)
{
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)
{
TableName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
DbName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Owner = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32)
{
CreateTime = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32)
{
LastAccessTime = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I32)
{
Retention = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
Sd = new StorageDescriptor();
Sd.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
PartitionKeys = new List <FieldSchema>();
TList _list87 = iprot.ReadListBegin();
for (int _i88 = 0; _i88 < _list87.Count; ++_i88)
{
FieldSchema _elem89 = new FieldSchema();
_elem89 = new FieldSchema();
_elem89.Read(iprot);
PartitionKeys.Add(_elem89);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Map)
{
{
Parameters = new Dictionary <string, string>();
TMap _map90 = iprot.ReadMapBegin();
for (int _i91 = 0; _i91 < _map90.Count; ++_i91)
{
string _key92;
string _val93;
_key92 = iprot.ReadString();
_val93 = iprot.ReadString();
Parameters[_key92] = _val93;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
ViewOriginalText = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.String)
{
ViewExpandedText = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.String)
{
TableType = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Struct)
{
Privileges = new PrincipalPrivilegeSet();
Privileges.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read(TProtocol iprot)
{
bool isset_spouts = false;
bool isset_bolts = false;
bool isset_state_spouts = 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.Map)
{
{
Spouts = new Dictionary <string, SpoutSpec>();
TMap _map22 = iprot.ReadMapBegin();
for (int _i23 = 0; _i23 < _map22.Count; ++_i23)
{
string _key24;
SpoutSpec _val25;
_key24 = iprot.ReadString();
_val25 = new SpoutSpec();
_val25.Read(iprot);
Spouts[_key24] = _val25;
}
iprot.ReadMapEnd();
}
isset_spouts = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
Bolts = new Dictionary <string, Bolt>();
TMap _map26 = iprot.ReadMapBegin();
for (int _i27 = 0; _i27 < _map26.Count; ++_i27)
{
string _key28;
Bolt _val29;
_key28 = iprot.ReadString();
_val29 = new Bolt();
_val29.Read(iprot);
Bolts[_key28] = _val29;
}
iprot.ReadMapEnd();
}
isset_bolts = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
State_spouts = new Dictionary <string, StateSpoutSpec>();
TMap _map30 = iprot.ReadMapBegin();
for (int _i31 = 0; _i31 < _map30.Count; ++_i31)
{
string _key32;
StateSpoutSpec _val33;
_key32 = iprot.ReadString();
_val33 = new StateSpoutSpec();
_val33.Read(iprot);
State_spouts[_key32] = _val33;
}
iprot.ReadMapEnd();
}
isset_state_spouts = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_spouts)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_bolts)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_state_spouts)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_row = false;
bool isset_columns = 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)
{
Row = iprot.ReadBinary();
isset_row = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
Columns = new List <TColumnIncrement>();
TList _list35 = iprot.ReadListBegin();
for (int _i36 = 0; _i36 < _list35.Count; ++_i36)
{
TColumnIncrement _elem37;
_elem37 = new TColumnIncrement();
_elem37.Read(iprot);
Columns.Add(_elem37);
}
iprot.ReadListEnd();
}
isset_columns = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Map)
{
{
Attributes = new Dictionary <byte[], byte[]>();
TMap _map38 = iprot.ReadMapBegin();
for (int _i39 = 0; _i39 < _map38.Count; ++_i39)
{
byte[] _key40;
byte[] _val41;
_key40 = iprot.ReadBinary();
_val41 = iprot.ReadBinary();
Attributes[_key40] = _val41;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32)
{
Durability = (TDurability)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct)
{
CellVisibility = new TCellVisibility();
CellVisibility.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_row)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Row not set");
}
if (!isset_columns)
{
throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Columns not set");
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
bool isset_storm_id = false;
bool isset_executor_stats = false;
bool isset_time_secs = false;
bool isset_uptime_secs = 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)
{
Storm_id = iprot.ReadString();
isset_storm_id = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
Executor_stats = new Dictionary <ExecutorInfo, ExecutorStats>();
TMap _map213 = iprot.ReadMapBegin();
for (int _i214 = 0; _i214 < _map213.Count; ++_i214)
{
ExecutorInfo _key215;
ExecutorStats _val216;
_key215 = new ExecutorInfo();
_key215.Read(iprot);
_val216 = new ExecutorStats();
_val216.Read(iprot);
Executor_stats[_key215] = _val216;
}
iprot.ReadMapEnd();
}
isset_executor_stats = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32)
{
Time_secs = iprot.ReadI32();
isset_time_secs = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32)
{
Uptime_secs = iprot.ReadI32();
isset_uptime_secs = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_storm_id)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_executor_stats)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_time_secs)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_uptime_secs)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
public void Read(TProtocol iprot)
{
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)
{
From = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
To = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32)
{
ToType = (MIDType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
Id = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I64)
{
CreatedTime = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I64)
{
DeliveredTime = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.String)
{
Text = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
Location = new Location();
Location.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.Bool)
{
HasContent = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.I32)
{
ContentType = (ContentType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.String)
{
ContentPreview = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.Map)
{
{
ContentMetadata = new Dictionary <string, string>();
TMap _map24 = iprot.ReadMapBegin();
for (int _i25 = 0; _i25 < _map24.Count; ++_i25)
{
string _key26;
string _val27;
_key26 = iprot.ReadString();
_val27 = iprot.ReadString();
ContentMetadata[_key26] = _val27;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
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)
{
SessionId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
UserIds = new List <string>();
TList _list124 = iprot.ReadListBegin();
for (int _i125 = 0; _i125 < _list124.Count; ++_i125)
{
string _elem126;
_elem126 = iprot.ReadString();
UserIds.Add(_elem126);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Text = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
Title = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
TemplateName = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Map)
{
{
TemplateData = new Dictionary <string, string>();
TMap _map127 = iprot.ReadMapBegin();
for (int _i128 = 0; _i128 < _map127.Count; ++_i128)
{
string _key129;
string _val130;
_key129 = iprot.ReadString();
_val130 = iprot.ReadString();
TemplateData[_key129] = _val130;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
Action = new THAction();
Action.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
ActionButtons = new List <THActionButton>();
TList _list131 = iprot.ReadListBegin();
for (int _i132 = 0; _i132 < _list131.Count; ++_i132)
{
THActionButton _elem133;
_elem133 = new THActionButton();
_elem133.Read(iprot);
ActionButtons.Add(_elem133);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
Media = new THNotificationTemplateMedia();
Media.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Struct)
{
Badge = new THBadge();
Badge.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
{
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)
{
Id = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
AckType = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
AckStatus = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List)
{
{
ExtraList = new List <TimNode>();
TList _list0 = iprot.ReadListBegin();
for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
{
TimNode _elem2;
_elem2 = new TimNode();
_elem2.Read(iprot);
ExtraList.Add(_elem2);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Struct)
{
Err = new TimError();
Err.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Map)
{
{
ExtraMap = new Dictionary <string, string>();
TMap _map3 = iprot.ReadMapBegin();
for (int _i4 = 0; _i4 < _map3.Count; ++_i4)
{
string _key5;
string _val6;
_key5 = iprot.ReadString();
_val6 = iprot.ReadString();
ExtraMap[_key5] = _val6;
}
iprot.ReadMapEnd();
}
}
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)
{
PeriodDuration = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
PoolsCount = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32)
{
TransactionsCount = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Map)
{
{
BalancePerCurrency = new Dictionary <sbyte, CumulativeAmount>();
TMap _map24 = iprot.ReadMapBegin();
for (int _i25 = 0; _i25 < _map24.Count; ++_i25)
{
sbyte _key26;
CumulativeAmount _val27;
_key26 = iprot.ReadByte();
_val27 = new CumulativeAmount();
_val27.Read(iprot);
BalancePerCurrency[_key26] = _val27;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32)
{
SmartContractsCount = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I32)
{
TransactionsSmartCount = 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.String)
{
Title = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String)
{
Type = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Image = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
Url = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Map)
{
{
Additional = new Dictionary <string, string>();
TMap _map0 = iprot.ReadMapBegin();
for (int _i1 = 0; _i1 < _map0.Count; ++_i1)
{
string _key2;
string _val3;
_key2 = iprot.ReadString();
_val3 = iprot.ReadString();
Additional[_key2] = _val3;
}
iprot.ReadMapEnd();
}
}
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.Map)
{
{
MetaData = new Dictionary <string, string>();
TMap _map23 = iprot.ReadMapBegin();
for (int _i24 = 0; _i24 < _map23.Count; ++_i24)
{
string _key25;
string _val26;
_key25 = iprot.ReadString();
_val26 = iprot.ReadString();
MetaData[_key25] = _val26;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Bool)
{
ForceRegistration = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
VerificationCode = 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)
{
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)
{
{
this.plan_node_descs = new List <PlanNodeDescription>();
TList _list17 = iprot.ReadListBegin();
for (int _i18 = 0; _i18 < _list17.Count; ++_i18)
{
PlanNodeDescription _elem19 = new PlanNodeDescription();
_elem19 = new PlanNodeDescription();
_elem19.Read(iprot);
this.plan_node_descs.Add(_elem19);
}
iprot.ReadListEnd();
}
this.__isset.plan_node_descs = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
this.node_index_map = new Dictionary <long, long>();
TMap _map20 = iprot.ReadMapBegin();
for (int _i21 = 0; _i21 < _map20.Count; ++_i21)
{
long _key22;
long _val23;
_key22 = iprot.ReadI64();
_val23 = iprot.ReadI64();
this.node_index_map[_key22] = _val23;
}
iprot.ReadMapEnd();
}
this.__isset.node_index_map = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
this.format = iprot.ReadBinary();
this.__isset.format = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public static void Skip(TProtocol prot, TType type)
{
switch (type)
{
case TType.Bool:
prot.ReadBool();
break;
case TType.Byte:
prot.ReadByte();
break;
case TType.I16:
prot.ReadI16();
break;
case TType.I32:
prot.ReadI32();
break;
case TType.I64:
prot.ReadI64();
break;
case TType.Double:
prot.ReadDouble();
break;
case TType.String:
// Don't try to decode the string, just skip it.
prot.ReadBinary();
break;
case TType.Struct:
prot.ReadStructBegin();
while (true)
{
TField field = prot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
Skip(prot, field.Type);
prot.ReadFieldEnd();
}
prot.ReadStructEnd();
break;
case TType.Map:
TMap map = prot.ReadMapBegin();
for (int i = 0; i < map.Count; i++)
{
Skip(prot, map.KeyType);
Skip(prot, map.ValueType);
}
prot.ReadMapEnd();
break;
case TType.Set:
TSet set = prot.ReadSetBegin();
for (int i = 0; i < set.Count; i++)
{
Skip(prot, set.ElementType);
}
prot.ReadSetEnd();
break;
case TType.List:
TList list = prot.ReadListBegin();
for (int i = 0; i < list.Count; i++)
{
Skip(prot, list.ElementType);
}
prot.ReadListEnd();
break;
}
}
public void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct)
{
this.result = new ResponseCommon();
this.result.Read(iprot);
this.__isset.result = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map)
{
{
this.leader_parts = new Dictionary <int, List <int> >();
TMap _map191 = iprot.ReadMapBegin();
for (int _i192 = 0; _i192 < _map191.Count; ++_i192)
{
int _key193;
List <int> _val194;
_key193 = iprot.ReadI32();
{
_val194 = new List <int>();
TList _list195 = iprot.ReadListBegin();
for (int _i196 = 0; _i196 < _list195.Count; ++_i196)
{
int _elem197 = 0;
_elem197 = iprot.ReadI32();
_val194.Add(_elem197);
}
iprot.ReadListEnd();
}
this.leader_parts[_key193] = _val194;
}
iprot.ReadMapEnd();
}
this.__isset.leader_parts = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
