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.Struct)
{
this.item = new IndexItem();
this.item.Read(iprot);
this.__isset.item = true;
}
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.space_id = iprot.ReadI32();
this.__isset.space_id = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
this.part_id = iprot.ReadI32();
this.__isset.part_id = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct)
{
this.learner = new nebula.HostAddr();
this.learner.Read(iprot);
this.__isset.learner = true;
}
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.task_id = iprot.ReadI32();
this.__isset.task_id = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct)
{
this.host = new nebula.HostAddr();
this.host.Read(iprot);
this.__isset.host = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32)
{
this.status = (JobStatus)iprot.ReadI32();
this.__isset.status = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I64)
{
this.start_time = iprot.ReadI64();
this.__isset.start_time = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I64)
{
this.stop_time = iprot.ReadI64();
this.__isset.stop_time = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I32)
{
this.job_id = iprot.ReadI32();
this.__isset.job_id = true;
}
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.List)
{
{
this.items = new List <IndexItem>();
TList _list128 = iprot.ReadListBegin();
for (int _i129 = 0; _i129 < _list128.Count; ++_i129)
{
IndexItem _elem130 = new IndexItem();
_elem130 = new IndexItem();
_elem130.Read(iprot);
this.items.Add(_elem130);
}
iprot.ReadListEnd();
}
this.__isset.items = true;
}
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.I64)
{
this.id = iprot.ReadI64();
this.__isset.id = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
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 4:
if (field.Type == TType.List)
{
{
this.tasks = new List <BalanceTask>();
TList _list145 = iprot.ReadListBegin();
for (int _i146 = 0; _i146 < _list145.Count; ++_i146)
{
BalanceTask _elem147 = new BalanceTask();
_elem147 = new BalanceTask();
_elem147.Read(iprot);
this.tasks.Add(_elem147);
}
iprot.ReadListEnd();
}
this.__isset.tasks = true;
}
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.space_id = iprot.ReadI32();
this.__isset.space_id = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I64)
{
this.id = iprot.ReadI64();
this.__isset.id = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.List)
{
{
this.host_del = new List <nebula.HostAddr>();
TList _list141 = iprot.ReadListBegin();
for (int _i142 = 0; _i142 < _list141.Count; ++_i142)
{
nebula.HostAddr _elem143 = new nebula.HostAddr();
_elem143 = new nebula.HostAddr();
_elem143.Read(iprot);
this.host_del.Add(_elem143);
}
iprot.ReadListEnd();
}
this.__isset.host_del = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
this.stop = iprot.ReadBool();
this.__isset.stop = true;
}
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.parts = new Dictionary <int, List <nebula.HostAddr> >();
TMap _map82 = iprot.ReadMapBegin();
for (int _i83 = 0; _i83 < _map82.Count; ++_i83)
{
int _key84;
List <nebula.HostAddr> _val85;
_key84 = iprot.ReadI32();
{
_val85 = new List <nebula.HostAddr>();
TList _list86 = iprot.ReadListBegin();
for (int _i87 = 0; _i87 < _list86.Count; ++_i87)
{
nebula.HostAddr _elem88 = new nebula.HostAddr();
_elem88 = new nebula.HostAddr();
_elem88.Read(iprot);
_val85.Add(_elem88);
}
iprot.ReadListEnd();
}
this.parts[_key84] = _val85;
}
iprot.ReadMapEnd();
}
this.__isset.parts = true;
}
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.List)
{
{
this.values = new List <byte[]>();
TList _list99 = iprot.ReadListBegin();
for (int _i100 = 0; _i100 < _list99.Count; ++_i100)
{
byte[] _elem101 = null;
_elem101 = iprot.ReadBinary();
this.values.Add(_elem101);
}
iprot.ReadListEnd();
}
this.__isset.values = true;
}
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.List)
{
{
this.snapshots = new List <Snapshot>();
TList _list161 = iprot.ReadListBegin();
for (int _i162 = 0; _i162 < _list161.Count; ++_i162)
{
Snapshot _elem163 = new Snapshot();
_elem163 = new Snapshot();
_elem163.Read(iprot);
this.snapshots.Add(_elem163);
}
iprot.ReadListEnd();
}
this.__isset.snapshots = true;
}
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.Struct)
{
this.hostAddr = new nebula.HostAddr();
this.hostAddr.Read(iprot);
this.__isset.hostAddr = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
this.status = (HostStatus)iprot.ReadI32();
this.__isset.status = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
this.leader_parts = new Dictionary <byte[], List <int> >();
TMap _map8 = iprot.ReadMapBegin();
for (int _i9 = 0; _i9 < _map8.Count; ++_i9)
{
byte[] _key10;
List <int> _val11;
_key10 = iprot.ReadBinary();
{
_val11 = new List <int>();
TList _list12 = iprot.ReadListBegin();
for (int _i13 = 0; _i13 < _list12.Count; ++_i13)
{
int _elem14 = 0;
_elem14 = iprot.ReadI32();
_val11.Add(_elem14);
}
iprot.ReadListEnd();
}
this.leader_parts[_key10] = _val11;
}
iprot.ReadMapEnd();
}
this.__isset.leader_parts = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Map)
{
{
this.all_parts = new Dictionary <byte[], List <int> >();
TMap _map15 = iprot.ReadMapBegin();
for (int _i16 = 0; _i16 < _map15.Count; ++_i16)
{
byte[] _key17;
List <int> _val18;
_key17 = iprot.ReadBinary();
{
_val18 = new List <int>();
TList _list19 = iprot.ReadListBegin();
for (int _i20 = 0; _i20 < _list19.Count; ++_i20)
{
int _elem21 = 0;
_elem21 = iprot.ReadI32();
_val18.Add(_elem21);
}
iprot.ReadListEnd();
}
this.all_parts[_key17] = _val18;
}
iprot.ReadMapEnd();
}
this.__isset.all_parts = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32)
{
this.role = (HostRole)iprot.ReadI32();
this.__isset.role = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
this.git_info_sha = iprot.ReadBinary();
this.__isset.git_info_sha = true;
}
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.List)
{
{
this.spaces = new List <IdName>();
TList _list42 = iprot.ReadListBegin();
for (int _i43 = 0; _i43 < _list42.Count; ++_i43)
{
IdName _elem44 = new IdName();
_elem44 = new IdName();
_elem44.Read(iprot);
this.spaces.Add(_elem44);
}
iprot.ReadListEnd();
}
this.__isset.spaces = true;
}
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.role = (HostRole)iprot.ReadI32();
this.__isset.role = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct)
{
this.host = new nebula.HostAddr();
this.host.Read(iprot);
this.__isset.host = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I64)
{
this.cluster_id = iprot.ReadI64();
this.__isset.cluster_id = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Map)
{
{
this.leader_partIds = new Dictionary <int, List <int> >();
TMap _map107 = iprot.ReadMapBegin();
for (int _i108 = 0; _i108 < _map107.Count; ++_i108)
{
int _key109;
List <int> _val110;
_key109 = iprot.ReadI32();
{
_val110 = new List <int>();
TList _list111 = iprot.ReadListBegin();
for (int _i112 = 0; _i112 < _list111.Count; ++_i112)
{
int _elem113 = 0;
_elem113 = iprot.ReadI32();
_val110.Add(_elem113);
}
iprot.ReadListEnd();
}
this.leader_partIds[_key109] = _val110;
}
iprot.ReadMapEnd();
}
this.__isset.leader_partIds = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
this.git_info_sha = iprot.ReadBinary();
this.__isset.git_info_sha = true;
}
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)
{
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.part_id = iprot.ReadI32();
this.__isset.part_id = 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.List)
{
{
this.peers = new List <nebula.HostAddr>();
TList _list66 = iprot.ReadListBegin();
for (int _i67 = 0; _i67 < _list66.Count; ++_i67)
{
nebula.HostAddr _elem68 = new nebula.HostAddr();
_elem68 = new nebula.HostAddr();
_elem68.Read(iprot);
this.peers.Add(_elem68);
}
iprot.ReadListEnd();
}
this.__isset.peers = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List)
{
{
this.losts = new List <nebula.HostAddr>();
TList _list69 = iprot.ReadListBegin();
for (int _i70 = 0; _i70 < _list69.Count; ++_i70)
{
nebula.HostAddr _elem71 = new nebula.HostAddr();
_elem71 = new nebula.HostAddr();
_elem71.Read(iprot);
this.losts.Add(_elem71);
}
iprot.ReadListEnd();
}
this.__isset.losts = true;
}
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.space_id = iprot.ReadI32();
this.__isset.space_id = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
this.part_id = iprot.ReadI32();
this.__isset.part_id = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.List)
{
{
this.peers = new List <nebula.HostAddr>();
TList _list200 = iprot.ReadListBegin();
for (int _i201 = 0; _i201 < _list200.Count; ++_i201)
{
nebula.HostAddr _elem202 = new nebula.HostAddr();
_elem202 = new nebula.HostAddr();
_elem202.Read(iprot);
this.peers.Add(_elem202);
}
iprot.ReadListEnd();
}
this.__isset.peers = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
