public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // WHY
if (field.type == TType.STRING) {
this.why = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // VALUES
if (field.type == TType.LIST) {
{
TList _list0 = iprot.readListBegin();
this.values = new ArrayList<ByteBuffer>(_list0.size);
for (int _i1 = 0; _i1 < _list0.size; ++_i1) {
ByteBuffer _elem2;
_elem2 = iprot.readBinary();
this.values.add(_elem2);
}
iprot.readListEnd();
}
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // INTERPRETATIONS
if (field.type == TType.LIST) {
{
TList _list44 = iprot.readListBegin();
this.interpretations = new ArrayList<GeocodeInterpretation>(_list44.size);
for (int _i45 = 0; _i45 < _list44.size; ++_i45) {
GeocodeInterpretation _elem46;
_elem46 = new GeocodeInterpretation();
_elem46.read(iprot);
this.interpretations.add(_elem46);
}
iprot.readListEnd();
}
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 2: // DEBUG_LINES
if (field.type == TType.LIST) {
{
TList _list47 = iprot.readListBegin();
this.debugLines = new ArrayList<String>(_list47.size);
for (int _i48 = 0; _i48 < _list47.size; ++_i48) {
String _elem49;
_elem49 = iprot.readString();
this.debugLines.add(_elem49);
}
iprot.readListEnd();
}
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 3: // REQUEST_WKT_GEOMETRY
if (field.type == TType.STRING) {
this.requestWktGeometry = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // START
if (field.type == TType.STRING) {
this.start = iprot.readBinary();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 2: // FINISH
if (field.type == TType.STRING) {
this.finish = iprot.readBinary();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 3: // REVERSED
if (field.type == TType.BOOL) {
this.reversed = iprot.readBool();
setReversedIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 4: // COUNT
if (field.type == TType.I32) {
this.count = iprot.readI32();
setCountIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
if (!isSetReversed()) {
throw new TProtocolException(
"Required field 'reversed' was not found in serialized data! Struct: " + toString());
}
if (!isSetCount()) {
throw new TProtocolException(
"Required field 'count' was not found in serialized data! Struct: " + toString());
}
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // START_TOKEN
if (field.type == TType.STRING) {
this.start_token = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 2: // END_TOKEN
if (field.type == TType.STRING) {
this.end_token = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 3: // ENDPOINTS
if (field.type == TType.LIST) {
{
TList _list16 = iprot.readListBegin();
this.endpoints = new ArrayList<String>(_list16.size);
for (int _i17 = 0; _i17 < _list16.size; ++_i17) {
String _elem18;
_elem18 = iprot.readString();
this.endpoints.add(_elem18);
}
iprot.readListEnd();
}
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
_Fields fieldId = _Fields.findByThriftId(field.id);
if (fieldId == null) {
TProtocolUtil.skip(iprot, field.type);
} else {
switch (fieldId) {
case ROW:
if (field.type == TType.STRING) {
this.row = iprot.readBinary();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case COLUMNS:
if (field.type == TType.MAP) {
{
TMap _map4 = iprot.readMapBegin();
this.columns = new HashMap<byte[], TCell>(2 * _map4.size);
for (int _i5 = 0; _i5 < _map4.size; ++_i5) {
byte[] _key6;
TCell _val7;
_key6 = iprot.readBinary();
_val7 = new TCell();
_val7.read(iprot);
this.columns.put(_key6, _val7);
}
iprot.readMapEnd();
}
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
}
iprot.readFieldEnd();
}
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // TIMESTAMP
if (field.type == TType.I64) {
this.timestamp = iprot.readI64();
setTimestampIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 2: // SUPER_COLUMN
if (field.type == TType.STRING) {
this.super_column = iprot.readBinary();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 3: // PREDICATE
if (field.type == TType.STRUCT) {
this.predicate = new SlicePredicate();
this.predicate.read(iprot);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
if (!isSetTimestamp()) {
throw new TProtocolException(
"Required field 'timestamp' was not found in serialized data! Struct: " + toString());
}
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // NAME
if (field.type == TType.STRING) {
this.name = iprot.readBinary();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 2: // COLUMNS
if (field.type == TType.LIST) {
{
TList _list0 = iprot.readListBegin();
this.columns = new ArrayList<Column>(_list0.size);
for (int _i1 = 0; _i1 < _list0.size; ++_i1) {
Column _elem2;
_elem2 = new Column();
_elem2.read(iprot);
this.columns.add(_elem2);
}
iprot.readListEnd();
}
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // RESPONSE_CODE
if (field.type == TType.I32) {
this.responseCode = iprot.readI32();
setResponseCodeIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 2: // TRANSACTION_ID
if (field.type == TType.I64) {
this.transactionID = iprot.readI64();
setTransactionIDIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 3: // DESCRIPTION
if (field.type == TType.STRING) {
this.description = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // TIMESTAMP
if (field.type == TType.I64) {
this.timestamp = iprot.readI64();
setTimestampIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 2: // WHAT
if (field.type == TType.I32) {
this.what = iprot.readI32();
setWhatIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 3: // WHY
if (field.type == TType.STRING) {
this.why = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // MESSAGE
if (field.type == TType.STRING) {
this.message = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 2: // LOG_CONTEXT
if (field.type == TType.STRING) {
this.log_context = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 3: // HANDLE
if (field.type == TType.STRUCT) {
this.handle = new QueryHandle();
this.handle.read(iprot);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // MYINT
if (field.type == TType.I32) {
this.myint = iprot.readI32();
setMyintIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 2: // MY_STRING
if (field.type == TType.STRING) {
this.myString = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 3: // UNDERSCORE_INT
if (field.type == TType.I32) {
this.underscore_int = iprot.readI32();
setUnderscore_intIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
_Fields fieldId = _Fields.findByThriftId(field.id);
if (fieldId == null) {
TProtocolUtil.skip(iprot, field.type);
} else {
switch (fieldId) {
case TRACKERS:
if (field.type == TType.LIST) {
{
TList _list39 = iprot.readListBegin();
this.trackers = new ArrayList<ThriftTaskTrackerStatus>(_list39.size);
for (int _i40 = 0; _i40 < _list39.size; ++_i40) {
ThriftTaskTrackerStatus _elem41;
_elem41 = new ThriftTaskTrackerStatus();
_elem41.read(iprot);
this.trackers.add(_elem41);
}
iprot.readListEnd();
}
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
}
iprot.readFieldEnd();
}
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
_Fields fieldId = _Fields.findByThriftId(field.id);
if (fieldId == null) {
TProtocolUtil.skip(iprot, field.type);
} else {
switch (fieldId) {
case USER:
if (field.type == TType.STRING) {
this.user = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case JOB_ID:
if (field.type == TType.STRUCT) {
this.jobID = new ThriftJobID();
this.jobID.read(iprot);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case JOB_FILE:
if (field.type == TType.STRING) {
this.jobFile = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case NAME:
if (field.type == TType.STRING) {
this.name = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case QUEUE_NAME:
if (field.type == TType.STRING) {
this.queueName = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
}
iprot.readFieldEnd();
}
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // MESSAGE
if (field.type == TType.STRING) {
this.message = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // UID
if (field.type == TType.I32) {
this.uid = iprot.readI32();
setUidIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 2: // ITEM_NUMBER
if (field.type == TType.STRING) {
this.itemNumber = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 3: // RESERVE_QUANTITY
if (field.type == TType.I32) {
this.reserveQuantity = iprot.readI32();
setReserveQuantityIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 4: // ORDER_NUMBER
if (field.type == TType.STRING) {
this.orderNumber = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 5: // FROM_ID
if (field.type == TType.STRING) {
this.fromId = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case TABLE:
if (field.type == TType.STRING) {
this.table = iprot.readString();
this.__isset.table = true;
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case KEY:
if (field.type == TType.STRING) {
this.key = iprot.readString();
this.__isset.key = true;
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case CFMAP:
if (field.type == TType.MAP) {
{
TMap _map22 = iprot.readMapBegin();
this.cfmap = new HashMap<String, List<superColumn_t>>(2 * _map22.size);
for (int _i23 = 0; _i23 < _map22.size; ++_i23) {
String _key24;
List<superColumn_t> _val25;
_key24 = iprot.readString();
{
TList _list26 = iprot.readListBegin();
_val25 = new ArrayList<superColumn_t>(_list26.size);
for (int _i27 = 0; _i27 < _list26.size; ++_i27) {
superColumn_t _elem28;
_elem28 = new superColumn_t();
_elem28.read(iprot);
_val25.add(_elem28);
}
iprot.readListEnd();
}
this.cfmap.put(_key24, _val25);
}
iprot.readMapEnd();
}
this.__isset.cfmap = true;
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case CFMAPDEL:
if (field.type == TType.MAP) {
{
TMap _map29 = iprot.readMapBegin();
this.cfmapdel = new HashMap<String, List<superColumn_t>>(2 * _map29.size);
for (int _i30 = 0; _i30 < _map29.size; ++_i30) {
String _key31;
List<superColumn_t> _val32;
_key31 = iprot.readString();
{
TList _list33 = iprot.readListBegin();
_val32 = new ArrayList<superColumn_t>(_list33.size);
for (int _i34 = 0; _i34 < _list33.size; ++_i34) {
superColumn_t _elem35;
_elem35 = new superColumn_t();
_elem35.read(iprot);
_val32.add(_elem35);
}
iprot.readListEnd();
}
this.cfmapdel.put(_key31, _val32);
}
iprot.readMapEnd();
}
this.__isset.cfmapdel = true;
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
break;
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case TASKTRACKERS:
if (field.type == TType.I32) {
this.taskTrackers = iprot.readI32();
this.__isset.taskTrackers = true;
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case MAPTASKS:
if (field.type == TType.I32) {
this.mapTasks = iprot.readI32();
this.__isset.mapTasks = true;
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case REDUCETASKS:
if (field.type == TType.I32) {
this.reduceTasks = iprot.readI32();
this.__isset.reduceTasks = true;
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case MAXMAPTASKS:
if (field.type == TType.I32) {
this.maxMapTasks = iprot.readI32();
this.__isset.maxMapTasks = true;
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case MAXREDUCETASKS:
if (field.type == TType.I32) {
this.maxReduceTasks = iprot.readI32();
this.__isset.maxReduceTasks = true;
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case STATE:
if (field.type == TType.I32) {
this.state = iprot.readI32();
this.__isset.state = true;
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
break;
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 2: // INCLUDE_TITLE
if (field.type == TType.BOOL) {
this.includeTitle = iprot.readBool();
setIncludeTitleIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 5: // INCLUDE_CONTENT_LENGTH
if (field.type == TType.BOOL) {
this.includeContentLength = iprot.readBool();
setIncludeContentLengthIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 6: // INCLUDE_CREATED
if (field.type == TType.BOOL) {
this.includeCreated = iprot.readBool();
setIncludeCreatedIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 7: // INCLUDE_UPDATED
if (field.type == TType.BOOL) {
this.includeUpdated = iprot.readBool();
setIncludeUpdatedIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 10: // INCLUDE_UPDATE_SEQUENCE_NUM
if (field.type == TType.BOOL) {
this.includeUpdateSequenceNum = iprot.readBool();
setIncludeUpdateSequenceNumIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 11: // INCLUDE_NOTEBOOK_GUID
if (field.type == TType.BOOL) {
this.includeNotebookGuid = iprot.readBool();
setIncludeNotebookGuidIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 12: // INCLUDE_TAG_GUIDS
if (field.type == TType.BOOL) {
this.includeTagGuids = iprot.readBool();
setIncludeTagGuidsIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 14: // INCLUDE_ATTRIBUTES
if (field.type == TType.BOOL) {
this.includeAttributes = iprot.readBool();
setIncludeAttributesIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 20: // INCLUDE_LARGEST_RESOURCE_MIME
if (field.type == TType.BOOL) {
this.includeLargestResourceMime = iprot.readBool();
setIncludeLargestResourceMimeIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 21: // INCLUDE_LARGEST_RESOURCE_SIZE
if (field.type == TType.BOOL) {
this.includeLargestResourceSize = iprot.readBool();
setIncludeLargestResourceSizeIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
_Fields fieldId = _Fields.findByThriftId(field.id);
if (fieldId == null) {
TProtocolUtil.skip(iprot, field.type);
} else {
switch (fieldId) {
case BYTES_TOTAL:
if (field.type == TType.I64) {
this.bytesTotal = iprot.readI64();
setBytesTotalIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case BYTES_USED:
if (field.type == TType.I64) {
this.bytesUsed = iprot.readI64();
setBytesUsedIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case BYTES_REMAINING:
if (field.type == TType.I64) {
this.bytesRemaining = iprot.readI64();
setBytesRemainingIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case BYTES_NON_DFS:
if (field.type == TType.I64) {
this.bytesNonDfs = iprot.readI64();
setBytesNonDfsIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case NUM_LIVE_DATA_NODES:
if (field.type == TType.I32) {
this.numLiveDataNodes = iprot.readI32();
setNumLiveDataNodesIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case NUM_DEAD_DATA_NODES:
if (field.type == TType.I32) {
this.numDeadDataNodes = iprot.readI32();
setNumDeadDataNodesIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case UPGRADE_STATUS:
if (field.type == TType.STRUCT) {
this.upgradeStatus = new UpgradeStatusReport();
this.upgradeStatus.read(iprot);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case HTTP_PORT:
if (field.type == TType.I32) {
this.httpPort = iprot.readI32();
setHttpPortIsSet(true);
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
}
iprot.readFieldEnd();
}
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1: // OBJECT_TYPE
if (field.type == TType.I32) {
this.objectType = HiveObjectType.findByValue(iprot.readI32());
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 2: // DB_NAME
if (field.type == TType.STRING) {
this.dbName = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 3: // OBJECT_NAME
if (field.type == TType.STRING) {
this.objectName = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 4: // PART_VALUES
if (field.type == TType.LIST) {
{
TList _list4 = iprot.readListBegin();
this.partValues = new ArrayList<String>(_list4.size);
for (int _i5 = 0; _i5 < _list4.size; ++_i5) {
String _elem6;
_elem6 = iprot.readString();
this.partValues.add(_elem6);
}
iprot.readListEnd();
}
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 5: // COLUMN_NAME
if (field.type == TType.STRING) {
this.columnName = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
validate();
}